logigate/app/lib/logic/project.ts

239 lines
11 KiB
TypeScript
Raw Normal View History

// Reading project data from files, links and storage. Shared by the browser
// and the share-link server, so it must stay free of browser APIs.
import { cleanPuzzle } from './puzzles'
import {
CROSSING_STYLES,
FACE_INKS,
LAMP_COLORS,
PANEL_CONTROLS,
WIRE_COLORS,
type CircuitNode,
type ComponentDef,
type ConnectorType,
type FaceDesign,
type HeldState,
type PanelRow,
type Project,
type PuzzleSpec,
} from './types'
/** Drops optional node settings that are out of range, so a hand-edited file can't break the editor. */
function cleanNode(n: CircuitNode) {
if (n.hz !== undefined && !(typeof n.hz === 'number' && n.hz > 0 && n.hz <= 1000)) delete n.hz
if (n.color !== undefined && !LAMP_COLORS.includes(n.color)) delete n.color
if (n.key !== undefined && !(typeof n.key === 'string' && n.key.length === 1)) delete n.key
if (n.size !== undefined && !['sm', 'md', 'lg'].includes(n.size)) delete n.size
if (n.autoLabel !== undefined && n.autoLabel !== true) delete n.autoLabel
if (n.bits !== undefined && !(Number.isInteger(n.bits) && n.bits >= 2 && n.bits <= 32)) delete n.bits
if (n.conn !== undefined && !(typeof n.conn === 'string' && n.conn.length <= 32)) delete n.conn
if (n.attach !== undefined && typeof n.attach !== 'string') delete n.attach
if (n.skip !== undefined) {
if (Array.isArray(n.skip)) n.skip = n.skip.filter(k => typeof k === 'string').slice(0, MAX_ROWS)
else delete n.skip
}
if (n.rows !== undefined) {
if (!Array.isArray(n.rows)) delete n.rows
else n.rows = n.rows.filter(cleanRow).slice(0, MAX_ROWS)
}
if (n.plug !== undefined && typeof n.plug !== 'string') delete n.plug
if (n.latch !== undefined && typeof n.latch !== 'string') delete n.latch
if (n.pitch !== undefined && !(Number.isInteger(n.pitch) && n.pitch >= 1 && n.pitch <= 8)) delete n.pitch
if (n.offsets !== undefined && !(Array.isArray(n.offsets) && n.offsets.every(v => Number.isInteger(v) && v >= 0 && v <= 10_000))) delete n.offsets
for (const k of ['names', 'invert'] as const) {
if (n[k] !== undefined && !(Array.isArray(n[k]) && n[k]!.every(v => typeof v === 'string'))) delete n[k]
}
if (n.inner !== undefined && n.inner !== true) delete n.inner
if (n.screen !== undefined && typeof n.screen !== 'string') delete n.screen
}
const MAX_ROWS = 256
function cleanRow(r: PanelRow): boolean {
if (!r || typeof r !== 'object' || typeof r.id !== 'string' || !r.id) return false
if (!PANEL_CONTROLS.includes(r.type)) r.type = 'switch'
for (const k of ['label', 'name'] as const) if (r[k] !== undefined && typeof r[k] !== 'string') delete r[k]
if (r.on !== undefined && typeof r.on !== 'boolean') delete r.on
if (r.hz !== undefined && !(typeof r.hz === 'number' && r.hz > 0 && r.hz <= 1000)) delete r.hz
if (r.dy !== undefined && !(Number.isInteger(r.dy) && r.dy >= 0 && r.dy <= 10_000)) delete r.dy
if (r.key !== undefined && !(typeof r.key === 'string' && r.key.length === 1)) delete r.key
if (r.color !== undefined && !LAMP_COLORS.includes(r.color)) delete r.color
return true
}
const num = (v: unknown, lo: number, hi: number) => typeof v === 'number' && Number.isFinite(v) && v >= lo && v <= hi
/** A hand-drawn box: sizes and places in range, drawings of known kinds; a broken one is dropped. */
function cleanDesign(d: ComponentDef) {
const f = d.design as FaceDesign | undefined
if (!f || typeof f !== 'object' || !num(f.w, 1, 200) || !num(f.h, 1, 200)) {
delete d.design
return
}
if (f.place !== undefined) {
if (!f.place || typeof f.place !== 'object' || Array.isArray(f.place)) delete f.place
else for (const [k, v] of Object.entries(f.place)) if (!v || !num(v.x, -200, 400) || !num(v.y, -200, 400)) delete f.place[k]
}
for (const k of ['hide', 'show'] as const) if (f[k] !== undefined && !(Array.isArray(f[k]) && f[k]!.every(v => typeof v === 'string'))) delete f[k]
// Sizes, turns and pin rows: numbers in range only.
const nums = (rec: Record<string, number> | undefined, ok: (v: number) => boolean) => {
if (!rec || typeof rec !== 'object' || Array.isArray(rec)) return undefined
for (const [k, v] of Object.entries(rec)) if (!(typeof v === 'number' && ok(v))) delete rec[k]
return rec
}
if (f.scale !== undefined) f.scale = nums(f.scale, v => v >= 0.25 && v <= 4)
if (f.rotate !== undefined) f.rotate = nums(f.rotate, v => [0, 90, 180, 270].includes(v))
if (f.pinAt !== undefined) f.pinAt = nums(f.pinAt, v => Number.isInteger(v) && v >= 0 && v <= 1000)
for (const k of ['scale', 'rotate', 'pinAt'] as const) if (f[k] === undefined) delete f[k]
if (f.shapes !== undefined) {
f.shapes = Array.isArray(f.shapes)
? f.shapes
.filter(
sh =>
sh &&
typeof sh.id === 'string' &&
['line', 'rect', 'ellipse', 'text'].includes(sh.kind) &&
[sh.x, sh.y, sh.w, sh.h].every(v => num(v, -400, 400)),
)
.slice(0, 500)
: []
for (const sh of f.shapes) {
if (sh.ink !== undefined && !FACE_INKS.includes(sh.ink)) delete sh.ink
if (sh.text !== undefined && typeof sh.text !== 'string') delete sh.text
if (sh.size !== undefined && !num(sh.size, 0.25, 4)) delete sh.size
if (sh.fill !== undefined && sh.fill !== true) delete sh.fill
if (sh.rotate !== undefined && ![0, 90, 180, 270].includes(sh.rotate)) delete sh.rotate
}
}
}
BF memory: a newer save brings its own bits, bits reach the account when you leave, room for them A project that comes in with the same circuit open (a newer save from another computer, a savegame restored in place, a shared link opened again) now runs from the bits it brings. Before, the running circuit went on with this computer's old bits and wrote them over the newer ones at the next save, and a savegame could not undo Power off and on. Bits changed only by buttons or a clock are sent to the account when the page is hidden or closed, when you leave the project, and before signing out, so they are no longer lost by "remove from this browser" and reach the other computer. A running clock alone still sends nothing. Bits alone keep the project's save time, so an edit saved on another computer wins over them and they end up in its savegames. What circuits hold has its own room of 500 KB per project on top of the 2 MB limit, in the browser, the account and share links. When it is full, the circuits left longest ago start from 0; a circuit that holds more than that on its own says so once. A project can no longer become too large to load because of its memory. A savegame opened as a copy saves the project it leaves first, like every other way of switching projects. Tests now run the editor itself (in a stand-in browser with an account server) for going into components and back, reloads, two projects, other computers, savegames, signing out and the room limit. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-26 17:44:43 +00:00
/** Upper bounds for a project that comes from outside. What its circuits hold has its own room (`state`) on top of `bytes`. */
export const LIMITS = { bytes: 2_000_000, components: 2_000, nodes: 100_000, state: 500_000 }
/** Checks and normalises project data. Throws with a readable message. */
export function toProject(data: unknown): Project {
const p = data as Partial<Project>
if (!p || typeof p !== 'object' || !Array.isArray(p.components) || p.components.length === 0) {
throw new Error('Not a Logigate project (no components)')
}
if (p.components.length > LIMITS.components) throw new Error('Too many components')
let nodes = 0
for (const d of p.components) {
if (typeof d?.id !== 'string' || typeof d.name !== 'string' || !Array.isArray(d.nodes) || !Array.isArray(d.wires)) {
throw new Error('Not a Logigate project (broken component)')
}
nodes += d.nodes.length
d.symbol ??= 'box'
if (d.wide !== undefined && !(d.wide && typeof d.wide.base === 'string' && Number.isInteger(d.wide.n) && d.wide.n >= 2 && d.wide.n <= 16)) delete d.wide
if (d.design !== undefined) cleanDesign(d)
for (const n of d.nodes) cleanNode(n)
for (const w of d.wires) if (w.color && !WIRE_COLORS.includes(w.color)) delete w.color
}
if (nodes > LIMITS.nodes) throw new Error('Project too large')
return {
version: 1,
name: typeof p.name === 'string' && p.name.trim() ? p.name.trim().slice(0, 80) : 'Untitled',
components: p.components,
openId: p.components.some(d => d.id === p.openId) ? p.openId! : p.components[0]!.id,
settings: {
symbols: p.settings?.symbols === 'ansi' ? 'ansi' : 'iec',
flow: p.settings?.flow ?? true,
...(p.settings?.crossing && CROSSING_STYLES.includes(p.settings.crossing) ? { crossing: p.settings.crossing } : {}),
...(p.settings?.tidy === true ? { tidy: true } : {}),
},
solved: Array.isArray(p.solved) ? p.solved.filter(s => typeof s === 'string') : [],
...(bestOf(p.best) ? { best: bestOf(p.best)! } : {}),
...(p.mode === 'campaign' || p.mode === 'challenges' ? { mode: p.mode } : {}),
...(puzzlesOf(p.puzzles) ? { puzzles: puzzlesOf(p.puzzles)! } : {}),
...(connectorsOf(p.connectors) ? { connectors: connectorsOf(p.connectors)! } : {}),
...(stateOf(p.state, p.components) ? { state: stateOf(p.state, p.components)! } : {}),
}
}
/** Bits the circuits held: only for circuits of the project, names and gates as text; broken entries are dropped. */
function stateOf(raw: unknown, components: ComponentDef[]): Record<string, HeldState> | null {
if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return null
const ids = new Set(components.map(d => d.id))
const out: Record<string, HeldState> = {}
for (const [id, s] of Object.entries(raw as Record<string, Partial<HeldState>>)) {
if (!ids.has(id) || !s || typeof s.on !== 'string' || !Array.isArray(s.names) || !s.names.every(n => typeof n === 'string')) continue
const clocks = Array.isArray(s.clocks) ? s.clocks.filter(k => typeof k === 'string') : []
if (!s.on && !clocks.length) continue
out[id] = { names: s.names, on: s.on, ...(clocks.length ? { clocks } : {}) }
}
BF memory: a newer save brings its own bits, bits reach the account when you leave, room for them A project that comes in with the same circuit open (a newer save from another computer, a savegame restored in place, a shared link opened again) now runs from the bits it brings. Before, the running circuit went on with this computer's old bits and wrote them over the newer ones at the next save, and a savegame could not undo Power off and on. Bits changed only by buttons or a clock are sent to the account when the page is hidden or closed, when you leave the project, and before signing out, so they are no longer lost by "remove from this browser" and reach the other computer. A running clock alone still sends nothing. Bits alone keep the project's save time, so an edit saved on another computer wins over them and they end up in its savegames. What circuits hold has its own room of 500 KB per project on top of the 2 MB limit, in the browser, the account and share links. When it is full, the circuits left longest ago start from 0; a circuit that holds more than that on its own says so once. A project can no longer become too large to load because of its memory. A savegame opened as a copy saves the project it leaves first, like every other way of switching projects. Tests now run the editor itself (in a stand-in browser with an account server) for going into components and back, reloads, two projects, other computers, savegames, signing out and the room limit. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-26 17:44:43 +00:00
const kept = trimState(out)
return Object.keys(kept).length ? kept : null
}
/**
* What circuits hold, newest last, cut to LIMITS.state: the newest are kept,
* older ones that no longer fit are dropped (those circuits start from 0), so
* no amount of memory makes a project too large to load or save.
*/
export function trimState(state: Record<string, HeldState>): Record<string, HeldState> {
const ids = Object.keys(state)
const kept = new Set<string>()
let room = LIMITS.state
for (let i = ids.length - 1; i >= 0; i--) {
const id = ids[i]!
const size = id.length + JSON.stringify(state[id]).length + 4
if (size > room) continue
room -= size
kept.add(id)
}
return kept.size === ids.length ? state : Object.fromEntries(ids.filter(id => kept.has(id)).map(id => [id, state[id]!]))
}
/** Challenge records: challenge id → fewest transistors, whole non-negative numbers only. */
function bestOf(raw: unknown): Record<string, number> | null {
if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return null
const out: Record<string, number> = {}
for (const [k, v] of Object.entries(raw)) if (typeof v === 'number' && Number.isInteger(v) && v >= 0 && k.length <= 64) out[k] = v
return Object.keys(out).length ? out : null
}
/** Connector types of a project: names, colours and lines within bounds; broken ones are dropped. */
function connectorsOf(raw: unknown): ConnectorType[] | null {
if (!Array.isArray(raw)) return null
const out: ConnectorType[] = []
for (const c of raw.slice(0, 200) as Partial<ConnectorType>[]) {
if (!c || typeof c.id !== 'string' || !c.id || c.id.length > 32 || out.some(o => o.id === c.id) || !Array.isArray(c.lines)) continue
const lines = c.lines
.slice(0, 64)
.filter(l => l && typeof l.name === 'string')
.map(l => ({ name: l.name.trim().slice(0, 24) || 'line', ...(l.back === true ? { back: true } : {}) }))
out.push({
id: c.id,
name: typeof c.name === 'string' && c.name.trim() ? c.name.trim().slice(0, 40) : 'Connector',
...(c.color && WIRE_COLORS.includes(c.color) ? { color: c.color } : {}),
lines,
})
}
return out.length ? out : null
}
/** Puzzles kept in a project; broken ones are dropped. */
function puzzlesOf(raw: unknown): PuzzleSpec[] | null {
if (!Array.isArray(raw)) return null
const out: PuzzleSpec[] = []
for (const p of raw.slice(0, 200)) {
const id = (p as PuzzleSpec)?.id
if (typeof id !== 'string' || !/^(pz|week):[A-Za-z0-9-]{1,32}$/.test(id) || out.some(o => o.id === id)) continue
try {
out.push(cleanPuzzle(p, id))
} catch {}
}
return out.length ? out : null
}
export function parseProject(json: string): Project {
BF memory: a newer save brings its own bits, bits reach the account when you leave, room for them A project that comes in with the same circuit open (a newer save from another computer, a savegame restored in place, a shared link opened again) now runs from the bits it brings. Before, the running circuit went on with this computer's old bits and wrote them over the newer ones at the next save, and a savegame could not undo Power off and on. Bits changed only by buttons or a clock are sent to the account when the page is hidden or closed, when you leave the project, and before signing out, so they are no longer lost by "remove from this browser" and reach the other computer. A running clock alone still sends nothing. Bits alone keep the project's save time, so an edit saved on another computer wins over them and they end up in its savegames. What circuits hold has its own room of 500 KB per project on top of the 2 MB limit, in the browser, the account and share links. When it is full, the circuits left longest ago start from 0; a circuit that holds more than that on its own says so once. A project can no longer become too large to load because of its memory. A savegame opened as a copy saves the project it leaves first, like every other way of switching projects. Tests now run the editor itself (in a stand-in browser with an account server) for going into components and back, reloads, two projects, other computers, savegames, signing out and the room limit. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-26 17:44:43 +00:00
if (json.length > LIMITS.bytes + LIMITS.state) throw new Error('File too large')
let data: unknown
try {
data = JSON.parse(json)
} catch {
throw new Error('Not a valid JSON file')
}
return toProject(data)
}