// Editor state: the project library, the open project, selection, undo // history, share links and the running simulation of the open circuit. // One shared instance for the whole page. import { nandCounts, runSteps, stats, tableCsv, TRANSISTORS_PER_NAND, truthTable, type Stats, type TestResult, type TruthTable } from '~/lib/logic/analyze' import { bundleWires, cableEnd, cableFromPins, cableIntoPins, cablePanel, dissolveCable, pinGroups, pluggedInto, plugInto, syncCables, type PinGroup, trimCable, } from '~/lib/logic/cables' import { fitLinks, fitSpots } from '~/lib/logic/fit' import { rememberPart } from '~/lib/recent' import { checkCircuit } from '~/lib/logic/check' import { loadSoundSettings, saveSoundSettings, sfx, type Sound, type SoundSettings } from '~/lib/audio' import { challengeName, challengeOpen, defUsable, isCampaign, KIND_NAMES, kindUnlocked, NEEDS, unlockedBy } from '~/lib/logic/progress' import { apiId, makePuzzle, scoreSolution, weekKey, weeklyId } from '~/lib/logic/puzzles' import { baseOf, MAX_GATE_INPUTS, NAND_BASE, wideGate } from '~/lib/logic/wide' import { CHALLENGES, challengeSteps, type Challenge } from '~/lib/logic/challenges' import { probeValue } from '~/lib/logic/probes' import { bitsCode, codeBits, DATA_KEYS, KEY_QUEUE, putChar } from '~/lib/logic/devices' import { AUTO_TICKS, HAND_TICKS, runBench, type BenchResult } from '~/lib/logic/bench' import { EXAMPLE as ASM_EXAMPLE, loadIntoPanels } from '~/lib/asm' import { latchedTo, latchInto, latchTarget, syncLatches } from '~/lib/logic/latch' import { cleanBundle, importBundle, importProblem, LIBRARY_LIMITS, libraryBundle, ownedEntry, publishProblem, type LibraryBundle, type LibraryMeta } from '~/lib/logic/library' import { compile, INVERTIBLE, invertedPins, rowSource } from '~/lib/logic/compile' import { chipPins, MAX_BITS, panelOffsets, pinKindOf, shapeOf, type Pt } from '~/lib/logic/geometry' import { adoptName, continueSeries, newPinLabel, uniqueLabel, usedLabels } from '~/lib/logic/labels' import { attachPanel, combineIntoPanel, detachPanel, dockedPanels, insertPanelRow, mergePanels, movePanelRow, newPanelRows, offItsPins, removeRow, syncPanels } from '~/lib/logic/panels' import { addExamples, containsDef, copySelection, createProject, deleteComponent, duplicateComponent, lineForWire, lookup, makeUnique, pinKeys, mergeComponents, newComponent, packageSelection, pasteClip, pruneWires, splitPort, startChallenge, startPuzzle, swapNode, uid, unlinkWires, unpackChip, type Clip, type SwapTarget, } from '~/lib/logic/ops' import { arrangeNodes, byPosition, numberedNames, seriesLinks, type Arrange, type Link } from '~/lib/logic/bulk' import { parseProject, toProject, trimState } from '~/lib/logic/project' import { Simulator } from '~/lib/logic/sim' import { packState, stateCarry } from '~/lib/logic/state' import { cachedAccount, currentId, libraryKeys, listProjects, loadProject, migrateLegacy, newLocalId, pendingDeletes, removeProject, saveMeta, saveProject, setCachedAccount, setCurrentId, setLibraryKey, setPendingDeletes, type AccountUser, type ProjectMeta, } from '~/lib/logic/storage' import type { AsmDoc, Bench, CircuitNode, ComponentDef, ConnectorType, HeldState, LampColor, LibraryOrigin, NodeKind, Probe, PanelControl, PanelRow, PinRef, Project, PuzzleSpec, WireColor } from '~/lib/logic/types' /** A challenge check plus how many transistors the solution uses. */ /** How everyone did on a puzzle, from the server. */ export interface PuzzleSummary { players: number histogram: { t: number; n: number }[] you?: { t: number; d: number | null; rank: number } /** The best ten, named as the players chose (empty: anonymous). */ top?: { name: string; t: number; d: number | null; you?: true }[] } export type MenuPage = 'main' | 'load' | 'free' | 'campaign' | 'challenges' | 'leaderboard' export interface ChallengeCheck extends TestResult { transistors: number /** Parts this first solve made usable (campaign). */ unlocked?: string[] /** Challenges it opened. */ nextUp?: string[] /** Fewest transistors of any passing solution so far, this one included. */ best?: number /** Set when this one beat an earlier record: that record. */ record?: number } /** One pin waiting to be wired in "connect one by one". */ export interface LinkEnd { node: string pin: string dir: 'in' | 'out' label: string } export interface Placing { kind: NodeKind chip?: string /** Port: its connector type. */ conn?: string keep?: boolean } export interface View { x: number y: number zoom: number } export type LinkState = 'none' | 'viewer' | 'dirty' | 'saving' | 'saved' | 'error' const BUDGET = 300_000 function create() { // ── Library ─────────────────────────────────────────────────────── migrateLegacy() const projects = ref(listProjects()) function initial(): { meta: ProjectMeta; project: Project } { const list = listProjects() const id = currentId() for (const m of [list.find(m => m.id === id), ...list]) { if (!m) continue const p = loadProject(m.id) if (p) return { meta: m, project: p } } const project = createProject({ examples: true }) const meta: ProjectMeta = { id: newLocalId(), name: project.name, updated: Date.now(), starter: true } // The starter project of a first visit is saved only once something // changes in it. Signed in on a new device, the account's saves load // instead, so an untouched starter never becomes a second copy. placeholder = true return { meta, project } } let placeholder = false const start = initial() // The starter project of a first visit is in the list now. projects.value = listProjects() const meta = ref(start.meta) const project = ref(start.project) setCurrentId(start.meta.id) const getDef = computed(() => lookup(project.value)) const def = computed(() => getDef.value(project.value.openId) ?? project.value.components[0]!) const selection = ref([]) const wireSel = ref([]) const placing = ref(null) const nav = ref([]) const views = reactive>({}) const notice = ref<{ text: string; kind: 'ok' | 'error' } | null>(null) const labelFocus = ref(0) const showHelp = ref(false) const dialog = ref(null) /** The component whose box is being drawn in the face designer. */ const faceFor = ref(null) function designFace(defId: string) { faceFor.value = defId dialog.value = 'face' } /** Tab of the panel on the left: this circuit, or its pins. The selection has its own panel on the right. */ const panelTab = ref<'circuit' | 'pins'>('circuit') /** Whether the panel on the left is open; remembered in this browser. */ const panelOpen = ref(true) try { panelOpen.value = localStorage.getItem('logigate:panel') !== 'closed' } catch {} function togglePanel(open = !panelOpen.value) { panelOpen.value = open try { localStorage.setItem('logigate:panel', open ? 'open' : 'closed') } catch {} } /** Asks the canvas to centre on a part. */ const focusRequest = ref<{ id: string; n: number } | null>(null) /** Pins being wired one after another; `at` is the one the next click connects. */ const linking = ref<{ queue: LinkEnd[]; at: number } | null>(null) /** Project whose savegames the versions dialog shows. */ const versionsFor = ref(null) let noticeTimer: ReturnType | undefined function notify(text: string, kind: 'ok' | 'error' = 'ok') { notice.value = { text, kind } clearTimeout(noticeTimer) noticeTimer = setTimeout(() => (notice.value = null), 3500) } function clearSelection() { selection.value = [] wireSel.value = [] pinSel.value = null } // ── Picked pins ─────────────────────────────────────────────────── /** * Pins picked on one part, all inputs or all outputs (a box around them, * or Shift + click): a cable plug or wires on exactly those pins. */ const pinSel = ref<{ node: string; dir: 'in' | 'out'; pins: string[] } | null>(null) // Picking parts or wires puts picked pins down, and so does another circuit. watch([() => selection.value.length, () => wireSel.value.length], ([a, b]) => { if (a || b) pinSel.value = null }) watch(() => def.value.id, () => (pinSel.value = null)) /** Pins of a part in their order on it, top to bottom. */ function pinOrder(node: string, dir: 'in' | 'out', pins: string[]): string[] { const n = def.value.nodes.find(x => x.id === node) if (!n) return [] const all = (dir === 'in' ? shapeOf(n, getDef.value).inputs : shapeOf(n, getDef.value).outputs).map(p => p.key) return all.filter(k => pins.includes(k)) } function pickPins(node: string, dir: 'in' | 'out', pins: string[]) { selection.value = [] wireSel.value = [] const list = pinOrder(node, dir, pins) pinSel.value = list.length ? { node, dir, pins: list } : null } /** Shift + click on a pin: in or out of the picked pins (pins of another part or side start a new pick). */ function pickPin(node: string, dir: 'in' | 'out', pin: string) { const s = pinSel.value const same = s && s.node === node && s.dir === dir pickPins(node, dir, same ? (s.pins.includes(pin) ? s.pins.filter(p => p !== pin) : [...s.pins, pin]) : [pin]) } /** A cable plug on exactly the picked pins. */ function cablePicked() { const s = pinSel.value if (!s) return pinSel.value = null if (s.dir === 'out') cableOut(s.node, s.pins) else cableIn(s.node, s.pins) } /** Wire the picked pins one after another: click where each one goes. */ function linkPicked() { const s = pinSel.value const n = s && def.value.nodes.find(x => x.id === s.node) if (!s || !n) return const shape = shapeOf(n, getDef.value) const label = (k: string) => (s.dir === 'in' ? shape.inputs : shape.outputs).find(p => p.key === k)?.label ?? '' pinSel.value = null placing.value = null linking.value = { queue: s.pins.map(pin => ({ node: s.node, pin, dir: s.dir, label: label(pin) })), at: 0 } } /** Bubbles on every picked input (or off, when they all have one). */ function invertPicked() { const s = pinSel.value const n = s && s.dir === 'in' ? def.value.nodes.find(x => x.id === s.node) : undefined if (!s || !n) return const pins = s.pins.filter(p => canInvert(n, p)) if (!pins.length) return notify('These inputs can not take a bubble', 'error') const all = pins.every(p => n.invert?.includes(p)) const set = new Set(n.invert ?? []) for (const p of pins) { if (all) set.delete(p) else set.add(p) } if (set.size) n.invert = [...set] else delete n.invert commit() } /** Removes the wires on the picked pins. */ function unwirePicked() { const s = pinSel.value if (!s) return const pins = new Set(s.pins) const before = def.value.wires.length def.value.wires = def.value.wires.filter(w => !(s.dir === 'out' ? w.from.node === s.node && pins.has(w.from.pin) : w.to.node === s.node && pins.has(w.to.pin))) const n = before - def.value.wires.length commit() notify(n ? `Removed ${n} wire${n === 1 ? '' : 's'}` : 'No wires on these pins') } // ── Saving ──────────────────────────────────────────────────────── let saveTimer: ReturnType | undefined let changed = false function persistNow() { clearTimeout(saveTimer) saveTimer = undefined // An untouched starter project is not saved (see initial()). if (placeholder) return // Bits that changed on their own (a clock, a button) go to the account too, but are no // edit: the save time stays, so an edit saved on another computer still wins over them. const bitsOnly = (keepState() || unsent) && !changed unsent = false meta.value = { ...meta.value, name: project.value.name, ...(bitsOnly ? {} : { updated: Date.now() }), ...(project.value.mode ? { mode: project.value.mode } : {}), ...(changed ? { dirty: true, starter: undefined } : bitsOnly ? { dirty: true } : {}), } if (!saveProject(toRaw(meta.value), toRaw(project.value))) notify('Browser storage is full. Export your project to keep it.', 'error') projects.value = listProjects() if (changed || bitsOnly) scheduleCloud() changed = false } function persist() { placeholder = false changed = true clearTimeout(saveTimer) saveTimer = setTimeout(persistNow, 300) scheduleSync() } // ── History ─────────────────────────────────────────────────────── const snap = () => JSON.stringify({ components: project.value.components, solved: project.value.solved, connectors: project.value.connectors }) let last = snap() const undoStack: string[] = [] const redoStack: string[] = [] const canUndo = ref(false) const canRedo = ref(false) function resetHistory() { // Docked panels line up with pins that moved since the project was saved (ports went to the top), now rather than at the next edit. syncPanels(project.value) pruneWires(project.value) syncLatches(project.value) syncCables(project.value) undoStack.length = 0 redoStack.length = 0 last = snap() canUndo.value = false canRedo.value = false } /** * Record a change. Structural changes (parts, wires) rebuild the simulation. * Latched parts and cables follow every change: a moved part takes them along. */ function commit(structural = true) { if (structural) { syncPanels(project.value) pruneWires(project.value) } syncLatches(project.value) syncCables(project.value) const s = snap() if (s === last) return undoStack.push(last) if (undoStack.length > 200) undoStack.shift() redoStack.length = 0 last = s canUndo.value = true canRedo.value = false forkIfViewer() persist() if (structural) scheduleRebuild() } function restore(s: string) { const data = JSON.parse(s) as Pick project.value.components = data.components project.value.solved = data.solved if (data.connectors) project.value.connectors = data.connectors else delete project.value.connectors if (!project.value.components.some(d => d.id === project.value.openId)) project.value.openId = project.value.components[0]!.id last = s selection.value = selection.value.filter(id => def.value.nodes.some(n => n.id === id)) wireSel.value = wireSel.value.filter(id => def.value.wires.some(w => w.id === id)) canUndo.value = undoStack.length > 0 canRedo.value = redoStack.length > 0 persist() scheduleRebuild() } function undo() { const s = undoStack.pop() if (s === undefined) return redoStack.push(last) restore(s) } function redo() { const s = redoStack.pop() if (s === undefined) return undoStack.push(last) restore(s) } // ── Simulation ──────────────────────────────────────────────────── const sim = shallowRef(null) let simRoot = '' const tick = ref(0) const status = ref<'stable' | 'busy' | 'oscillating'>('stable') const running = ref(true) const hz = ref(2) const cycles = ref(0) const errors = ref([]) const circuitStats = ref({ nands: 0, sequential: false, delay: 0 }) const pressed = new Set() // Terminals and keyboards (see "Text in and out" below). /** What each terminal shows and the keys waiting in each keyboard, by part id; not saved. */ const screens = shallowRef(new Map()) const keyQueues = shallowRef(new Map()) /** Goes up when a screen or a queue changes. */ const devVersion = ref(0) /** The keyboard the keys you type go into. */ const typingInto = ref(null) let devTerms: string[] = [] let devKbs: string[] = [] /** Each strobe pin's level when last looked at, to act on a rise. */ const levels = new Map() function rebuild() { const d = def.value const nl = compile(getDef.value, d.id) const key = `${meta.value.id}/${d.id}` // The circuit running goes on as it is; one opened starts from what it held when it was last open. const held = project.value.state?.[d.id] const carry = sim.value && simRoot === key ? sim.value.carry() : held && stateCarry(held, nl) const s = new Simulator(nl, carry) for (const n of d.nodes) { if (n.kind === 'input') s.setSource(n.id, !!n.on) else if (n.kind === 'button') s.setSource(n.id, pressed.has(n.id)) else if (n.kind === 'panel') { for (const r of n.rows ?? []) { const key = rowSource(n.id, r.id) if (r.type === 'switch') s.setSource(key, !!r.on) else if (r.type === 'button') s.setSource(key, pressed.has(key)) } } } scheduleBenches() devTerms = d.nodes.filter(n => n.kind === 'terminal').map(n => n.id) devKbs = d.nodes.filter(n => n.kind === 'keyboard').map(n => n.id) if (!devKbs.includes(typingInto.value ?? '')) typingInto.value = null for (const id of devKbs) feedKeyboard(id, s) s.run(BUDGET) // Where the strobes start: only a rise from here on acts. for (const id of devTerms) for (const pin of ['wr', 'clr']) levels.set(`${id}:${pin}`, s.pin(id, pin)) for (const id of devKbs) levels.set(`${id}:next`, s.pin(id, 'next')) if (simRoot !== key) cycles.value = 0 sim.value = s simRoot = key errors.value = nl.errors circuitStats.value = stats(nl) tick.value++ } /** * Puts what the open circuit holds (its latches, flip-flops and memory) in * the project, so it starts from there when it is opened again, here or * after loading. Not an undo step. True when that changed. */ function keepState(): boolean { const s = sim.value const id = def.value.id if (!s || simRoot !== `${meta.value.id}/${id}`) return false const held = packState(s) const before = project.value.state?.[id] if (JSON.stringify(held) === JSON.stringify(before)) return false setHeld(id, held) if (held && !project.value.state?.[id]) { // More than a project keeps: said once, and the circuit starts from 0 when it opens again. if (!full.has(id)) notify('This circuit holds too many bits to keep: it starts from 0 when it opens again', 'error') full.add(id) return !!before } return true } /** Circuits whose bits were too many to keep, so that is said only once. */ const full = new Set() /** What a circuit holds in the project, as the newest entry; undefined forgets it. The oldest go when there are too many bits. */ function setHeld(id: string, held: HeldState | undefined) { const state = { ...project.value.state } delete state[id] if (held) state[id] = held const kept = trimState(state) if (Object.keys(kept).length) project.value.state = kept else delete project.value.state } /** Bits put in this browser's copy that the account does not have yet. */ let unsent = false /** * What the open circuit holds, put in this browser's copy between saves * (a clock running, a button pressed) without counting as an edit: no undo * step, and the save time stays, so an edit saved on another computer wins * over bits alone. The account gets them when the page is left (`leaving`), * never just because a clock runs. A save that is due happens now instead. * A save made since in another tab is never overwritten for the bits alone. */ function saveState(leaving = false) { if (saveTimer) return persistNow() const saved = listProjects().find(m => m.id === meta.value.id) if (placeholder || saved?.updated !== meta.value.updated) return const held = keepState() unsent ||= held const send = leaving && unsent if (!held && !send) return if (send) { meta.value = { ...meta.value, dirty: true } unsent = false } saveProject(toRaw(meta.value), toRaw(project.value)) if (send) scheduleCloud() } /** Power off and on: the open circuit forgets what it held and starts again from all zeros. */ function resetState() { setHeld(def.value.id, undefined) simRoot = '' rebuild() persist() notify('Powered off and on: every bit starts from 0 again') } let rebuildQueued = false function scheduleRebuild() { if (rebuildQueued) return rebuildQueued = true queueMicrotask(() => { rebuildQueued = false rebuild() }) } /** Value at a pin of the open circuit. Reactive through `tick`. */ function val(nodeId: string, pin: string): number { void tick.value return sim.value?.pin(nodeId, pin) ?? 0 } /** Value at a lamp or display inside a chip of the open circuit. */ function faceVal(chipNode: string, inner: string, pin: string): number { void tick.value return sim.value?.face(chipNode, inner, pin) ?? 0 } let raf = 0 // ── Text in and out ─────────────────────────────────────────────── function rose(id: string, pin: string, v: number) { const k = `${id}:${pin}` const before = levels.get(k) ?? v levels.set(k, v) return v === 1 && before === 0 } /** A keyboard's outputs: the first waiting key on D0–D7, RDY while there is one. */ function feedKeyboard(id: string, s = sim.value) { if (!s) return const q = keyQueues.value.get(id) ?? [] const bits = codeBits(q[0] ?? 0) DATA_KEYS.forEach((k, i) => s.setSource(`${id}:${k}`, bits[i] === 1)) s.setSource(`${id}:rdy`, q.length > 0) } /** Acts on the strobes of terminals and keyboards; called whenever the circuit has settled. */ function devices() { const s = sim.value if (!s || (!devTerms.length && !devKbs.length)) return let changed = false for (const id of devTerms) { if (rose(id, 'clr', s.pin(id, 'clr'))) { screens.value.set(id, ['']) changed = true } if (rose(id, 'wr', s.pin(id, 'wr'))) { screens.value.set(id, putChar(screens.value.get(id) ?? [], bitsCode(DATA_KEYS.map(k => s.pin(id, k))))) changed = true } } for (const id of devKbs) { if (rose(id, 'next', s.pin(id, 'next'))) { const q = keyQueues.value.get(id) if (q?.length) { q.shift() feedKeyboard(id, s) changed = true } } } if (changed) devVersion.value++ } /** Starts (or stops) typing into a keyboard. */ function typeInto(id: string | null) { typingInto.value = id && typingInto.value !== id ? id : null } /** A key typed into the keyboard being typed into. */ function typeKey(code: number) { const id = typingInto.value if (!id) return const q = keyQueues.value.get(id) ?? [] if (q.length >= KEY_QUEUE) { play('error') return notify(`The keyboard holds ${KEY_QUEUE} keys: let the circuit take some (NEXT)`, 'error') } q.push(code) keyQueues.value.set(id, q) feedKeyboard(id) devVersion.value++ } function clearScreen(id: string) { screens.value.set(id, ['']) devVersion.value++ } function clearKeys(id: string) { keyQueues.value.set(id, []) feedKeyboard(id) devVersion.value++ } // ── Logic analyzer ──────────────────────────────────────────────── /** The analyzer panel is open. */ const analyzerOpen = ref(false) /** What the watched signals were, oldest first: one sample per clock half-step, and on every other change. */ const trace = shallowRef<{ cycle: number; vals: number[]; edge: boolean }[]>([]) const traceVersion = ref(0) const TRACE_MAX = 1000 let traceKey = '' /** Takes a sample of the watched signals; without `edge`, only when one of them changed. */ function sample(edge = false) { const s = sim.value const d = def.value const ps = d.probes if (!s || !ps?.length) return // Other signals (or another circuit): start over. const key = `${d.id}|${ps.map(p => `${p.node}:${p.pin}`).join(',')}` if (key !== traceKey) { traceKey = key trace.value = [] } const vals = ps.map(p => probeValue(d, p, (n, pin) => s.pin(n, pin))) const list = trace.value const last = list[list.length - 1] if (!edge && last && last.vals.every((v, i) => v === vals[i])) return list.push({ cycle: cycles.value, vals, edge }) if (list.length > TRACE_MAX) list.splice(0, list.length - TRACE_MAX) traceVersion.value++ } function clearTrace() { trace.value = [] traceVersion.value++ sample(true) } /** Watches a signal in the analyzer (and opens it). */ function watchSignal(p: Probe | null) { if (!p) return const d = def.value if (!(d.probes ?? []).some(x => x.node === p.node && x.pin === p.pin)) { d.probes = [...(d.probes ?? []), { node: p.node, pin: p.pin }] commit(false) } analyzerOpen.value = true nextTick(() => sample(true)) } function unwatch(i: number) { const d = def.value if (!d.probes) return d.probes = d.probes.filter((_, k) => k !== i) if (!d.probes.length) delete d.probes commit(false) } function startLoop() { let lastT = performance.now() let acc: number[] = [] let unsettled = 0 let lastChanges = -1 const frame = (t: number) => { const dt = Math.min(100, t - lastT) lastT = t const s = sim.value if (s) { let rises = 0 let tickHz = 0 const n = s.nl.clocks.length if (running.value && n) { if (acc.length !== n) acc = new Array(n).fill(0) // Ticks count the first clock that follows the top-bar speed (or the first clock). const counted = Math.max(0, s.nl.clockHz.indexOf(0)) tickHz = s.nl.clockHz[counted] || hz.value const fastest: number[] = [] for (let i = 0; i < n; i++) { const f = s.nl.clockHz[i] || hz.value if (f <= 0) { fastest.push(i) continue } acc[i]! += dt const half = 500 / f for (let k = 0; acc[i]! >= half && k < 16; k++) { acc[i]! -= half s.run(BUDGET) sample(true) devices() if (s.toggleClock(i) && i === counted) rises++ } if (acc[i]! > half) acc[i] = 0 } if (fastest.length) { const end = performance.now() + 10 while (performance.now() < end) { if (!s.run(BUDGET)) break devices() for (const i of fastest) if (s.toggleClock(i) && i === counted) rises++ } } } if (rises) cycles.value += rises if (rises && sound.value.ticks && tickHz > 0 && tickHz <= 8) play('tick') const settled = s.run(BUDGET) unsettled = settled ? 0 : unsettled + 1 status.value = settled ? 'stable' : unsettled > 30 ? 'oscillating' : 'busy' if (s.changes !== lastChanges) { lastChanges = s.changes if (settled) { sample() devices() } tick.value++ } } raf = requestAnimationFrame(frame) } raf = requestAnimationFrame(frame) return () => cancelAnimationFrame(raf) } /** One full clock cycle (rise and fall), each half settled. */ function step() { const s = sim.value if (!s) return s.run(BUDGET) if (s.clock) { s.setClock(0) s.run(BUDGET) } sample(true) devices() s.setClock(1) s.run(BUDGET) cycles.value++ sample(true) devices() s.setClock(0) s.run(BUDGET) sample(true) devices() tick.value++ } // ── Navigation ──────────────────────────────────────────────────── // Every step to another circuit is also an entry in the browser's history, // so its back and forward (the mouse's side buttons, Alt + ← →, the // browser's buttons) go through the circuits the way they were visited, // the crumbs along with them. /** Where the editor is, as kept in a browser history entry. */ interface NavEntry { /** Project, open circuit, and the crumbs to it. */ p: string id: string nav: string[] /** Steps from the first entry the editor wrote. */ i: number } const browserHistory = typeof history !== 'undefined' && typeof history.pushState === 'function' const entryNow = () => (history.state as { lg?: NavEntry } | null)?.lg /** Going back or forward to an entry: what that changes is written into it, not as a new one. */ let restoring = false /** Writes where the editor is into the browser's history: as a new entry (`push`), or into the current one. */ function record(push: boolean) { if (!browserHistory) return push &&= !restoring const i = (entryNow()?.i ?? 0) + (push ? 1 : 0) // Whatever else the entry holds (the router's own bookkeeping) stays as it is. const state = { ...(history.state ?? {}), lg: { p: meta.value.id, id: def.value.id, nav: [...nav.value], i } satisfies NavEntry } if (push) history.pushState(state, '') else history.replaceState(state, '') } /** Shows another circuit; what the one left was holding is kept for when it opens again. */ function show(id: string) { if (id === def.value.id || !getDef.value(id)) return keepState() project.value.openId = id clearSelection() placing.value = null linking.value = null persist() rebuild() } /** Shows a circuit with the crumbs to it: a new step in the browser's history when it is another circuit. */ function go(id: string, crumbs: string[]) { if (!getDef.value(id)) return const moved = id !== def.value.id nav.value = crumbs show(id) record(moved) } /** Goes into a circuit, one step further along the way. */ function open(id: string) { if (id !== def.value.id) go(id, [...nav.value, def.value.id]) } /** The browser went back or forward (or reloaded): to the circuit of that entry, in its project, as far as they still exist. */ function restoreEntry(s: NavEntry | undefined) { if (!s) return restoring = true try { if (s.p !== meta.value.id && listProjects().some(m => m.id === s.p)) switchProject(s.p) if (s.p === meta.value.id && getDef.value(s.id)) { nav.value = s.nav.filter(id => getDef.value(id) && id !== s.id) show(s.id) } record(false) } finally { restoring = false } } /** One step back along the crumbs. */ function back() { goTo(nav.value.length - 1) } /** The project's top circuit: "main", or else the first one no other circuit uses. */ const mainId = computed(() => { const list = project.value.components if (list.some(d => d.id === 'main')) return 'main' const used = new Set(list.flatMap(d => d.nodes.filter(n => n.kind === 'chip' && n.chip).map(n => n.chip!))) return (list.find(d => !used.has(d.id) && !d.challenge) ?? list[0]!).id }) /** Back to the top circuit; the crumbs are forgotten, the browser's back still leads where you were. */ function goMain() { go(mainId.value, []) } /** Back to step `i` of the way here (0 is where it started). */ function goTo(i: number) { const id = nav.value[i] if (id) go(id, nav.value.slice(0, i)) } // ── Editing ─────────────────────────────────────────────────────── /** Asks the canvas to open quick add in its middle (search in the parts bar). */ const partSearch = ref(0) /** A part being dragged in from the parts list, so the canvas can show where it would connect. */ const dragPart = ref(null) /** Places a part; `links` are wires to make at once, with "ghost" standing for the new part. */ function addNode(p: Placing, x: number, y: number, links: Link[] = []): CircuitNode { const node: CircuitNode = { id: uid('n'), kind: p.kind, x, y } if (p.chip) node.chip = p.chip if (p.conn) node.conn = p.conn if (p.kind === 'input' || p.kind === 'output') { node.label = newPinLabel(def.value, p.kind) node.autoLabel = true } if (p.kind === 'note') node.label = 'Note' if (p.kind === 'tag') { node.label = uniqueLabel('SIG', usedLabels(def.value, 'signal')) node.autoLabel = true } // A new reference uses the signal sent last. if (p.kind === 'ref') node.label = def.value.nodes.filter(n => n.kind === 'tag' && n.label?.trim()).at(-1)?.label?.trim() ?? '' if (p.kind === 'panel' || p.kind === 'outpanel') node.rows = newPanelRows() if (p.kind === 'bundle' || p.kind === 'split') node.bits = 4 if (p.kind === 'bench') { node.bench = { rows: [] } // Dropped on (or next to) a component: docks below it. const chip = benchSpot(x, y) if (chip) dockAt(node, chip) } // A new pixel is like the one placed last: building a colour screen, every pixel comes in colour. if (p.kind === 'pixel' && def.value.nodes.findLast(n => n.kind === 'pixel')?.rgb) node.rgb = true def.value.nodes.push(node) rememberPart(p.kind, p.chip) const swap = (r: PinRef) => (r.node === 'ghost' ? { node: node.id, pin: r.pin } : r) const made = links.filter(l => addWire(swap(l.from), swap(l.to))).length selection.value = [node.id] wireSel.value = [] commit() play(made ? 'connect' : 'place') if (made) notify(`Placed and connected ${made} wire${made === 1 ? '' : 's'}`) return node } function canPlace(chipId: string) { const d = getDef.value(chipId) return !containsDef(project.value, chipId, def.value.id) && (!d || defUsable(project.value, d)) } /** In a campaign, basic parts are earned; elsewhere everything can be placed. */ function canPlaceKind(kind: NodeKind) { return kindUnlocked(project.value, kind) } // ── Sound ───────────────────────────────────────────────────────── const sound = ref(loadSoundSettings()) function play(s: Sound) { sfx(s, sound.value) } function setSound(patch: Partial) { sound.value = { ...sound.value, ...patch } saveSoundSettings(sound.value) if (patch.on || patch.volume !== undefined) play('on') } /** What a pin plugs into: '' a single wire, 'bus' a cable end, 'c:' a port of that connector type. Wires join pins of one kind. */ function pinKind(nodeId: string, pin: string, dir: 'in' | 'out'): string { const n = def.value.nodes.find(x => x.id === nodeId) if (!n) return '' const s = shapeOf(n, getDef.value) const p = (dir === 'in' ? s.inputs : s.outputs).find(p => p.key === pin) return p ? pinKindOf(p) : '' } /** True when the pin is a cable end or a port. */ const isBus = (nodeId: string, pin: string, dir: 'in' | 'out') => pinKind(nodeId, pin, dir) !== '' /** Adds one wire (replacing whatever fed that input) without recording an undo step. False for a cable/wire mismatch. */ function addWire(from: PinRef, to: PinRef, pts?: Pt[]): boolean { const d = def.value if (pinKind(from.node, from.pin, 'out') !== pinKind(to.node, to.pin, 'in')) return false const old = d.wires.find(w => w.to.node === to.node && w.to.pin === to.pin) d.wires = d.wires.filter(w => w !== old) const wire: (typeof d.wires)[number] = { id: uid('w'), from, to } if (pts?.length) wire.pts = pts const sameNet = d.wires.find(w => w.from.node === from.node && w.from.pin === from.pin && w.color) if (sameNet?.color) wire.color = sameNet.color d.wires.push(wire) // An unnamed switch, lamp or pin takes the name of the component pin it now connects to. const fn = d.nodes.find(n => n.id === from.node) const tn = d.nodes.find(n => n.id === to.node) if (fn && tn) { adoptName(d, fn, from.pin, tn, to.pin, getDef.value) adoptName(d, tn, to.pin, fn, from.pin, getDef.value) } return true } /** Why two pins can't be joined, in words. */ function mismatch(from: PinRef, to: PinRef): string { const name = (k: string) => (k.startsWith('c:') ? (getDef.value.conn?.(k.slice(2))?.name ?? 'connector') : '') const a = name(pinKind(from.node, from.pin, 'out')) const b = name(pinKind(to.node, to.pin, 'in')) if (a || b) return a && b ? `A ${a} port only plugs into a ${a} port, not ${b}` : `A ${a || b} port only takes a ${a || b} cable from another ${a || b} port` return 'A cable runs from a bundle to a split; single wires go to the bundle’s and split’s side pins' } function connect(from: PinRef, to: PinRef, pts?: Pt[]) { if (!addWire(from, to, pts)) { play('error') return notify(mismatch(from, to), 'error') } wireSel.value = [] commit() play('connect') } /** * Moves a wire's end to another pin: the wire now runs from `from` to * `to`, keeping its colour. An input that had a wire gets this one instead. */ function rewire(wireId: string, from: PinRef, to: PinRef) { const d = def.value const old = d.wires.find(w => w.id === wireId) if (!old) return if (old.from.node === from.node && old.from.pin === from.pin && old.to.node === to.node && old.to.pin === to.pin) return if (pinKind(from.node, from.pin, 'out') !== pinKind(to.node, to.pin, 'in')) { play('error') return notify(mismatch(from, to), 'error') } d.wires = d.wires.filter(w => w !== old) addWire(from, to) const made = d.wires[d.wires.length - 1]! if (old.color && !made.color) made.color = old.color wireSel.value = [made.id] selection.value = [] commit() play('connect') } /** Several wires as one undo step. */ function connectMany(links: Link[]) { const made = links.filter(l => addWire(l.from, l.to)).length if (!made) return wireSel.value = [] commit() play('connect') if (made > 1) notify(`Connected ${made} wires`) } /** Asks the canvas for the open circuit as a sheet: printed (or saved as PDF), or as an SVG file. */ const sheetRequest = ref<{ mode: 'print' | 'svg'; n: number } | null>(null) function exportSheet(mode: 'print' | 'svg') { sheetRequest.value = { mode, n: (sheetRequest.value?.n ?? 0) + 1 } } /** What looks wrong in the open circuit, worst first; a loop that never settles too. */ const issues = computed(() => { const list = checkCircuit(def.value, getDef.value) if (status.value === 'oscillating') list.unshift({ level: 'warn', text: 'The circuit keeps changing: a loop that never settles', nodes: [] }) return list }) /** Shows the parts of a problem: selects them and centres on the first. */ function showIssue(nodes: string[]) { if (!nodes.length) return focusNode(nodes[0]!) selection.value = nodes } /** Where the selected parts fit as a group (green boxes on the canvas), nearest first. */ const fits = computed(() => (selection.value.length < 2 ? [] : fitSpots(def.value, getDef.value, selection.value))) /** The fit pointed at: which spot, and its first pin. */ const fitHover = ref<{ spot: number; start: number } | null>(null) watch(fits, () => (fitHover.value = null)) function connectFit(spot: number, start: number) { const s = fits.value[spot] if (!s) return fitHover.value = null connectMany(fitLinks(s, start)) } /** * The selected parts to another part's pins, in order: their outputs to * its inputs (dir 'out'), or its outputs to their inputs (dir 'in'). */ function connectSelectionTo(targetId: string, dir: 'in' | 'out') { const target = def.value.nodes.find(n => n.id === targetId) const first = def.value.nodes.filter(n => selection.value.includes(n.id) && n.id !== targetId).sort(byPosition)[0] if (!target || !first) return const mine = dir === 'out' ? pinKeys(first, getDef.value).outs[0] : pinKeys(first, getDef.value).ins[0] const theirs = dir === 'out' ? pinKeys(target, getDef.value).ins[0] : pinKeys(target, getDef.value).outs[0] if (!mine || !theirs) return notify('No matching pins to connect', 'error') connectMany(seriesLinks(def.value, getDef.value, selection.value, { node: first.id, pin: mine, dir }, { node: target.id, pin: theirs })) } /** Parts plus the panels docked to them: they move, copy and delete together. */ function withDocked(ids: Iterable): Set { const set = new Set(ids) for (const p of dockedPanels(def.value, set)) set.add(p.id) return set } /** What moves along when parts move: docked panels and plugged-in cable ends, and what is plugged into those. */ function withFollowers(ids: Iterable): Set { const set = new Set(ids) for (let size = -1; size !== set.size; ) { size = set.size for (const p of [...dockedPanels(def.value, set), ...pluggedInto(def.value, set), ...latchedTo(def.value, set)]) set.add(p.id) for (const n of def.value.nodes) if (n.bench?.on && set.has(n.bench.on)) set.add(n.id) } return set } function deleteSelected() { const d = def.value if (!selection.value.length && !wireSel.value.length) return const ids = withDocked(selection.value) const wires = new Set(wireSel.value) d.nodes = d.nodes.filter(n => !ids.has(n.id)) d.wires = d.wires.filter(w => !ids.has(w.from.node) && !ids.has(w.to.node) && !wires.has(w.id)) clearSelection() commit() play('delete') } const selectedWires = computed(() => { const ids = new Set(wireSel.value) return def.value.wires.filter(w => ids.has(w.id)) }) function setWireColor(color: WireColor | undefined) { for (const w of selectedWires.value) { if (color) w.color = color else delete w.color } commit(false) } function autoRoute() { for (const w of selectedWires.value) delete w.pts commit(false) } /** Select every wire that carries the same signal (same source pin). */ function selectNet(wireId: string) { const w = def.value.wires.find(x => x.id === wireId) if (!w) return wireSel.value = def.value.wires.filter(x => x.from.node === w.from.node && x.from.pin === w.from.pin).map(x => x.id) } function swap(nodeId: string, target: SwapTarget) { const removed = swapNode(project.value, def.value, nodeId, target) commit() if (removed) notify(`Swapped. ${removed} wire${removed === 1 ? '' : 's'} had no matching pin and were removed.`) } /** Gives a placed gate `n` inputs, by swapping in its wide version (made on first use). */ function setInputs(node: CircuitNode, n: number) { const base = baseOf(node, getDef.value) if (!base) return if (base !== NAND_BASE && containsDef(project.value, base, def.value.id)) return notify('A component cannot contain itself', 'error') const target = wideGate(project.value, base, Math.round(n)) if (!target) return notify(`Gates can have 2 to ${MAX_GATE_INPUTS} inputs`, 'error') if (target.kind === 'chip' && target.chip === node.chip) return if (target.kind === 'nand' && node.kind === 'nand') return swap(node.id, target) } function unlink(ids: string[]) { const n = unlinkWires(def.value, new Set(ids)) commit() notify(n ? `Removed ${n} wire${n === 1 ? '' : 's'}` : 'Nothing was connected') } function unpack(nodeId: string) { const res = unpackChip(project.value, def.value.id, nodeId) if (!res.ok) return notify(res.error, 'error') selection.value = res.nodes wireSel.value = [] commit() if (res.dropped) notify(`Unpacked. ${res.dropped} wire${res.dropped === 1 ? '' : 's'} on split lines had nowhere to go and ${res.dropped === 1 ? 'was' : 'were'} removed.`) } /** Splits a port on a placed component's box into a pin per line, or joins it into its socket again (the wires on its lines go). */ function toggleSplit(n: CircuitNode, port: string) { const removed = splitPort(project.value, def.value, n.id, port, !n.splitPorts?.includes(port)) commit() if (removed) notify(`Joined. ${removed} wire${removed === 1 ? '' : 's'} on its lines removed.`) } /** * A single wire brought to a port's socket on a component's box (`dir`: the * side of the wire it comes from): the port splits, and the first free line * that runs that way is the pin to wire to. Null when there is none. */ function lineAt(dir: 'in' | 'out', chipId: string, port: string): PinRef | null { const key = lineForWire(project.value, def.value, chipId, port, dir === 'out') if (!key) { play('error') notify(dir === 'out' ? 'No free line of this port goes into the component' : 'No line of this port comes out of the component', 'error') return null } splitPort(project.value, def.value, chipId, port, true) return { node: chipId, pin: key } } function makeIndependent(nodeId: string) { const copy = makeUnique(project.value, def.value, nodeId) if (!copy) return commit() notify(`This one now uses its own copy, "${copy.name}"`) } function toggleInput(node: CircuitNode) { node.on = !node.on sim.value?.setSource(node.id, node.on) play(node.on ? 'on' : 'off') persist() } function press(node: CircuitNode, down: boolean) { if (down && !pressed.has(node.id)) play('press') if (down) pressed.add(node.id) else pressed.delete(node.id) sim.value?.setSource(node.id, down) } /** Click on a panel row: flips a switch row. */ function toggleRow(node: CircuitNode, row: PanelRow) { if (row.type !== 'switch' || node.kind !== 'panel') return row.on = !row.on sim.value?.setSource(rowSource(node.id, row.id), row.on) play(row.on ? 'on' : 'off') persist() } function pressRow(node: CircuitNode, row: PanelRow, down: boolean) { if (row.type !== 'button' || node.kind !== 'panel') return const key = rowSource(node.id, row.id) if (down && !pressed.has(key)) play('press') if (down) pressed.add(key) else pressed.delete(key) sim.value?.setSource(key, down) } // ── Panels ──────────────────────────────────────────────────────── /** Docks a panel to a component: switches for its free inputs (left), or lamps for its outputs (right). */ function addPanel(chipId: string, side: 'in' | 'out' = 'in') { const panel = attachPanel(project.value, def.value, chipId, side) if (!panel) return notify(side === 'in' ? 'Every input of this component is already connected' : 'This component has no outputs', 'error') selection.value = [panel.id] wireSel.value = [] commit() const n = panel.rows!.length notify(side === 'in' ? `Input panel with ${n} switch${n === 1 ? '' : 'es'} attached` : `Output panel with ${n} lamp${n === 1 ? '' : 's'} attached`) } /** Pins of the open circuit got new keys: circuits that place it keep their wires on them. */ function followPins(renamed: Map) { if (!renamed.size) return const id = def.value.id for (const d of project.value.components) { const chips = new Set(d.nodes.filter(n => n.kind === 'chip' && n.chip === id).map(n => n.id)) if (!chips.size) continue for (const w of d.wires) { const to = chips.has(w.to.node) ? renamed.get(w.to.pin) : undefined if (to) w.to = { node: w.to.node, pin: to } const from = chips.has(w.from.node) ? renamed.get(w.from.pin) : undefined if (from) w.from = { node: w.from.node, pin: from } } } } /** Joins the selected panels into one; circuits that place this one keep their wires to the rows. */ function mergeSelectedPanels() { const res = mergePanels(def.value, selection.value) if (!res) return notify('Select at least two panels of the same kind', 'error') followPins(res.renamed) selection.value = [res.panel.id] wireSel.value = [] commit() notify(`One panel with ${res.panel.rows?.length ?? 0} rows`) } /** The selected switches, buttons and clocks as one input panel, or output pins and lamps as one output panel. */ function combineSelected() { const res = combineIntoPanel(def.value, selection.value, getDef.value) if (!res) return notify('Select switches, buttons and clocks, or output pins and lamps (two or more)', 'error') followPins(res.renamed) selection.value = [res.panel.id] wireSel.value = [] commit() notify(`${res.panel.kind === 'outpanel' ? 'Output' : 'Input'} panel with ${res.panel.rows?.length ?? 0} rows`) } // ── Main menu ───────────────────────────────────────────────────── /** The title menu shows when the app opens at /; links open straight into the editor. */ const screen = ref<'menu' | 'editor'>(location.pathname === '/' ? 'menu' : 'editor') const menuPage = ref('main') /** The challenges list below its button in the top bar. */ const challengesOpen = ref(false) function enterGame() { screen.value = 'editor' menuPage.value = 'main' } function showMenu(page: MenuPage = 'main') { persistNow() dialog.value = null paused.value = null menuPage.value = page screen.value = 'menu' } // ── Pause menu ──────────────────────────────────────────────────── /** The in-game menu over the editor (Esc): its main list, or the saves to load. */ const paused = ref(null) function pause(page: 'main' | 'load' = 'main') { placing.value = null linking.value = null paused.value = page } /** Saves now: in this browser, and in the account when signed in. */ async function saveNow() { placeholder = false changed = true persistNow() if (!account.value) return notify('Saved in this browser') await syncAccount() notify(cloudState.value === 'synced' ? 'Saved to your account' : 'Saved in this browser; the account will follow when it can be reached', cloudState.value === 'synced' ? 'ok' : 'error') } /** A project's mode, from its index entry, or (for projects saved before it was noted there) from the project. */ const modes = new Map() function projectMode(m: ProjectMeta): Project['mode'] | undefined { if (m.mode) return m.mode if (!modes.has(m.id)) modes.set(m.id, loadProject(m.id)?.mode ?? null) return modes.get(m.id) ?? undefined } /** The newest project of a mode, if any. */ const newestOf = (mode: Project['mode']) => listProjects().filter(m => projectMode(m) === mode).sort((a, b) => b.updated - a.updated)[0] /** The newest project of a mode, for the menu to show progress (the open one as it is now). */ function projectOf(mode: Project['mode']): Project | null { const m = newestOf(mode) if (!m) return null return m.id === meta.value.id ? project.value : loadProject(m.id) } /** Into the campaign: the newest one, or a new one. */ function playCampaign() { const m = newestOf('campaign') if (m) switchProject(m.id) else newProject(false, true) challengesOpen.value = true enterGame() } /** Into the challenges project (made on first use: NAND only, every challenge open). */ function intoChallenges() { const m = newestOf('challenges') if (m) switchProject(m.id) else { persistNow() const p = createProject({ examples: false, name: 'Challenges' }) p.mode = 'challenges' activate(addProject(p), p) } challengesOpen.value = true } function playChallenge(c: Challenge) { intoChallenges() beginChallenge(c) enterGame() } /** The puzzle of the week, in the challenges project. */ function playWeekly() { intoChallenges() const spec = project.value.puzzles?.find(p => p.id === weeklyId(weekKey())) if (spec) beginPuzzle(spec) else void openPuzzle('weekly') enterGame() } /** Name shown next to your scores on the leaderboards. */ const playerName = ref((() => { try { return localStorage.getItem('logigate:player-name') ?? '' } catch { return '' } })()) async function setPlayerName(name: string) { const res = await api<{ name: string }>('POST', '/api/players/name', { player: playerId(), name }) playerName.value = res.name try { localStorage.setItem('logigate:player-name', res.name) } catch {} } /** A puzzle and its leaderboard from the server ("weekly", "week-2026-43" or a link id). */ async function fetchBoard(id: string): Promise<{ id: string; spec: PuzzleSpec; summary: PuzzleSummary } | null> { try { return await api('GET', `/api/puzzles/${encodeURIComponent(id)}?player=${encodeURIComponent(playerId())}`) } catch { return null } } /** Puts pixels on a named screen of the component's box ('' for the main screen). */ function setScreen(ids: string[], name: string) { const v = name.trim() for (const n of nodesById(ids)) { if (n.kind !== 'pixel') continue if (v) n.screen = v else delete n.screen } commit(false) } /** * Pixels in colour (three inputs, red, green, blue) or one colour (one * input). The wire into a one-colour pixel feeds all three (white); back, * the red wire stays. */ function setRgb(ids: string[], on: boolean) { const d = def.value for (const n of nodesById(ids)) { if (n.kind !== 'pixel' || !!n.rgb === on) continue const into = d.wires.filter(w => w.to.node === n.id) if (on) { n.rgb = true delete n.color const w = into.find(x => x.to.pin === 'a') if (w) { w.to = { node: n.id, pin: 'r' } for (const pin of ['g', 'b']) d.wires.push({ id: uid('w'), from: { ...w.from }, to: { node: n.id, pin } }) } } else { delete n.rgb const keep = into.find(x => x.to.pin === 'r') ?? into[0] d.wires = d.wires.filter(x => x.to.node !== n.id || x === keep) if (keep) keep.to = { node: n.id, pin: 'a' } } } commit() } // ── Test benches ────────────────────────────────────────────────── /** Results of the benches in the open circuit, by bench id; not saved. */ const benchResults = shallowRef(new Map()) /** The bench whose tests are open in the dialog. */ const benchOpen = ref(null) let benchTimer: ReturnType | undefined /** The component a bench at this spot docks to: one whose box is under it or within two squares. */ function benchSpot(x: number, y: number): CircuitNode | undefined { let best: CircuitNode | undefined let bestD = 2.01 for (const n of def.value.nodes) { if (n.kind !== 'chip') continue const b = shapeOf(n, getDef.value).body const dx = Math.max(n.x + b.x - x, 0, x - (n.x + b.x + b.w)) const dy = Math.max(n.y + b.y - y, 0, y - (n.y + b.y + b.h)) const d = Math.max(dx, dy) if (d < bestD) { best = n bestD = d } } return best } /** Docks a bench to a component, just below it. */ function dockAt(bench: CircuitNode, chip: CircuitNode) { const b = shapeOf(chip, getDef.value).body bench.bench = { rows: bench.bench?.rows ?? [], on: chip.id } bench.x = chip.x + b.x bench.y = Math.ceil(chip.y + b.y + b.h + 1.5) } /** Docks a bench to a component of this circuit (or undocks it) and runs its tests. */ function dockBench(id: string, chipId: string | null) { const n = def.value.nodes.find(x => x.id === id) const chip = chipId ? def.value.nodes.find(x => x.id === chipId && x.kind === 'chip') : undefined if (!n?.bench) return if (chip) dockAt(n, chip) else delete n.bench.on commit(false) scheduleBenches() } /** The component a bench tests, if it is docked to one that is still here. */ function benchTarget(bench: CircuitNode): { node: CircuitNode; def: ComponentDef } | undefined { const node = bench.bench?.on ? def.value.nodes.find(n => n.id === bench.bench!.on) : undefined const d = node?.kind === 'chip' && node.chip ? getDef.value(node.chip) : undefined return node && d ? { node, def: d } : undefined } /** Runs a bench's tests now; by hand they may run longer. */ function runBenchNow(id: string, byHand = false) { const n = def.value.nodes.find(x => x.id === id) if (!n?.bench) return const t = benchTarget(n) const res: BenchResult = t ? runBench(getDef.value, t.def.id, n.bench.rows, byHand ? HAND_TICKS : AUTO_TICKS) : { rows: [], pass: 0, fail: 0, error: 'Dock it to a component: drop it on one, or pick one in its tests' } benchResults.value.set(id, res) benchResults.value = new Map(benchResults.value) if (byHand) play(res.fail || res.error ? 'error' : 'connect') } /** Runs every bench of the open circuit a moment after the last change. */ function scheduleBenches() { clearTimeout(benchTimer) if (!def.value.nodes.some(n => n.kind === 'bench')) return benchTimer = setTimeout(() => { for (const n of def.value.nodes) if (n.kind === 'bench') runBenchNow(n.id) }, 300) } /** Changes a bench's tests (an undo step) and runs them again. */ function setBench(id: string, change: (b: Bench) => void) { const n = def.value.nodes.find(x => x.id === id) if (!n?.bench) return change(n.bench) commit(false) scheduleBenches() } // ── Assembler ───────────────────────────────────────────────────── /** The assembler's texts, kept in the project (not undo steps). */ const asmDoc = computed(() => project.value.asm ?? { ...ASM_EXAMPLE }) function saveAsm(patch: Partial) { project.value.asm = { ...asmDoc.value, ...patch } persist() } /** Puts assembled words into the switch panels of a circuit (one word a panel). An undo step. */ function loadProgram(targetId: string, words: number[], width: number, msbTop: boolean): boolean { const target = getDef.value(targetId) if (!target) return false const res = loadIntoPanels(target, words, width, msbTop) if (!res.ok) { notify(res.error, 'error') play('error') return false } commit() notify(`Loaded ${res.panels} word${res.panels === 1 ? '' : 's'} into "${target.name}"${res.cleared ? `, ${res.cleared} more panel${res.cleared === 1 ? '' : 's'} set to 0` : ''}`) play('place') return true } /** Every row of an input panel the same kind: all switches, all buttons or all clocks. */ function setRowsType(panel: CircuitNode, type: PanelControl) { for (const r of panel.rows ?? []) { r.type = type if (type !== 'switch') delete r.on if (type !== 'clock') delete r.hz } commit() } function undock(panel: CircuitNode) { detachPanel(panel) commit() } function setRowType(row: PanelRow, type: PanelControl) { row.type = type if (type !== 'switch') delete row.on if (type !== 'clock') delete row.hz commit() } /** Swaps a row of a free panel with its neighbour; the rows keep their places, so the switches trade them. */ function moveRow(panel: CircuitNode, index: number, by: -1 | 1) { const rows = panel.rows ?? [] const j = index + by if (panel.attach || j < 0 || j >= rows.length) return const at = panelOffsets(rows) ;[rows[index], rows[j]] = [rows[j]!, rows[index]!] rows.forEach((r, i) => (r.dy = at[i]!)) commit() } /** Empty rows above a row of a free panel; the rows below move along. */ function setRowGap(panel: CircuitNode, index: number, gap: number) { const rows = panel.rows ?? [] if (panel.attach || index < 1 || index >= rows.length) return const at = panelOffsets(rows) const shift = at[index - 1]! + 1 + Math.max(0, Math.min(20, Math.round(gap) || 0)) - at[index]! rows.forEach((r, i) => (r.dy = i < index ? at[i]! : at[i]! + shift)) commit() } /** A keyboard key for a panel row (empty to clear it). */ function setRowKey(row: PanelRow, key: string | undefined) { if (key) row.key = key else delete row.key commit(false) } function setRowColor(row: PanelRow, color: LampColor | undefined) { if (color) row.color = color else delete row.color commit(false) } // ── Cable ends ──────────────────────────────────────────────────── /** The part a cable end's single wires all run to (for a bundle: come from), if just one. */ function plugTarget(end: CircuitNode): CircuitNode | undefined { const wires = end.kind === 'bundle' ? def.value.wires.filter(w => w.to.node === end.id) : def.value.wires.filter(w => w.from.node === end.id) const ids = new Set(wires.map(w => (end.kind === 'bundle' ? w.from.node : w.to.node))) const part = ids.size === 1 ? def.value.nodes.find(n => n.id === [...ids][0]) : undefined return part && part.kind !== 'bundle' && part.kind !== 'split' ? part : undefined } function plugEnd(end: CircuitNode) { const part = plugTarget(end) if (!part || !plugInto(def.value, end, part.id, getDef.value)) { return notify('Its wires must all run to the pins of one part, in the same order as the cable', 'error') } commit() } /** Pulls a cable end out of its part: it steps two squares away and its wires show again. */ function unplugEnd(end: CircuitNode) { if (!end.plug) return delete end.plug end.x += end.kind === 'bundle' ? 2 : -2 commit() } /** * Parts moved away from the part they hang on come loose: cable ends * unplug, latched parts let go, and a docked panel moved up or down off its * component's pins becomes a panel of its own (rows and wires kept). */ function unplugMoved(ids: Set) { for (const n of def.value.nodes) { if (n.plug && ids.has(n.id) && !ids.has(n.plug)) delete n.plug if (n.latch && ids.has(n.id) && !ids.has(n.latch)) delete n.latch if (n.attach && ids.has(n.id) && !ids.has(n.attach) && offItsPins(def.value, n, getDef.value)) detachPanel(n) } } /** The part a part could latch onto: wired to it, its pins lining up exactly. */ function latchTargetOf(n: CircuitNode): CircuitNode | undefined { return n.latch ? undefined : latchTarget(def.value, n, getDef.value) } /** Latches a part onto the part it fits: it moves onto that part's pins and goes along with it. */ function latchPart(n: CircuitNode) { const host = latchTarget(def.value, n, getDef.value) if (!host || !latchInto(def.value, n, host.id, getDef.value)) { return notify('Its pins must line up with the pins it is wired to, one for one', 'error') } commit() play('connect') } /** Lets a latched part go: it steps two squares away and its wires show again. */ function unlatch(n: CircuitNode) { const host = n.latch ? def.value.nodes.find(x => x.id === n.latch) : undefined if (!host) return delete n.latch n.x += n.x >= host.x ? 2 : -2 commit() } function setPitch(end: CircuitNode, pitch: number) { if (end.plug) return const p = Math.max(1, Math.min(8, Math.round(pitch) || 1)) if (p === 1) delete end.pitch else end.pitch = p delete end.offsets commit() } /** * Pins of a part a new cable can plug onto: groups of its outputs (those * not already in a plugged cable) and of its free inputs. */ function cableChoices(n: CircuitNode): { out: PinGroup[]; in: PinGroup[] } { const none = { out: [], in: [] } if (n.kind !== 'chip' && n.kind !== 'panel' && n.kind !== 'hex') return none const s = shapeOf(n, getDef.value) const d = def.value const kinds = new Map(d.nodes.map(x => [x.id, x])) const cabled = new Set(d.wires.filter(w => w.from.node === n.id && kinds.get(w.to.node)?.plug === n.id).map(w => w.from.pin)) // Inputs already fed by a plugged cable are taken; inputs with a plain wire can take a cable (the wire goes into it). const fed = new Set(d.wires.filter(w => w.to.node === n.id && kinds.get(w.from.node)?.plug === n.id).map(w => w.to.pin)) // Pins on their usual edge only: a split port's lines that run the other way sit on the far edge, where no cable end fits. const outs = s.outputs.filter(p => !p.bus && p.face !== -1).sort((a, b) => a.dy - b.dy) const ins = n.kind === 'panel' ? [] : s.inputs.filter(p => !p.bus && p.face !== 1).sort((a, b) => a.dy - b.dy) return { out: pinGroups(outs, k => !cabled.has(k)), in: pinGroups(ins, k => !fed.has(k)) } } /** * A cable from some of a part's outputs. When each of them already has * one wire, those wires go into the cable (both ends plug in where they * can); otherwise just a plug goes on the pins, its cable pulled out by hand. */ function cableOut(nodeId: string, pins: string[]) { const wires = def.value.wires.filter(w => w.from.node === nodeId && pins.includes(w.from.pin)) const per = new Map() for (const w of wires) per.set(w.from.pin, (per.get(w.from.pin) ?? 0) + 1) if (wires.length >= 2 && pins.every(p => per.get(p) === 1)) return bundleSelected(wires.map(w => w.id)) const res = cableFromPins(def.value, nodeId, pins, getDef.value) if (!res.ok) return notify(res.error, 'error') selection.value = [res.bundle.id] wireSel.value = [] commit() notify(`Plug with ${res.bundle.bits} wires: drag the cable out of its pin to where they go`) } /** A cable into some of a part's inputs: their wires go into it when they all have one, else a plug on the free ones. */ function cableIn(nodeId: string, pins: string[]) { const wires = def.value.wires.filter(w => w.to.node === nodeId && pins.includes(w.to.pin)) if (wires.length >= 2 && wires.length === pins.length) return bundleSelected(wires.map(w => w.id)) const res = cableIntoPins(def.value, nodeId, pins, getDef.value) if (!res.ok) return notify(res.error, 'error') selection.value = [res.split.id] wireSel.value = [] commit() notify(`Plug with ${res.split.bits} wires: drag the cable out of its pin to what drives them`) } /** * A cable pulled out of a cable end and dropped at `x`, `y`: its other end * goes there, wired to the pins it was dropped on (`links`, from 'ghost'). */ function pullCable(endId: string, x: number, y: number, links: Link[] = []) { const end = cableEnd(def.value, endId, x, y) if (!end) return const swap = (r: PinRef) => (r.node === 'ghost' ? { node: end.id, pin: r.pin } : r) const made = links.filter(l => addWire(swap(l.from), swap(l.to))).length selection.value = [end.id] wireSel.value = [] commit() play(made ? 'connect' : 'place') } function addCablePanel(bundleId: string) { const panel = cablePanel(def.value, bundleId, getDef.value) if (!panel) return notify('Every wire of this cable is already driven', 'error') selection.value = [panel.id] wireSel.value = [] commit() notify(`Input panel with ${panel.rows!.length} switches plugged into the cable`) } function addRow(panel: CircuitNode) { panel.rows = [...(panel.rows ?? []), ...newPanelRows(1)] commit() } /** A new row at a place in a free panel's order (above the row there); returns it. */ function insertRow(panel: CircuitNode, index: number): PanelRow | undefined { if (panel.attach) return const row = insertPanelRow(panel, index) commit() return row } /** A row of a free panel dragged to another place in the order. */ function moveRowTo(panel: CircuitNode, from: number, to: number) { if (panel.attach || !movePanelRow(panel, from, to)) return commit() } function dropRow(panel: CircuitNode, rowId: string) { removeRow(def.value, panel, rowId) commit() } let clip: Clip | null = null let pasteCount = 0 /** Something copied, ready to paste. */ const hasClip = ref(false) function copy() { if (!selection.value.length) return clip = copySelection(def.value, withDocked(selection.value)) hasClip.value = true pasteCount = 0 notify(`Copied ${clip.nodes.length} part${clip.nodes.length === 1 ? '' : 's'}`) } /** Pastes a little below the copy each time, or with its top left corner at `at`. */ function paste(at?: Pt) { if (!clip) return pasteCount++ const blocked = clip.nodes.filter(n => n.kind === 'chip' && n.chip && !canPlace(n.chip)) const usable: Clip = blocked.length ? { nodes: clip.nodes.filter(n => !blocked.includes(n)), wires: clip.wires } : clip if (blocked.length) notify('Skipped parts that would contain this circuit itself', 'error') const [dx, dy] = at && usable.nodes.length ? [Math.round(at[0]) - Math.min(...usable.nodes.map(n => n.x)), Math.round(at[1]) - Math.min(...usable.nodes.map(n => n.y))] : [2 * pasteCount, 2 * pasteCount] const ids = pasteClip(def.value, usable, dx, dy) const fresh = new Set(ids) continueSeries(def.value, def.value.nodes.filter(n => fresh.has(n.id))) selection.value = ids wireSel.value = [] commit() } function duplicate() { copy() paste() } // ── Connect one by one ──────────────────────────────────────────── /** * Pins of the given parts, top to bottom, ready to be wired one after the * other: their outputs, or their inputs when asked for (or when they have * no outputs, like lamps). */ function linkQueue(ids: string[], want?: 'in' | 'out'): LinkEnd[] { const nodes = def.value.nodes.filter(n => ids.includes(n.id) && n.kind !== 'note').sort((a, b) => a.y - b.y || a.x - b.x) const shapes = nodes.map(n => ({ n, s: shapeOf(n, getDef.value) })) const dir = want ?? (shapes.some(({ s }) => s.outputs.length) ? 'out' : 'in') const queue: LinkEnd[] = [] for (const { n, s } of shapes) { for (const p of dir === 'out' ? s.outputs : s.inputs) { const label = p.label || n.label?.trim() || '' queue.push({ node: n.id, pin: p.key, dir, label }) } } return queue } function startLinking(ids = selection.value, want?: 'in' | 'out') { const queue = linkQueue(ids, want) if (!queue.length) return notify('Nothing to connect: select parts with pins', 'error') placing.value = null linking.value = null linking.value = { queue, at: 0 } } /** * Wires the pin whose turn it is to `target`, then moves on to the next one. * With `more` (Shift), the wire keeps following the mouse from the same * signal for another connection: from the same output, or, when it started * at an input, from the output just wired to it. */ function linkTo(target: PinRef, more = false) { const l = linking.value const cur = l?.queue[l.at] if (!l || !cur) return const here = { node: cur.node, pin: cur.pin } if (cur.dir === 'out') connect(here, target) else connect(target, here) if (more && cur.dir === 'out') return if (more && l.queue.length === 1) { linking.value = { queue: [{ ...target, dir: 'out', label: '' }], at: 0 } return } l.at++ if (l.at >= l.queue.length) { linking.value = null if (l.queue.length > 1) notify(`Connected ${l.queue.length} pins`) } } function stopLinking() { linking.value = null } // ── Tidy wiring ─────────────────────────────────────────────────── function setTidy(on: boolean) { if (on) project.value.settings.tidy = true else delete project.value.settings.tidy persist() } /** Removes all hand-placed bends in the open circuit and lays every wire out tidily. */ function tidyAll() { const bent = def.value.wires.filter(w => w.pts).length for (const w of def.value.wires) delete w.pts project.value.settings.tidy = true commit(false) persist() notify(bent ? `Tidied. ${bent} hand-placed bend${bent === 1 ? ' was' : 's were'} removed (Ctrl+Z brings ${bent === 1 ? 'it' : 'them'} back)` : 'Tidy wiring is on') } /** Tidy wiring in every circuit of the project: all hand-placed bends go, one undo step. */ function tidyEverything() { let bent = 0 let circuits = 0 for (const d of project.value.components) { const n = d.wires.filter(w => w.pts).length if (n) circuits++ bent += n for (const w of d.wires) delete w.pts } project.value.settings.tidy = true commit(false) persist() notify( bent ? `Tidied every circuit: ${bent} hand-placed bend${bent === 1 ? '' : 's'} in ${circuits} circuit${circuits === 1 ? '' : 's'} removed (Ctrl+Z brings them back)` : 'Every circuit is tidy', ) } function selectAll() { selection.value = def.value.nodes.map(n => n.id) wireSel.value = def.value.wires.map(w => w.id) } function packageSelected(name: string) { const res = packageSelection(project.value, def.value.id, new Set(selection.value), name) if (!res.ok) { notify(res.error, 'error') return } selection.value = [res.chipNode] wireSel.value = [] commit() notify(`Created component "${res.def.name}"`) } // ── Components ──────────────────────────────────────────────────── function createComponent(name = 'New part') { const d = newComponent(project.value, name) commit() open(d.id) labelFocus.value++ } function removeComponent(id: string) { const err = deleteComponent(project.value, id) if (err) return notify(err, 'error') nav.value = nav.value.filter(n => n !== id) commit() rebuild() } function copyComponent(id: string) { const d = duplicateComponent(project.value, id) if (!d) return commit() open(d.id) } function beginChallenge(c: Challenge) { const existing = project.value.components.find(d => d.challenge === c.id) if (existing) return open(existing.id) if (!challengeOpen(project.value, c.id)) { play('error') return notify(`Solve ${(NEEDS[c.id] ?? []).filter(n => !project.value.solved.includes(n)).map(challengeName).join(' and ')} first`, 'error') } const d = startChallenge(project.value, c) commit() open(d.id) } /** The challenge or puzzle the open circuit is for. */ const task = computed(() => { const id = def.value.challenge if (!id) return null const c = CHALLENGES.find(c => c.id === id) if (c) return { id, challenge: c, puzzle: undefined, steps: challengeSteps(c) } const p = project.value.puzzles?.find(p => p.id === id) return p ? { id, challenge: undefined, puzzle: p, steps: p.steps } : null }) function checkChallenge(): ChallengeCheck | null { const t = task.value if (!t) return null const res = t.puzzle ? scoreSolution(toRaw(project.value.components), def.value.id, toRaw(t.puzzle)) : runSteps(getDef.value, def.value.id, t.steps) const used = transistors(def.value.id) const before = project.value.best?.[t.id] if (!res.pass) { play('fail') return { ...res, transistors: used, best: before } } let changed = false const first = !project.value.solved.includes(t.id) const opened = first && t.challenge ? unlockedBy(project.value, t.id) : { challenges: [], kinds: [] } if (first) { project.value.solved.push(t.id) changed = true } const record = before === undefined || used < before if (record) { project.value.best = { ...project.value.best, [t.id]: used } changed = true } if (changed) { commit(false) persist() } const unlocked = isCampaign(project.value) && first && t.challenge ? [def.value.name, ...opened.kinds.map(k => KIND_NAMES[k] ?? k)] : [] const nextUp = opened.challenges.map(challengeName) play(record && before !== undefined ? 'record' : 'solve') if (unlocked.length || nextUp.length) play('unlock') if (t.puzzle) void submitScore(t.puzzle) return { ...res, transistors: used, best: record ? used : before, record: record && before !== undefined ? before : undefined, unlocked, nextUp, } } // ── Puzzles ─────────────────────────────────────────────────────── /** A random id for this browser, so the server can keep one best score per player. */ function playerId(): string { try { let id = localStorage.getItem('logigate:player') if (!id) { id = uid('p') + uid() + uid() localStorage.setItem('logigate:player', id) } return id } catch { return 'anonymous-player' } } /** How everyone did, per puzzle id, as last heard from the server. */ const boards = reactive>({}) async function loadBoard(spec: PuzzleSpec) { try { const res = await api<{ summary: PuzzleSummary }>('GET', `/api/puzzles/${apiId(spec.id)}?player=${encodeURIComponent(playerId())}`) boards[spec.id] = res.summary } catch {} } async function submitScore(spec: PuzzleSpec) { try { const res = await api<{ score: { pass: boolean; transistors: number }; summary: PuzzleSummary }>('POST', `/api/puzzles/${apiId(spec.id)}/scores`, { player: playerId(), defId: def.value.id, components: toRaw(project.value.components), }) boards[spec.id] = res.summary } catch (e) { notify(`Your score could not be sent: ${(e as Error).message}`, 'error') } } function beginPuzzle(spec: PuzzleSpec) { const d = startPuzzle(project.value, spec) commit() open(d.id) void loadBoard(spec) } /** Opens a puzzle from the server: a link id, or "weekly". */ async function openPuzzle(id: string) { try { const res = await api<{ spec: PuzzleSpec; summary: PuzzleSummary }>('GET', `/api/puzzles/${encodeURIComponent(id)}?player=${encodeURIComponent(playerId())}`) boards[res.spec.id] = res.summary beginPuzzle(res.spec) notify(`Puzzle: ${res.spec.name}`) } catch (e) { notify((e as Error).message, 'error') } finally { syncUrl() } } /** Publishes the open circuit as a puzzle; returns its link. */ async function publishPuzzle(name: string, goal: string): Promise { const spec = makePuzzle(toRaw(project.value.components), def.value.id, name, goal) const res = await api<{ id: string }>('POST', '/api/puzzles', { puzzle: spec }) return `${location.origin}/puzzle/${res.id}` } // ── Public library ──────────────────────────────────────────────── /** Edit keys of the library entries this browser published. */ const libKeys = ref(libraryKeys()) /** The library entry a component is, when this browser published it from here (and so can update or remove it). */ function ownEntry(d: ComponentDef | undefined): string | undefined { return d && ownedEntry(libKeys.value, meta.value.id, d.id) } /** Why the open circuit can't go to the library; null when it can. */ const libraryProblem = computed(() => publishProblem(project.value, def.value.id)) async function listLibrary(q = ''): Promise<{ entries: LibraryMeta[]; total: number }> { return api('GET', `/api/library?q=${encodeURIComponent(q.trim())}`) } /** * Publishes the open circuit to the library with everything it uses, or a * new version when this browser published it before. The name and * description go to the component too; the author is your leaderboard name. */ async function publishToLibrary(name: string, description: string, author: string): Promise { const d = def.value const problem = publishProblem(project.value, d.id) if (problem) throw new Error(problem) if (author.trim() !== playerName.value) await setPlayerName(author) const text = description.trim().slice(0, LIBRARY_LIMITS.description) d.name = name.trim().slice(0, LIBRARY_LIMITS.name) || d.name if (text) d.description = text else delete d.description try { const body = { player: playerId(), ...libraryBundle(toRaw(project.value), d.id) } const own = ownEntry(d) let res: { id: string; key?: string; version: number } | undefined if (own) { try { res = await api('PUT', `/api/library/${own}`, body, libKeys.value[own]!.key) } catch (e) { // Gone from the library: it goes in again as a new entry. if ((e as { status?: number }).status !== 404) throw e setLibraryKey(own, null) } } res ??= await api<{ id: string; key: string; version: number }>('POST', '/api/library', body) if (res.key) setLibraryKey(res.id, { key: res.key, project: meta.value.id, def: d.id }) libKeys.value = libraryKeys() d.from = { id: res.id, version: res.version, author: playerName.value } return d.from } finally { commit(false) } } /** Takes an entry this browser published out of the library; components here keep working, just without the mark. */ async function removeFromLibrary(id: string) { try { await api('DELETE', `/api/library/${id}`, undefined, libKeys.value[id]?.key) } catch (e) { if ((e as { status?: number }).status !== 404) throw e } setLibraryKey(id, null) libKeys.value = libraryKeys() for (const d of project.value.components) if (d.from?.id === id && !d.from.inside) delete d.from commit(false) } async function fetchEntry(id: string): Promise<{ entry: LibraryMeta; bundle: LibraryBundle }> { const problem = importProblem(project.value) if (problem) throw new Error(problem) const res = await api<{ entry: LibraryMeta; bundle: unknown }>('GET', `/api/library/${encodeURIComponent(id)}`) return { entry: res.entry, bundle: cleanBundle(res.bundle) } } const originOf = (entry: LibraryMeta): LibraryOrigin => ({ id: entry.id, version: entry.version, author: entry.author }) /** Adds a library entry to the open project; returns the id of its component here, ready to place. */ async function addFromLibrary(id: string): Promise { const { entry, bundle } = await fetchEntry(id) const res = importBundle(project.value, bundle, originOf(entry)) commit() const along = res.added > 1 ? ` and ${res.added - 1} component${res.added === 2 ? '' : 's'} it uses` : '' notify(res.added ? `Added "${entry.name}"${entry.author ? ` by ${entry.author}` : ''}${along}` : `"${entry.name}" is in this project already`) return res.root } /** Brings a component from the library to the newest version of its entry, in place: wherever it is used follows. */ async function updateFromLibrary(defId: string) { const d = getDef.value(defId) if (!d?.from || d.from.inside) return try { const { entry, bundle } = await fetchEntry(d.from.id) importBundle(project.value, bundle, originOf(entry), d.id) commit() notify(`"${d.name}" is now version ${entry.version} (Ctrl+Z goes back)`) } catch (e) { notify((e as Error).message, 'error') } } /** The newest version of a library entry; null when the library can't be reached or no longer has it. */ async function libraryVersion(id: string): Promise { try { return (await api<{ entry: LibraryMeta }>('GET', `/api/library/${encodeURIComponent(id)}?meta`)).entry.version } catch { return null } } // ── Several parts at once ───────────────────────────────────────── const nodesById = (ids: string[]) => { const set = new Set(ids) return def.value.nodes.filter(n => set.has(n.id)) } /** Swaps every given part for the same new one, keeping wires on matching pins. One undo step. */ function swapMany(ids: string[], target: SwapTarget) { let removed = 0 for (const n of nodesById(ids)) { if (n.kind === target.kind && n.chip === target.chip) continue removed += swapNode(project.value, def.value, n.id, target) } commit() notify(removed ? `Swapped. ${removed} wire${removed === 1 ? '' : 's'} had no matching pin and were removed.` : `Swapped ${ids.length} parts`) } /** Names the parts top to bottom from a pattern (D# → D0, D1, …). An empty pattern clears their names. */ function renameMany(ids: string[], pattern: string, start = 0) { const nodes = nodesById(ids).sort(byPosition) const names = numberedNames(pattern, nodes.length, start) nodes.forEach((n, i) => { if (pattern.trim()) n.label = names[i] else delete n.label delete n.autoLabel }) // Signal names decide what connects. commit(nodes.some(n => n.kind === 'tag' || n.kind === 'ref')) } /** A name typed by hand (Pins list); empty lets connections name the part again. */ function setLabel(node: CircuitNode, label: string, row?: PanelRow) { const v = label.trim() if (row) { if (v) row.label = v else delete row.label return commit() } if (v) node.label = v else delete node.label delete node.autoLabel commit(false) } /** Sets the switches among the parts to 0 or 1, or flips each. */ function setSwitches(ids: string[], to: boolean | 'flip') { for (const n of nodesById(ids)) { if (n.kind !== 'input') continue const on = to === 'flip' ? !n.on : to if (!!n.on === on) continue n.on = on sim.value?.setSource(n.id, on) } play(to === false ? 'off' : 'on') persist() } /** The same setting on every part (colour, frequency, note size); undefined removes it. */ function patchMany(ids: string[], patch: Pick, structural = false) { for (const n of nodesById(ids)) { for (const [k, v] of Object.entries(patch) as [keyof typeof patch, never][]) { if (v === undefined) delete n[k] else n[k] = v } } commit(structural) } function arrangeSelected(how: Arrange) { arrangeNodes(nodesById(selection.value), how) commit(false) } /** Narrows the selection to some of its parts. */ function selectOnly(ids: string[]) { selection.value = ids wireSel.value = [] } /** A reference to a signal, placed to the right of its tag and selected. */ function useSignal(tag: CircuitNode) { const name = tag.label?.trim() if (!name) return notify('Give the signal a name first', 'error') const b = shapeOf(tag, getDef.value).body const ref: CircuitNode = { id: uid('n'), kind: 'ref', x: Math.round(tag.x + b.x + b.w + 3), y: tag.y, label: name } def.value.nodes.push(ref) selection.value = [ref.id] wireSel.value = [] commit() play('place') } /** Every tag and reference of a signal. */ function selectSignal(name: string) { selection.value = def.value.nodes.filter(n => (n.kind === 'tag' || n.kind === 'ref') && n.label?.trim() === name).map(n => n.id) wireSel.value = [] } /** Selects a part and centres the view on it. */ function focusNode(id: string) { selection.value = [id] wireSel.value = [] focusRequest.value = { id, n: (focusRequest.value?.n ?? 0) + 1 } } // ── Transistors ─────────────────────────────────────────────────── const nands = computed(() => nandCounts(project.value.components)) /** Transistors in a component at every depth, 4 per NAND gate. */ function transistors(defId: string): number { return (nands.value.get(defId) ?? 0) * TRANSISTORS_PER_NAND } /** Transistors in one placed part: 4 for a NAND, its whole inside for a component, 0 for switches, lamps and cables. */ function transistorsOfNode(n: CircuitNode): number { const child = n.kind === 'chip' && n.chip ? getDef.value(n.chip) : undefined const bubbles = invertedPins(n, child ? chipPins(child) : undefined).length * TRANSISTORS_PER_NAND if (n.kind === 'nand') return TRANSISTORS_PER_NAND + bubbles return (n.kind === 'chip' && n.chip ? transistors(n.chip) : 0) + bubbles } /** Inputs that take a bubble: single wires into gates, components, outputs and lamps, not the lines of a split port. */ function canInvert(n: CircuitNode, pin: string): boolean { if (!INVERTIBLE.has(n.kind)) return false const p = shape(n).inputs.find(p => p.key === pin) return !!p && !p.bus && !p.port } /** Puts a bubble on an input (it reads the signal inverted, through one NAND), or takes it off. */ function toggleInvert(n: CircuitNode, pin: string) { if (!canInvert(n, pin)) return const set = new Set(n.invert ?? []) if (!set.delete(pin)) set.add(pin) if (set.size) n.invert = [...set] else delete n.invert commit() } // ── Connector types ───────────────────────────────────────────── /** The connector type open in the connector dialog. */ const connectorFor = ref(null) /** A new connector type with two lines, opened for editing. */ function addConnector(): ConnectorType { const names = new Set((project.value.connectors ?? []).map(c => c.name.toLowerCase())) let name = 'Connector' for (let i = 2; names.has(name.toLowerCase()); i++) name = `Connector ${i}` const c: ConnectorType = { id: uid('k'), name, lines: [{ name: 'D0' }, { name: 'D1' }] } project.value.connectors = [...(project.value.connectors ?? []), c] commit() editConnector(c.id) return c } function editConnector(id: string) { connectorFor.value = id dialog.value = 'connector' } /** Where a connector type is used: ports in all circuits. */ function connectorUses(id: string): number { return project.value.components.reduce((n, d) => n + d.nodes.filter(x => x.conn === id && (x.kind === 'portin' || x.kind === 'portout')).length, 0) } function removeConnector(id: string) { const uses = connectorUses(id) if (uses) return notify(`Still used by ${uses} port${uses === 1 ? '' : 's'}: change or delete those first`, 'error') project.value.connectors = (project.value.connectors ?? []).filter(c => c.id !== id) if (!project.value.connectors.length) delete project.value.connectors if (connectorFor.value === id) dialog.value = null commit() } // ── Cables ──────────────────────────────────────────────────────── /** Bundling with a chosen route: the next click places the start of the cable, the one after its end. */ const cabling = ref<{ wires: string[]; start?: Pt } | null>(null) function startCable(wires = wireSel.value) { if (wires.length < 2) return notify('Select at least two wires to bundle (Shift + click or drag a box)', 'error') placing.value = null linking.value = null cabling.value = { wires: [...wires] } } function placeCable(at: Pt) { const c = cabling.value if (!c) return if (!c.start) { c.start = at return } cabling.value = null bundleSelected(c.wires, { start: c.start, end: at }) } /** Colour of a cable's sleeve (every cable leaving that bundle); undefined for the default. */ function setCableColor(bundleId: string, color: WireColor | undefined) { for (const w of def.value.wires) { if (w.from.node !== bundleId) continue if (color) w.color = color else delete w.color } commit(false) } function bundleSelected(wires = wireSel.value, at?: { start: Pt; end: Pt }) { const res = bundleWires(def.value, wires, getDef.value, at) if (!res.ok) return notify(res.error, 'error') selection.value = [res.bundle.id, res.split.id] wireSel.value = [] commit() notify(`${res.bundle.bits} wires bundled into one cable`) } /** Drops the wires of a cable that nothing feeds or takes; the rest close up. */ function trimCableEnd(endId: string) { const res = trimCable(def.value, endId) if (!res) return notify('Every wire of this cable is in use') commit() notify(`Cable of ${res.after} wires now (was ${res.before})`) } function removeCable(bundleId: string) { const n = dissolveCable(def.value, bundleId) clearSelection() commit() notify(n ? `Cable removed; ${n} wire${n === 1 ? '' : 's'} run on their own again` : 'Cable removed') } function setBits(node: CircuitNode, bits: number) { node.bits = Math.min(MAX_BITS, Math.max(2, Math.round(bits) || 2)) commit() } function table(): TruthTable | { error: string } { return truthTable(getDef.value, def.value.id) } // ── Projects ────────────────────────────────────────────────────── function activate(m: ProjectMeta, p: Project) { // Another project is a step in the browser's history; a newer save of this one is not. const moved = m.id !== meta.value.id placeholder = false meta.value = m project.value = p setCurrentId(m.id) resetHistory() nav.value = [] clearSelection() placing.value = null linking.value = null for (const k of Object.keys(views)) delete views[k] linkState.value = m.link ? (m.link.key ? 'saved' : 'viewer') : 'none' projects.value = listProjects() record(moved) syncUrl() // A project that arrives (another computer's newer save, a savegame) runs from the bits it brings, even with the same circuit open. simRoot = '' unsent = false rebuild() } function switchProject(id: string) { if (id === meta.value.id) return persistNow() const p = loadProject(id) const m = listProjects().find(x => x.id === id) if (!p || !m) return notify('Could not open that project', 'error') activate(m, p) } function addProject(p: Project, link?: ProjectMeta['link']): ProjectMeta { const m: ProjectMeta = { id: newLocalId(), name: p.name, updated: Date.now() } if (link) m.link = link saveProject(m, p) scheduleCloud() return m } function newProject(examples: boolean, campaign = false) { persistNow() const p = createProject({ examples, campaign }) activate(addProject(p), p) if (campaign) notify('Campaign started: you have NAND. Open Challenges on the left and build NOT first.') } function duplicateProject(id: string) { persistNow() const p = loadProject(id) if (!p) return p.name = `${p.name} copy` activate(addProject(p), p) } function deleteProject(id: string) { const gone = listProjects().find(m => m.id === id) if (gone?.cloud) { setPendingDeletes([...pendingDeletes(), { owner: gone.cloud.owner, id }]) scheduleCloud() } removeProject(id) projects.value = listProjects() if (id !== meta.value.id) return const next = projects.value[0] const p = next && loadProject(next.id) if (next && p) activate(next, p) else { const fresh = createProject({ examples: true }) activate(addProject(fresh), fresh) } } function renameProject(id: string, name: string) { const clean = name.trim().slice(0, 80) || 'Untitled' if (id === meta.value.id) { project.value.name = clean persist() return } const p = loadProject(id) const m = listProjects().find(x => x.id === id) if (!p || !m) return p.name = clean saveProject({ ...m, name: clean, dirty: true }, p) projects.value = listProjects() scheduleCloud() } function loadExamples() { const n = addExamples(project.value) commit() notify(n ? `Added ${n} example parts` : 'All examples are already here') } function download(name: string, text: string, type = 'application/json') { const blob = new Blob([text], { type }) const a = document.createElement('a') a.href = URL.createObjectURL(blob) a.download = name a.click() URL.revokeObjectURL(a.href) } const slug = (name: string, fallback: string) => name.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '') || fallback function exportJson() { persistNow() download(`${slug(project.value.name, 'project')}.logigate.json`, JSON.stringify(project.value, null, 1)) } function exportTable(t: TruthTable) { download(`${slug(def.value.name, 'circuit')}-truth-table.csv`, tableCsv(t), 'text/csv') } /** Opens a project file as a new project in the library. */ async function importAsProject(file: File) { try { const p = parseProject(await file.text()) if (p.name === 'Untitled') p.name = file.name.replace(/(\.logigate)?\.json$/i, '') persistNow() activate(addProject(p), p) notify(`Opened ${file.name}`) } catch (e) { notify((e as Error).message, 'error') } } /** Adds the components of a project file to the open project. */ async function importComponents(file: File) { try { const p = parseProject(await file.text()) const n = mergeComponents(project.value, p.components) commit() notify(n ? `Added ${n} component${n === 1 ? '' : 's'} from ${file.name}` : 'Nothing new in that file') } catch (e) { notify((e as Error).message, 'error') } } // ── Share links ─────────────────────────────────────────────────── const linkState = ref(meta.value.link ? (meta.value.link.key ? 'saved' : 'viewer') : 'none') const linkError = ref('') const linkUrl = computed(() => (meta.value.link ? `${location.origin}/p/${meta.value.link.id}` : '')) function syncUrl() { const path = meta.value.link ? `/p/${meta.value.link.id}` : '/' if (location.pathname !== path) history.replaceState(history.state, '', path) } async function api(method: string, url: string, body?: unknown, key?: string): Promise { const res = await fetch(url, { method, headers: { 'content-type': 'application/json', ...(key ? { 'x-edit-key': key } : {}) }, body: body === undefined ? undefined : JSON.stringify(body), }) const data = await res.json().catch(() => ({})) if (!res.ok) throw Object.assign(new Error((data as { message?: string }).message || `Server error ${res.status}`), { status: res.status }) return data as T } async function createLink() { persistNow() linkState.value = 'saving' try { const res = await api<{ id: string; key: string }>('POST', '/api/p', { project: toRaw(project.value) }) meta.value = { ...meta.value, link: { id: res.id, key: res.key }, dirty: true } saveMeta(toRaw(meta.value)) scheduleCloud() projects.value = listProjects() linkState.value = 'saved' syncUrl() } catch (e) { linkError.value = (e as Error).message linkState.value = 'error' } } let syncTimer: ReturnType | undefined let syncing = false async function pushLink() { const link = meta.value.link if (!link?.key) return if (syncing) return scheduleSync() syncing = true linkState.value = 'saving' try { await api('PUT', `/api/p/${link.id}`, { project: toRaw(project.value) }, link.key) linkState.value = 'saved' } catch (e) { linkError.value = (e as Error).message linkState.value = 'error' } finally { syncing = false } } /** The person who made a link saves to it automatically, a few seconds after each change. */ function scheduleSync() { if (!meta.value.link?.key) return linkState.value = 'dirty' clearTimeout(syncTimer) syncTimer = setTimeout(pushLink, 2500) } /** Editing someone else's shared project turns it into your own copy. */ function forkIfViewer() { if (!meta.value.link || meta.value.link.key) return meta.value = { ...meta.value, link: undefined } saveMeta(toRaw(meta.value)) linkState.value = 'none' syncUrl() notify('This is now your own copy. Share it to get your own link.') } /** Opens /p/:id: your own linked project, or a fresh copy of someone else's. */ async function openLink(id: string) { const list = listProjects() const own = list.find(m => m.link?.id === id && m.link.key) if (own) { if (own.id !== meta.value.id) switchProject(own.id) return } try { const res = await fetch(`/api/p/${encodeURIComponent(id)}`) if (!res.ok) throw new Error(res.status === 404 ? 'This link does not exist' : 'Could not load the link') const data = (await res.json()) as { project: unknown } const p = toProject(data.project) if (!placeholder) persistNow() const viewer = list.find(m => m.link?.id === id && !m.link.key) if (viewer) { const m = { ...viewer, name: p.name, updated: Date.now() } saveProject(m, p) activate(m, p) } else activate(addProject(p, { id }), p) notify(`Opened "${p.name}" from a shared link`) } catch (e) { notify((e as Error).message, 'error') if (placeholder) persistNow() syncUrl() } } async function copyText(text: string, done = 'Link copied') { try { await navigator.clipboard.writeText(text) notify(done) } catch { notify('Copy failed: the browser did not allow it', 'error') } } window.addEventListener('beforeunload', () => saveState(true)) document.addEventListener('visibilitychange', () => document.visibilityState === 'hidden' && saveState(true)) setInterval(saveState, 30_000) if (browserHistory) { window.addEventListener('popstate', e => restoreEntry((e.state as { lg?: NavEntry } | null)?.lg)) // The mouse's back button on the first entry would leave the editor: it goes up the crumbs instead, // or stays (Chrome lets a page stop it; other browsers go back as usual). window.addEventListener('mouseup', e => { if (e.button !== 3 || screen.value !== 'editor' || (entryNow()?.i ?? 0) > 0) return e.preventDefault() back() }) } /** The page the app was loaded with opens its link once; the browser's back or forward landing on such a page later does not. */ let landed = false function firstPage(): boolean { const first = !landed landed = true return first } // ── Account ─────────────────────────────────────────────────────── // Signed in, every project in this browser is also kept in the account and // other devices get it on their next sync. Each upload names the revision // it started from; when another device saved in between, both versions are // kept (the other one as a copy) instead of one silently replacing the other. const account = ref(cachedAccount()) /** False while a signed-in browser is still loading the account's saves at startup: the menu waits, so nothing is started twice. */ const savesReady = ref(!account.value) const cloudState = ref<'off' | 'syncing' | 'synced' | 'offline' | 'error'>(account.value ? 'syncing' : 'off') const cloudError = ref('') function setAccount(user: AccountUser | null) { account.value = user setCachedAccount(user) cloudState.value = user ? cloudState.value : 'off' } async function authCall(method: string, url: string, body?: unknown): Promise { const res = await fetch(url, { method, headers: { 'content-type': 'application/json' }, body: body === undefined ? undefined : JSON.stringify(body), }) const data = await res.json().catch(() => ({})) if (res.status === 401 && url.startsWith('/api/me/')) { setAccount(null) notify('You were signed out. Sign in again to keep syncing.', 'error') } if (!res.ok && res.status !== 409) throw new Error((data as { message?: string }).message || `Server error ${res.status}`) return { ...(data as object), status: res.status } as T } function localProject(m: ProjectMeta): Project | null { if (m.id === meta.value.id) { if (saveTimer) persistNow() return toRaw(project.value) } return loadProject(m.id) } function updateMeta(id: string, patch: Partial) { const m = listProjects().find(x => x.id === id) if (!m) return const next = { ...m, ...patch } if (patch.dirty === false) delete next.dirty saveMeta(next) if (id === meta.value.id) meta.value = { ...meta.value, ...patch } } interface CloudMeta { id: string name: string updated: number rev: number link?: ProjectMeta['link'] } /** Replaces this browser's copy of a project with the account's current one. */ async function takeRemote(m: ProjectMeta, uid: string, remote: CloudMeta) { const res = await authCall<{ project?: Project; status: number }>('GET', `/api/me/projects/${m.id}`) if (!res.project) return const p = toProject(res.project) const next: ProjectMeta = { ...m, name: p.name, updated: remote.updated, cloud: { owner: uid, rev: remote.rev } } delete next.dirty delete next.snapshot saveProject(next, p) if (m.id === meta.value.id) activate(next, p) } /** * One save per project on every device. When another device saved the same * project in between, the newer save wins everywhere, and the other one is * kept as a savegame of that project (Load → savegames), never as a copy. */ async function upload(m: ProjectMeta, uid: string) { const p = localProject(m) if (!p) return const baseRev = m.cloud?.owner === uid ? m.cloud.rev : 0 const body = { project: p, baseRev, link: m.link, snapshot: m.snapshot === true } let res = await authCall<{ meta?: CloudMeta; conflict?: boolean; status: number }>('PUT', `/api/me/projects/${m.id}`, body) if (res.conflict && res.meta) { if (res.meta.updated > m.updated) { // The other device's save is newer: this one becomes a savegame. await authCall('POST', `/api/me/projects/${m.id}/versions`, { project: p, baseRev }) await takeRemote(m, uid, res.meta) notify(`"${m.name}" was changed later on another device and is loaded now. Your version here is in its savegames.`) return } // This save is newer: it wins, and the server keeps the other one as a savegame. res = await authCall('PUT', `/api/me/projects/${m.id}`, { ...body, force: true, snapshot: true }) notify(`"${m.name}" was also changed on another device. Yours is newer and saved; the other one is in its savegames.`) } if (res.meta) updateMeta(m.id, { cloud: { owner: uid, rev: res.meta.rev }, dirty: false, snapshot: undefined }) } let syncingAccount = false let syncAgain = false /** Brings this browser and the account up to date in both directions. */ async function syncAccount() { const uid = account.value?.id if (!uid) return if (syncingAccount) { syncAgain = true return } syncingAccount = true cloudState.value = 'syncing' try { if (saveTimer) persistNow() for (const d of pendingDeletes().filter(d => d.owner === uid)) { await authCall('DELETE', `/api/me/projects/${d.id}`).catch(() => {}) } setPendingDeletes(pendingDeletes().filter(d => d.owner !== uid)) const remote = await authCall<{ projects: CloudMeta[]; deleted: { id: string }[]; status: number }>('GET', '/api/me/projects') if (!account.value) return // Deleted on another device. for (const t of remote.deleted) { const m = listProjects().find(x => x.id === t.id && x.cloud?.owner === uid) if (m && !m.dirty) { if (m.id === meta.value.id) { notify(`"${m.name}" was deleted on another device`) deleteProject(m.id) } else removeProject(m.id) } } // New or newer in the account. for (const r of remote.projects) { const m = listProjects().find(x => x.id === r.id) if (m && ((m.cloud && m.cloud.owner !== uid) || m.dirty || (m.cloud?.rev ?? 0) >= r.rev)) continue const res = await authCall<{ project?: Project; status: number }>('GET', `/api/me/projects/${r.id}`) if (!res.project) continue const p = toProject(res.project) const next: ProjectMeta = { id: r.id, name: p.name, updated: r.updated, cloud: { owner: uid, rev: r.rev } } const link = r.link ?? m?.link if (link) next.link = link saveProject(next, p) if (r.id === meta.value.id) { activate(next, p) notify(`Updated "${p.name}" from another device`) } } // Projects that are new here or changed here (not the untouched starter project). for (const m of listProjects()) { if ((m.cloud && m.cloud.owner !== uid) || (m.starter && !m.dirty)) continue if (!m.cloud || m.dirty) await upload(m, uid) } // A new browser: open the account's latest project instead of the untouched starter. if (meta.value.starter && !meta.value.dirty) { const latest = listProjects().filter(m => m.cloud?.owner === uid).sort((a, b) => b.updated - a.updated)[0] const p = latest && loadProject(latest.id) if (latest && p) { const starter = meta.value.id activate(latest, p) removeProject(starter) } } projects.value = listProjects() cloudState.value = 'synced' cloudError.value = '' } catch (e) { cloudError.value = (e as Error).message cloudState.value = navigator.onLine ? 'error' : 'offline' } finally { syncingAccount = false if (syncAgain) { syncAgain = false void syncAccount() } } } let cloudTimer: ReturnType | undefined function scheduleCloud() { if (!account.value) return clearTimeout(cloudTimer) cloudTimer = setTimeout(syncAccount, 2000) } async function signIn(email: string, password: string, create: boolean) { const res = await authCall<{ user?: AccountUser; message?: string; status: number }>('POST', create ? '/api/auth/register' : '/api/auth/login', { email, password }) if (!res.user) throw new Error(res.message || 'Could not sign in') setAccount(res.user) await syncAccount() notify(create ? 'Account created. Your projects are now saved in it.' : `Signed in as ${res.user.email}`) } async function signOut(removeHere: boolean) { const uid = account.value?.id if (uid) { // Bits not sent yet are sent now, so removing the projects here does not lose them. saveState(true) await syncAccount() } await authCall('POST', '/api/auth/logout').catch(() => {}) setAccount(null) if (removeHere && uid) { for (const m of listProjects()) if (m.cloud?.owner === uid && !m.dirty) removeProject(m.id) projects.value = listProjects() if (!projects.value.some(m => m.id === meta.value.id)) deleteProject(meta.value.id) } notify('Signed out') } async function changePassword(current: string, next: string) { await authCall('POST', '/api/auth/password', { current, next }) notify('Password changed. Other devices need to sign in again.') } async function deleteAccount(password: string) { const uid = account.value?.id await authCall('POST', '/api/auth/delete', { password }) setAccount(null) // The projects stay in this browser, now as local-only projects. for (const m of listProjects()) { if (m.cloud?.owner !== uid) continue const next = { ...m } delete next.cloud saveMeta(next) } if (meta.value.cloud?.owner === uid) { const next = { ...meta.value } delete next.cloud meta.value = next } projects.value = listProjects() notify('Account deleted. Your projects are still in this browser.') } // ── Savegames ───────────────────────────────────────────────────── interface VersionInfo { v: number at: number rev: number name: string size: number } async function listVersions(projectId: string): Promise { const res = await authCall<{ versions: VersionInfo[]; status: number }>('GET', `/api/me/projects/${projectId}/versions`) return res.versions ?? [] } async function fetchVersion(projectId: string, v: number): Promise { const res = await authCall<{ version?: { project: unknown }; status: number }>('GET', `/api/me/projects/${projectId}/versions/${v}`) if (!res.version) throw new Error('Version not found') return toProject(res.version.project) } /** * Brings back a savegame: as a new project, or in place of the current * state (which the server keeps as a savegame first, so this can be undone). */ async function restoreVersion(projectId: string, v: number, asCopy: boolean) { persistNow() const p = await fetchVersion(projectId, v) if (asCopy) { p.name = `${p.name} (${new Date(v).toLocaleDateString()})` activate(addProject(p), p) notify(`Opened the saved version as "${p.name}"`) return } const m = listProjects().find(x => x.id === projectId) if (!m) return const next: ProjectMeta = { ...m, name: p.name, updated: Date.now(), dirty: true, snapshot: true } saveProject(next, p) activate(next, p) scheduleCloud() notify('Restored. The state before is kept as a savegame too.') } async function listTrash(): Promise<{ id: string; name: string; deleted: number; v: number }[]> { const res = await authCall<{ projects: { id: string; name: string; deleted: number; v: number }[]; status: number }>('GET', '/api/me/trash') return res.projects ?? [] } async function restoreDeleted(item: { id: string; v: number }) { const p = await fetchVersion(item.id, item.v) persistNow() setPendingDeletes(pendingDeletes().filter(d => d.id !== item.id)) const m: ProjectMeta = { id: item.id, name: p.name, updated: Date.now(), dirty: true } saveProject(m, p) activate(m, p) scheduleCloud() notify(`"${p.name}" is back`) } /** Checks the session with the server, then syncs; again on focus and every minute. */ let accountStarted = false async function startAccount() { // Once per page load, however often the editor is shown. if (accountStarted) return accountStarted = true try { const res = await authCall<{ user: AccountUser | null; status: number }>('GET', '/api/auth/me') setAccount(res.user) if (res.user) await syncAccount() } catch { if (account.value) cloudState.value = 'offline' } finally { savesReady.value = true } let lastFocusSync = Date.now() const onFocus = () => { if (document.visibilityState === 'visible' && Date.now() - lastFocusSync > 10_000) { lastFocusSync = Date.now() void syncAccount() } } document.addEventListener('visibilitychange', onFocus) window.addEventListener('online', () => void syncAccount()) setInterval(() => document.visibilityState === 'visible' && void syncAccount(), 60_000) } function shape(node: CircuitNode) { return shapeOf(node, getDef.value) } rebuild() // A reload, or back or forward to an entry from before one: where that entry was. A fresh tab starts its first entry here. if (browserHistory) { if (entryNow()) restoreEntry(entryNow()) else record(false) } return { firstPage, project, meta, projects, getDef, def, selection, wireSel, selectedWires, clearSelection, pinSel, pickPins, pickPin, cablePicked, linkPicked, invertPicked, unwirePicked, placing, nav, views, notice, labelFocus, showHelp, dialog, notify, commit, persist, undo, redo, canUndo, canRedo, sim, tick, status, running, hz, cycles, errors, circuitStats, val, faceVal, startLoop, analyzerOpen, trace, traceVersion, clearTrace, watchSignal, unwatch, step, rebuild, resetState, open, back, mainId, goMain, goTo, addNode, canPlace, connect, deleteSelected, setWireColor, autoRoute, selectNet, toggleInput, press, toggleRow, pressRow, addPanel, undock, mergeSelectedPanels, combineSelected, setRowsType, setScreen, setRgb, benchResults, benchOpen, benchTarget, runBenchNow, setBench, dockBench, screens, keyQueues, devVersion, typingInto, typeInto, typeKey, clearScreen, clearKeys, asmDoc, saveAsm, loadProgram, screen, menuPage, challengesOpen, enterGame, showMenu, projectMode, projectOf, playCampaign, playChallenge, playWeekly, playerName, setPlayerName, fetchBoard, setRowType, addRow, dropRow, insertRow, moveRowTo, withDocked, withFollowers, issues, showIssue, sheetRequest, exportSheet, faceFor, designFace, fits, fitHover, connectFit, unplugMoved, latchTargetOf, latchPart, unlatch, moveRow, setRowGap, setRowKey, setRowColor, plugTarget, plugEnd, unplugEnd, setPitch, addCablePanel, dragPart, partSearch, cableChoices, cableOut, cableIn, pullCable, linking, startLinking, linkTo, stopLinking, setTidy, tidyAll, tidyEverything, exportTable, transistors, transistorsOfNode, canInvert, toggleInvert, nands, panelTab, panelOpen, togglePanel, focusRequest, swapMany, connectMany, connectSelectionTo, rewire, renameMany, setLabel, setSwitches, patchMany, arrangeSelected, selectOnly, focusNode, useSignal, selectSignal, canPlaceKind, paused, pause, saveNow, savesReady, setInputs, sound, setSound, play, task, boards, loadBoard, beginPuzzle, openPuzzle, publishPuzzle, ownEntry, libraryProblem, listLibrary, publishToLibrary, removeFromLibrary, addFromLibrary, updateFromLibrary, libraryVersion, libKeys, isBus, pinKind, connectorFor, addConnector, editConnector, connectorUses, removeConnector, bundleSelected, cabling, startCable, placeCable, setCableColor, removeCable, trimCableEnd, setBits, swap, unlink, unpack, toggleSplit, lineAt, makeIndependent, copy, paste, hasClip, duplicate, selectAll, packageSelected, createComponent, removeComponent, copyComponent, beginChallenge, checkChallenge, table, switchProject, newProject, duplicateProject, deleteProject, renameProject, loadExamples, exportJson, importAsProject, importComponents, linkState, linkError, linkUrl, createLink, pushLink, openLink, syncUrl, account, cloudState, cloudError, syncAccount, signIn, signOut, changePassword, deleteAccount, startAccount, versionsFor, listVersions, restoreVersion, listTrash, restoreDeleted, copyText, shape, } } let editor: ReturnType | undefined export function useEditor() { editor ??= create() return editor }