logigate/app/composables/useEditor.ts

825 lines
24 KiB
TypeScript

// 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 { runSteps, stats, truthTable, type Stats, type TestResult, type TruthTable } from '~/lib/logic/analyze'
import { CHALLENGES, challengeSteps, type Challenge } from '~/lib/logic/challenges'
import { compile } from '~/lib/logic/compile'
import { shapeOf, type Pt } from '~/lib/logic/geometry'
import {
addExamples,
containsDef,
copySelection,
createProject,
deleteComponent,
duplicateComponent,
lookup,
mergeComponents,
newComponent,
packageSelection,
pasteClip,
pruneWires,
startChallenge,
uid,
type Clip,
} from '~/lib/logic/ops'
import { parseProject, toProject } from '~/lib/logic/project'
import { Simulator } from '~/lib/logic/sim'
import {
currentId,
listProjects,
loadProject,
migrateLegacy,
newLocalId,
removeProject,
saveMeta,
saveProject,
setCurrentId,
type ProjectMeta,
} from '~/lib/logic/storage'
import type { CircuitNode, NodeKind, PinRef, Project, WireColor } from '~/lib/logic/types'
export interface Placing {
kind: NodeKind
chip?: 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() }
// A first visit through a share link should not leave an unused starter
// project behind; it is saved only once something changes in it.
placeholder = location.pathname.startsWith('/p/')
if (!placeholder) saveProject(meta, project)
return { meta, project }
}
let placeholder = false
const start = initial()
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 | 'projects' | 'share'>(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 = []
}
// ── Saving ────────────────────────────────────────────────────────
let saveTimer: ReturnType<typeof setTimeout> | undefined
function persistNow() {
clearTimeout(saveTimer)
saveTimer = undefined
meta.value = { ...meta.value, name: project.value.name, updated: Date.now() }
if (!saveProject(toRaw(meta.value), toRaw(project.value))) notify('Browser storage is full. Export your project to keep it.', 'error')
projects.value = listProjects()
}
function persist() {
placeholder = false
clearTimeout(saveTimer)
saveTimer = setTimeout(persistNow, 300)
scheduleSync()
}
// ── History ───────────────────────────────────────────────────────
const snap = () => JSON.stringify({ components: project.value.components, solved: project.value.solved })
let last = snap()
const undoStack: string[] = []
const redoStack: string[] = []
const canUndo = ref(false)
const canRedo = ref(false)
function resetHistory() {
undoStack.length = 0
redoStack.length = 0
last = snap()
canUndo.value = false
canRedo.value = false
}
/** Record a change. Structural changes (parts, wires) rebuild the simulation. */
function commit(structural = true) {
if (structural) pruneWires(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'>
project.value.components = data.components
project.value.solved = data.solved
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}`
const carry = sim.value && simRoot === key ? sim.value.carry() : undefined
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))
}
s.run(BUDGET)
if (simRoot !== key) cycles.value = 0
sim.value = s
simRoot = key
errors.value = nl.errors
circuitStats.value = stats(nl)
tick.value++
}
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 = 0
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
if (running.value && s.nl.clocks.length) {
if (hz.value > 0) {
acc += dt
const half = 500 / hz.value
for (let n = 0; acc >= half && n < 16; n++) {
acc -= half
s.run(BUDGET)
s.setClock(s.clock ^ 1)
if (s.clock) rises++
}
if (acc > half) acc = 0
} else {
const end = performance.now() + 10
while (performance.now() < end) {
if (!s.run(BUDGET)) break
s.setClock(s.clock ^ 1)
if (s.clock) rises++
}
}
}
if (rises) cycles.value += rises
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 ────────────────────────────────────────────────────
function open(id: string, push = true) {
if (id === def.value.id || !getDef.value(id)) return
if (push) nav.value.push(def.value.id)
project.value.openId = id
clearSelection()
placing.value = null
persist()
rebuild()
}
function back() {
const id = nav.value.pop()
if (id) open(id, false)
}
// ── Editing ───────────────────────────────────────────────────────
function nextLabel(kind: 'input' | 'output'): string {
const used = new Set(def.value.nodes.filter(n => n.kind === kind).map(n => n.label))
if (kind === 'input') {
for (const c of 'ABCDEFGHIJKLMNOPRSTUVWXYZ') if (!used.has(c)) return c
return `I${used.size + 1}`
}
if (!used.has('Q')) return 'Q'
for (let i = 1; ; i++) if (!used.has(`Q${i}`)) return `Q${i}`
}
function addNode(p: Placing, x: number, y: number): CircuitNode {
const node: CircuitNode = { id: uid('n'), kind: p.kind, x, y }
if (p.chip) node.chip = p.chip
if (p.kind === 'input' || p.kind === 'output') node.label = nextLabel(p.kind)
if (p.kind === 'note') node.label = 'Note'
def.value.nodes.push(node)
selection.value = [node.id]
wireSel.value = []
commit()
return node
}
function canPlace(chipId: string) {
return !containsDef(project.value, chipId, def.value.id)
}
function connect(from: PinRef, to: PinRef, pts?: Pt[]) {
const d = def.value
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)
wireSel.value = []
commit()
}
function deleteSelected() {
const d = def.value
if (!selection.value.length && !wireSel.value.length) return
const ids = new Set(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()
}
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 toggleInput(node: CircuitNode) {
node.on = !node.on
sim.value?.setSource(node.id, node.on)
persist()
}
function press(node: CircuitNode, down: boolean) {
if (down) pressed.add(node.id)
else pressed.delete(node.id)
sim.value?.setSource(node.id, down)
}
let clip: Clip | null = null
let pasteCount = 0
function copy() {
if (!selection.value.length) return
clip = copySelection(def.value, new Set(selection.value))
pasteCount = 0
notify(`Copied ${clip.nodes.length} part${clip.nodes.length === 1 ? '' : 's'}`)
}
function paste() {
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')
selection.value = pasteClip(def.value, usable, 2 * pasteCount, 2 * pasteCount)
wireSel.value = []
commit()
}
function duplicate() {
copy()
paste()
}
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)
const d = startChallenge(project.value, c)
commit()
open(d.id)
}
function checkChallenge(): TestResult | null {
const c = CHALLENGES.find(c => c.id === def.value.challenge)
if (!c) return null
const res = runSteps(getDef.value, def.value.id, challengeSteps(c))
if (res.pass && !project.value.solved.includes(c.id)) {
project.value.solved.push(c.id)
commit(false)
}
return res
}
function table(): TruthTable | { error: string } {
return truthTable(getDef.value, def.value.id)
}
// ── Projects ──────────────────────────────────────────────────────
function activate(m: ProjectMeta, p: Project) {
meta.value = m
project.value = p
setCurrentId(m.id)
resetHistory()
nav.value = []
clearSelection()
placing.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()
syncUrl()
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)
return m
}
function newProject(examples: boolean) {
persistNow()
const p = createProject({ examples })
activate(addProject(p), p)
}
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) {
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 }, p)
projects.value = listProjects()
}
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) {
const blob = new Blob([text], { type: 'application/json' })
const a = document.createElement('a')
a.href = URL.createObjectURL(blob)
a.download = name
a.click()
URL.revokeObjectURL(a.href)
}
function exportJson() {
persistNow()
const slug = project.value.name.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '') || 'project'
download(`${slug}.logigate.json`, JSON.stringify(project.value, null, 1))
}
/** 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 new Error((data as { message?: string }).message || `Server error ${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 } }
saveMeta(toRaw(meta.value))
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) {
try {
await navigator.clipboard.writeText(text)
notify('Link copied')
} catch {
notify('Copy failed; select the link and copy it by hand', 'error')
}
}
window.addEventListener('beforeunload', () => {
if (saveTimer) persistNow()
})
function shape(node: CircuitNode) {
return shapeOf(node, getDef.value)
}
rebuild()
return {
project,
meta,
projects,
getDef,
def,
selection,
wireSel,
selectedWires,
clearSelection,
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,
open,
back,
addNode,
canPlace,
connect,
deleteSelected,
setWireColor,
autoRoute,
selectNet,
toggleInput,
press,
copy,
paste,
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,
copyText,
shape,
}
}
let editor: ReturnType<typeof create> | undefined
export function useEditor() {
editor ??= create()
return editor
}