bireactive 0.2.3 → 0.3.0

package/dist/formats/lens.js

@@ -0,0 +1,54 @@
+// lens.ts — hub-and-spoke wiring: one abstract-value hub cell, one
+// stateful text lens per concrete syntax.
+//
+// Each spoke's complement is { text, tree, errors, synced }: the
+// concrete text, its tolerant CST, current error regions, and the hub
+// value this text last agreed with (by identity — the hub only changes
+// identity on a real change). The spoke:
+//
+//   bwd   — parse the written text. Clean ⇒ push the recovered value to
+//           the hub. Errors ⇒ `updates: [SKIP]` (hub untouched),
+//           but the complement keeps the broken text so the view echoes
+//           it back instead of trampling the editor.
+//   step  — when the hub moved away from `synced`, absorb it by
+//           three-way surgical merge around any error regions.
+//   fwd   — the complement's text.
+import { cell, lens, SKIP } from "../core/cell.js";
+import { deepEqual, mergeText, valueOf, } from "./cst.js";
+function fromValue(adapter, v) {
+    const text = adapter.print(v);
+    const { tree, errors } = adapter.parse(text);
+    return { text, tree, errors, synced: v };
+}
+function absorb(adapter, c, theirs) {
+    const { text } = mergeText(adapter, c.text, c.tree, c.errors, theirs, c.synced);
+    if (text === c.text)
+        return { ...c, synced: theirs };
+    const { tree, errors } = adapter.parse(text);
+    return { text, tree, errors, synced: theirs };
+}
+/** Writable hub for a shared abstract value (deep-equality pruned). */
+export function valueHub(initial) {
+    return cell(initial, { equals: deepEqual });
+}
+/** Writable text view of `hub` in `adapter`'s syntax. Valid edits push
+ *  through; broken edits hold the hub and merge external changes around
+ *  the error regions. */
+export function formatSpoke(hub, adapter) {
+    return lens(hub, {
+        init: ([v]) => fromValue(adapter, v),
+        step: ([v], c) => (v === c.synced ? c : absorb(adapter, c, v)),
+        fwd: (_vals, c) => c.text,
+        bwd: (target, _vals, c) => {
+            const { tree, errors } = adapter.parse(target);
+            if (errors.length === 0) {
+                const v = valueOf(tree);
+                return { updates: [v], complement: { text: target, tree, errors, synced: v } };
+            }
+            return {
+                updates: [SKIP],
+                complement: { text: target, tree, errors, synced: c.synced },
+            };
+        },
+    });
+}

package/dist/formats/toml.d.ts

@@ -0,0 +1,2 @@
+import { type FormatAdapter } from "./cst.js";
+export declare const tomlFormat: FormatAdapter;

package/dist/formats/toml.js

