logigate/app/composables/useEditor.ts

2946 lines
107 KiB
TypeScript
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

// 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,
} 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 { 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 { CircuitNode, ComponentDef, ConnectorType, HeldState, LampColor, LibraryOrigin, NodeKind, 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<ProjectMeta[]>(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<ProjectMeta>(start.meta)
const project = ref<Project>(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<string[]>([])
const wireSel = ref<string[]>([])
const placing = ref<Placing | null>(null)
const nav = ref<string[]>([])
const views = reactive<Record<string, View>>({})
const notice = ref<{ text: string; kind: 'ok' | 'error' } | null>(null)
const labelFocus = ref(0)
const showHelp = ref(false)
const dialog = ref<null | 'connector' | 'share' | 'account' | 'versions' | 'table' | 'publish' | 'settings' | 'search' | 'face' | 'library' | 'library-publish'>(null)
/** The component whose box is being drawn in the face designer. */
const faceFor = ref<string | null>(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<string | null>(null)
let noticeTimer: ReturnType<typeof setTimeout> | 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<typeof setTimeout> | 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, 'components' | 'solved' | 'connectors'>
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<Simulator | null>(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<string[]>([])
const circuitStats = ref<Stats>({ nands: 0, sequential: false, delay: 0 })
const pressed = new Set<string>()
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))
}
}
}
s.run(BUDGET)
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<string>()
/** 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
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)
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
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
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)
}
s.setClock(1)
s.run(BUDGET)
cycles.value++
s.setClock(0)
s.run(BUDGET)
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<Placing | null>(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
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<SoundSettings>(loadSoundSettings())
function play(s: Sound) {
sfx(s, sound.value)
}
function setSound(patch: Partial<SoundSettings>) {
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:<id>' 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<string>): Set<string> {
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<string>): Set<string> {
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)
}
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<string, string>) {
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<MenuPage>('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 | 'main' | 'load'>(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<string, Project['mode'] | null>()
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)
}
/** 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<string>) {
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<string, number>()
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<Record<string, PuzzleSummary>>({})
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<string> {
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<LibraryOrigin> {
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<string> {
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<number | null> {
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<CircuitNode, 'color' | 'hz' | 'size'>, 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<string | null>(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`)
}
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<LinkState>(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<T>(method: string, url: string, body?: unknown, key?: string): Promise<T> {
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<typeof setTimeout> | 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<AccountUser | null>(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<T>(method: string, url: string, body?: unknown): Promise<T> {
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<ProjectMeta>) {
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<typeof setTimeout> | 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<VersionInfo[]> {
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<Project> {
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,
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,
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,
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<typeof create> | undefined
export function useEditor() {
editor ??= create()
return editor
}