@@ -0,0 +1,526 @@
+// toml.ts — tolerant TOML adapter (line subset).
+//
+// Supports `key = value` lines, `[section]` headers (dotted paths),
+// comments, basic/literal strings, numbers, booleans, inline arrays
+// (multi-line) and inline tables. The canonical printer emits root
+// scalars first, then one [section] per top-level object; deeper
+// objects render as inline tables. TOML has no null: ops carrying null
+// are reported as inexpressible (full-reprint fallback on clean docs).
+// `[[arrays-of-tables]]`, dotted keys, and datetimes parse as error
+// regions rather than failing the document.
+import { isObject, } from "./cst.js";
+const BARE_KEY = /^[A-Za-z0-9_-]+$/;
+const NUMRE = /^[-+]?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?/;
+const HEADER = /^\[\s*([^\]]+?)\s*\]\s*(?:#.*)?$/;
+class P {
+    text;
+    pos = 0;
+    errors = [];
+    root;
+    current;
+    currentEntry = null;
+    lastContentEnd = -1;
+    sawSection = false;
+    constructor(text) {
+        this.text = text;
+        this.root = {
+            kind: "object",
+            start: 0,
+            end: text.length,
+            entries: [],
+            meta: { kind: "root", preambleEnd: 0 },
+        };
+        this.current = this.root;
+    }
+    err(start, end, message) {
+        this.errors.push({ start, end, message });
+    }
+    run() {
+        const t = this.text;
+        while (this.pos < t.length) {
+            const lineStart = this.pos;
+            let lineEnd = t.indexOf("\n", this.pos);
+            if (lineEnd === -1)
+                lineEnd = t.length;
+            let j = lineStart;
+            while (j < lineEnd && (t[j] === " " || t[j] === "\t"))
+                j++;
+            if (j >= lineEnd || t[j] === "#" || t[j] === "\r") {
+                this.pos = lineEnd + 1;
+                continue;
+            }
+            if (t[j] === "[") {
+                this.header(j, lineStart, lineEnd);
+                this.pos = lineEnd + 1;
+                continue;
+            }
+            this.keyValue(j, lineStart, lineEnd);
+        }
+        this.finalizeSection();
+    }
+    finalizeSection() {
+        if (this.current !== this.root && this.lastContentEnd >= 0) {
+            this.current.end = Math.max(this.current.end, this.lastContentEnd);
+            if (this.currentEntry !== null) {
+                this.currentEntry.end = this.current.end;
+            }
+        }
+    }
+    errorLine(lineStart, contentStart, lineEnd, message) {
+        this.err(contentStart, lineEnd, message);
+        const node = { kind: "error", start: contentStart, end: lineEnd };
+        this.current.entries.push({
+            key: undefined,
+            start: lineStart,
+            end: lineEnd,
+            node,
+            meta: { lineStart },
+        });
+        this.lastContentEnd = lineEnd;
+    }
+    header(j, lineStart, lineEnd) {
+        const raw = this.text.slice(j, lineEnd);
+        if (raw.startsWith("[[")) {
+            this.errorLine(lineStart, j, lineEnd, "arrays of tables are not supported");
+            return;
+        }
+        const m = HEADER.exec(raw);
+        if (m === null) {
+            this.errorLine(lineStart, j, lineEnd, "malformed table header");
+            return;
+        }
+        const segs = m[1].split(".").map(s => s.trim().replace(/^["']|["']$/g, ""));
+        if (segs.some(s => s.length === 0)) {
+            this.errorLine(lineStart, j, lineEnd, "malformed table path");
+            return;
+        }
+        this.finalizeSection();
+        let node = this.root;
+        for (let i = 0; i < segs.length; i++) {
+            const seg = segs[i];
+            const existing = node.entries.find(e => e.key === seg);
+            if (existing !== undefined) {
+                if (existing.node.kind !== "object") {
+                    this.errorLine(lineStart, j, lineEnd, `'${seg}' is already a value`);
+                    return;
+                }
+                node = existing.node;
+                if (i === segs.length - 1) {
+                    node.meta.kind = "section";
+                    this.currentEntry = existing;
+                }
+                continue;
+            }
+            const child = {
+                kind: "object",
+                start: lineStart,
+                end: lineEnd,
+                entries: [],
+                meta: { kind: i === segs.length - 1 ? "section" : "implicit" },
+            };
+            const entry = {
+                key: seg,
+                start: lineStart,
+                end: lineEnd,
+                node: child,
+                meta: { lineStart },
+            };
+            node.entries.push(entry);
+            node = child;
+            if (i === segs.length - 1)
+                this.currentEntry = entry;
+        }
+        this.current = node;
+        this.lastContentEnd = lineEnd;
+        this.sawSection = true;
+    }
+    keyValue(j, lineStart, lineEnd) {
+        const t = this.text;
+        let key = null;
+        let p = j;
+        if (t[p] === '"' || t[p] === "'") {
+            const s = this.scanString(p);
+            if (s !== null) {
+                key = s.value;
+                p = s.end;
+            }
+        }
+        else {
+            let e = p;
+            while (e < lineEnd && BARE_KEY.test(t[e]))
+                e++;
+            if (e > p) {
+                key = t.slice(p, e);
+                p = e;
+            }
+        }
+        while (p < lineEnd && (t[p] === " " || t[p] === "\t"))
+            p++;
+        if (key === null || t[p] !== "=") {
+            this.errorLine(lineStart, j, lineEnd, "expected 'key = value'");
+            this.pos = lineEnd + 1;
+            return;
+        }
+        p++;
+        while (p < lineEnd && (t[p] === " " || t[p] === "\t"))
+            p++;
+        let node = this.parseValue(p);
+        // Past the value: only whitespace or a comment may remain on its line.
+        let q = node.end;
+        const vLineEnd = endOfLine(t, node.end);
+        while (q < vLineEnd && (t[q] === " " || t[q] === "\t"))
+            q++;
+        if (q < vLineEnd && t[q] !== "#" && node.kind !== "error") {
+            this.err(node.start, vLineEnd, "unexpected content after value");
+            node = { kind: "error", start: node.start, end: vLineEnd };
+        }
+        const entry = {
+            key: node.kind === "error" ? undefined : key,
+            start: lineStart,
+            end: node.end,
+            node,
+            meta: { lineStart },
+        };
+        this.current.entries.push(entry);
+        if (this.current === this.root && !this.sawSection) {
+            this.root.meta.preambleEnd = Math.min(vLineEnd + 1, t.length);
+        }
+        this.lastContentEnd = node.end;
+        this.pos = vLineEnd + 1;
+    }
+    scanString(start) {
+        const t = this.text;
+        const q = t[start];
+        let out = "";
+        let p = start + 1;
+        while (p < t.length && t[p] !== "\n") {
+            const c = t[p];
+            if (q === '"' && c === "\\") {
+                const esc = t[p + 1];
+                p += 2;
+                if (esc === "n")
+                    out += "\n";
+                else if (esc === "t")
+                    out += "\t";
+                else
+                    out += esc ?? "";
+                continue;
+            }
+            if (c === q)
+                return { value: out, end: p + 1 };
+            out += c;
+            p++;
+        }
+        return null;
+    }
+    skipValueWs(p) {
+        const t = this.text;
+        for (;;) {
+            while (p < t.length && (t[p] === " " || t[p] === "\t" || t[p] === "\n" || t[p] === "\r"))
+                p++;
+            if (t[p] === "#") {
+                while (p < t.length && t[p] !== "\n")
+                    p++;
+                continue;
+            }
+            return p;
+        }
+    }
+    garbage(start, message) {
+        const t = this.text;
+        let p = start;
+        let depth = 0;
+        while (p < t.length) {
+            const c = t[p];
+            if (c === "[" || c === "{")
+                depth++;
+            else if (c === "]" || c === "}") {
+                if (depth === 0)
+                    break;
+                depth--;
+            }
+            else if (depth === 0 && (c === "," || c === "\n" || c === "#"))
+                break;
+            p++;
+        }
+        let end = p;
+        while (end > start && (t[end - 1] === " " || t[end - 1] === "\t"))
+            end--;
+        if (end === start)
+            end = Math.min(start + 1, t.length);
+        this.err(start, end, message);
+        return { kind: "error", start, end };
+    }
+    parseValue(start) {
+        const t = this.text;
+        const c = t[start];
+        if (c === undefined || c === "\n") {
+            this.err(start, start + 1, "missing value");
+            return { kind: "error", start, end: Math.min(start + 1, t.length) };
+        }
+        if (c === '"' || c === "'") {
+            const s = this.scanString(start);
+            if (s === null)
+                return this.garbage(start, "unterminated string");
+            return { kind: "scalar", start, end: s.end, value: s.value };
+        }
+        if (c === "[") {
+            const items = [];
+            let p = start + 1;
+            for (;;) {
+                p = this.skipValueWs(p);
+                if (p >= t.length) {
+                    this.err(start, start + 1, "unclosed array");
+                    return { kind: "array", start, end: p, items };
+                }
+                if (t[p] === "]")
+                    return { kind: "array", start, end: p + 1, items };
+                if (t[p] === ",") {
+                    p++;
+                    continue;
+                }
+                const item = this.parseValue(p);
+                items.push(item);
+                p = item.end;
+            }
+        }
+        if (c === "{") {
+            const entries = [];
+            let p = start + 1;
+            for (;;) {
+                p = this.skipValueWs(p);
+                if (p >= t.length || t[p] === "\n") {
+                    this.err(start, start + 1, "unclosed inline table");
+                    return {
+                        kind: "object",
+                        start,
+                        end: p,
+                        entries,
+                        meta: { kind: "inline" },
+                    };
+                }
+                if (t[p] === "}") {
+                    return {
+                        kind: "object",
+                        start,
+                        end: p + 1,
+                        entries,
+                        meta: { kind: "inline" },
+                    };
+                }
+                if (t[p] === ",") {
+                    p++;
+                    continue;
+                }
+                const entryStart = p;
+                let key = null;
+                if (t[p] === '"' || t[p] === "'") {
+                    const s = this.scanString(p);
+                    if (s !== null) {
+                        key = s.value;
+                        p = s.end;
+                    }
+                }
+                else {
+                    let e = p;
+                    while (e < t.length && BARE_KEY.test(t[e]))
+                        e++;
+                    if (e > p) {
+                        key = t.slice(p, e);
+                        p = e;
+                    }
+                }
+                while (p < t.length && (t[p] === " " || t[p] === "\t"))
+                    p++;
+                if (key === null || t[p] !== "=") {
+                    const g = this.garbage(entryStart, "expected 'key = value' in inline table");
+                    entries.push({ key: undefined, start: entryStart, end: g.end, node: g });
+                    p = Math.max(g.end, entryStart + 1);
+                    continue;
+                }
+                p++;
+                while (p < t.length && (t[p] === " " || t[p] === "\t"))
+                    p++;
+                const v = this.parseValue(p);
+                entries.push({
+                    key: v.kind === "error" ? undefined : key,
+                    start: entryStart,
+                    end: v.end,
+                    node: v,
+                });
+                p = v.end;
+            }
+        }
+        const rest = t.slice(start, endOfLine(t, start));
+        if (rest.startsWith("true"))
+            return this.literal(start, 4, true);
+        if (rest.startsWith("false"))
+            return this.literal(start, 5, false);
+        const num = NUMRE.exec(rest);
+        if (num !== null && num[0].length > 0 && /^[-+]?\d/.test(rest)) {
+            const end = start + num[0].length;
+            const after = t[end];
+            if (after === undefined || " \t\n,]}#".includes(after)) {
+                return { kind: "scalar", start, end, value: Number(num[0]) };
+            }
+        }
+        return this.garbage(start, "expected a value");
+    }
+    literal(start, len, value) {
+        const after = this.text[start + len];
+        if (after === undefined || " \t\n,]}#".includes(after)) {
+            return { kind: "scalar", start, end: start + len, value };
+        }
+        return this.garbage(start, "expected a value");
+    }
+}
+function endOfLine(text, pos) {
+    const nl = text.indexOf("\n", pos);
+    return nl === -1 ? text.length : nl;
+}
+function parse(text) {
+    const p = new P(text);
+    p.run();
+    if (p.root.entries.length === 0 && p.errors.length === 0) {
+        p.err(0, 0, "empty document");
+        return { tree: { kind: "error", start: 0, end: 0 }, errors: p.errors };
+    }
+    return { tree: p.root, errors: p.errors };
+}
+// -- printing ----------------------------------------------------------------
+function containsNull(v) {
+    if (v === null)
+        return true;
+    if (Array.isArray(v))
+        return v.some(containsNull);
+    if (isObject(v))
+        return Object.values(v).some(containsNull);
+    return false;
+}
+function printKey(k) {
+    return BARE_KEY.test(k) ? k : JSON.stringify(k);
+}
+function printInline(v) {
+    if (v === null)
+        return '""'; // unreachable: null ops are rejected upstream
+    if (typeof v === "string")
+        return JSON.stringify(v);
+    if (typeof v !== "object")
+        return String(v);
+    if (Array.isArray(v))
+        return `[${v.map(printInline).join(", ")}]`;
+    const keys = Object.keys(v);
+    if (keys.length === 0)
+        return "{}";
+    return `{ ${keys.map(k => `${printKey(k)} = ${printInline(v[k])}`).join(", ")} }`;
+}
+function sectionBody(obj) {
+    return Object.keys(obj)
+        .map(k => `${printKey(k)} = ${printInline(obj[k])}`)
+        .join("\n");
+}
+function printSection(key, obj) {
+    const body = sectionBody(obj);
+    return body.length > 0 ? `[${printKey(key)}]\n${body}` : `[${printKey(key)}]`;
+}
+function print(value) {
+    if (!isObject(value))
+        return "# TOML requires a table at the root\n";
+    const keys = Object.keys(value);
+    const scalars = keys.filter(k => !isObject(value[k]));
+    const tables = keys.filter(k => isObject(value[k]));
+    const parts = [];
+    if (scalars.length > 0) {
+        parts.push(scalars.map(k => `${printKey(k)} = ${printInline(value[k])}`).join("\n"));
+    }
+    for (const k of tables)
+        parts.push(printSection(k, value[k]));
+    return `${parts.join("\n\n")}\n`;
+}
+// -- ops → edits ---------------------------------------------------------------
+function tableKind(node) {
+    if (node.kind !== "object")
+        return null;
+    return node.meta.kind;
+}
+function opToEdit(op, text) {
+    switch (op.type) {
+        case "replace": {
+            const { node, value } = op;
+            if (containsNull(value))
+                return null;
+            const kind = tableKind(node);
+            if (kind === "root") {
+                if (!isObject(value))
+                    return null;
+                return [{ start: 0, end: text.length, text: print(value) }];
+            }
+            if (kind === "section") {
+                if (!isObject(value) || op.entry?.key === undefined)
+                    return null;
+                return [{ start: node.start, end: node.end, text: printSection(op.entry.key, value) }];
+            }
+            if (kind === "implicit")
+                return null;
+            // Inline value (scalar, array, inline table, or entry value line).
+            return [{ start: node.start, end: node.end, text: printInline(value) }];
+        }
+        case "insert": {
+            const { obj, key, value } = op;
+            if (containsNull(value))
+                return null;
+            const kind = tableKind(obj);
+            if (kind === "root") {
+                const meta = obj.meta;
+                if (isObject(value)) {
+                    const prefix = text.length === 0 || text.endsWith("\n") ? "\n" : "\n\n";
+                    return [
+                        {
+                            start: text.length,
+                            end: text.length,
+                            text: `${prefix}${printSection(key, value)}\n`,
+                        },
+                    ];
+                }
+                const at = Math.min(meta.preambleEnd ?? 0, text.length);
+                const pad = at > 0 && text[at - 1] !== "\n" ? "\n" : "";
+                return [{ start: at, end: at, text: `${pad}${printKey(key)} = ${printInline(value)}\n` }];
+            }
+            if (kind === "section" || kind === "implicit") {
+                // Anchor after the surviving line entry, never after a child
+                // section (the key would land in the wrong table); with no safe
+                // anchor, insert right below the header.
+                const afterKind = op.after !== undefined ? tableKind(op.after.node) : null;
+                const anchor = op.after !== undefined && (afterKind === null || afterKind === "inline")
+                    ? op.after.end
+                    : endOfLine(text, obj.start);
+                return [{ start: anchor, end: anchor, text: `\n${printKey(key)} = ${printInline(value)}` }];
+            }
+            // Inline table.
+            if (obj.entries.length === 0)
+                return null; // diff replaces empty objects
+            const anchor = (op.after ?? obj.entries[obj.entries.length - 1]).end;
+            return [{ start: anchor, end: anchor, text: `, ${printKey(key)} = ${printInline(value)}` }];
+        }
+        case "delete": {
+            const { obj, entry } = op;
+            const kind = tableKind(obj);
+            if (kind === "inline") {
+                const idx = obj.entries.indexOf(entry);
+                const next = obj.entries[idx + 1];
+                if (next !== undefined)
+                    return [{ start: entry.start, end: next.start, text: "" }];
+                const prev = obj.entries[idx - 1];
+                const start = prev !== undefined ? prev.end : obj.start + 1;
+                return [{ start, end: entry.end, text: "" }];
+            }
+            // Line-level entry (scalar line or whole section).
+            const eol = endOfLine(text, entry.end);
+            const end = eol < text.length ? eol + 1 : eol;
+            const meta = entry.meta;
+            const start = meta?.lineStart ?? entry.start;
+            return [{ start, end, text: "" }];
+        }
+    }
+}
+export const tomlFormat = { name: "TOML", parse, print, opToEdit };

package/dist/formats/yaml.d.ts

@@ -0,0 +1,2 @@
+import { type FormatAdapter } from "./cst.js";
+export declare const yamlFormat: FormatAdapter;