bireactive 0.2.4 → 0.3.0

package/dist/formats/edn.js

@@ -0,0 +1,301 @@
+// edn.ts — tolerant EDN adapter (maps, vectors, strings, numbers,
+// booleans, nil, keywords). Keyword map keys project to plain string
+// keys in the abstract value; commas are whitespace; `;` comments run
+// to end of line. Recovery mirrors the JSON adapter: garbage runs to
+// the next delimiter at depth zero become ErrorNodes.
+import { indentOf, } from "./cst.js";
+const WS = /[ \t\r\n,]/;
+const NUM = /^[-+]?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?/;
+const KEYWORD = /^:[A-Za-z_*+!?<>=.][\w*+!?<>=.-]*/;
+const SAFE_KEY = /^[A-Za-z_][\w-]*$/;
+class P {
+    text;
+    pos = 0;
+    errors = [];
+    constructor(text) {
+        this.text = text;
+    }
+    err(start, end, message) {
+        this.errors.push({ start, end, message });
+    }
+    skipWs() {
+        for (;;) {
+            while (this.pos < this.text.length && WS.test(this.text[this.pos]))
+                this.pos++;
+            if (this.text[this.pos] === ";") {
+                while (this.pos < this.text.length && this.text[this.pos] !== "\n")
+                    this.pos++;
+                continue;
+            }
+            return;
+        }
+    }
+    peek() {
+        return this.text[this.pos];
+    }
+    garbage(start, message) {
+        let depth = 0;
+        while (this.pos < this.text.length) {
+            const c = this.text[this.pos];
+            if (c === '"') {
+                this.pos++;
+                while (this.pos < this.text.length) {
+                    const s = this.text[this.pos];
+                    if (s === "\\")
+                        this.pos += 2;
+                    else if (s === '"' || s === "\n") {
+                        this.pos++;
+                        break;
+                    }
+                    else
+                        this.pos++;
+                }
+                continue;
+            }
+            if (c === "{" || c === "[" || c === "(")
+                depth++;
+            else if (c === "}" || c === "]" || c === ")") {
+                if (depth === 0)
+                    break;
+                depth--;
+            }
+            else if (depth === 0 && WS.test(c))
+                break;
+            this.pos++;
+        }
+        let end = this.pos;
+        if (end === start)
+            end = Math.min(start + 1, this.text.length);
+        this.err(start, end, message);
+        return { kind: "error", start, end };
+    }
+    scanString() {
+        const start = this.pos;
+        this.pos++;
+        let out = "";
+        while (this.pos < this.text.length) {
+            const c = this.text[this.pos];
+            if (c === '"') {
+                this.pos++;
+                return { value: out, end: this.pos, ok: true };
+            }
+            if (c === "\n")
+                break;
+            if (c === "\\") {
+                const esc = this.text[this.pos + 1];
+                this.pos += 2;
+                if (esc === "n")
+                    out += "\n";
+                else if (esc === "t")
+                    out += "\t";
+                else if (esc === "r")
+                    out += "\r";
+                else
+                    out += esc ?? "";
+                continue;
+            }
+            out += c;
+            this.pos++;
+        }
+        this.err(start, this.pos, "unterminated string");
+        return { value: out, end: this.pos, ok: false };
+    }
+    parseValue() {
+        const start = this.pos;
+        const c = this.peek();
+        if (c === "{")
+            return this.parseMap();
+        if (c === "[")
+            return this.parseVector();
+        if (c === '"') {
+            const s = this.scanString();
+            if (!s.ok)
+                return { kind: "error", start, end: s.end };
+            return { kind: "scalar", start, end: s.end, value: s.value };
+        }
+        const rest = this.text.slice(this.pos);
+        const kw = KEYWORD.exec(rest);
+        if (kw) {
+            this.pos += kw[0].length;
+            return { kind: "scalar", start, end: this.pos, value: kw[0].slice(1) };
+        }
+        const num = NUM.exec(rest);
+        if (num && num[0].length > 0 && /^[-+]?\d/.test(rest)) {
+            this.pos += num[0].length;
+            const after = this.peek();
+            if (after !== undefined && !WS.test(after) && !"}])".includes(after)) {
+                return this.garbage(start, "malformed number");
+            }
+            return { kind: "scalar", start, end: this.pos, value: Number(num[0]) };
+        }
+        for (const [word, value] of [
+            ["true", true],
+            ["false", false],
+            ["nil", null],
+        ]) {
+            if (rest.startsWith(word)) {
+                const after = this.text[this.pos + word.length];
+                if (after === undefined || WS.test(after) || "}])".includes(after)) {
+                    this.pos += word.length;
+                    return { kind: "scalar", start, end: this.pos, value };
+                }
+            }
+        }
+        return this.garbage(start, "expected a value");
+    }
+    parseMap() {
+        const start = this.pos;
+        this.pos++; // {
+        const entries = [];
+        for (;;) {
+            this.skipWs();
+            const c = this.peek();
+            if (c === undefined) {
+                this.err(start, start + 1, "unclosed map");
+                return { kind: "object", start, end: this.pos, entries };
+            }
+            if (c === "}") {
+                this.pos++;
+                return { kind: "object", start, end: this.pos, entries };
+            }
+            const entryStart = this.pos;
+            let key;
+            if (c === ":") {
+                const kw = KEYWORD.exec(this.text.slice(this.pos));
+                if (kw) {
+                    key = kw[0].slice(1);
+                    this.pos += kw[0].length;
+                }
+            }
+            else if (c === '"') {
+                const s = this.scanString();
+                if (s.ok)
+                    key = s.value;
+            }
+            if (key === undefined) {
+                const node = this.garbage(entryStart, "expected a keyword or string key");
+                entries.push({ key: undefined, start: entryStart, end: node.end, node });
+                continue;
+            }
+            this.skipWs();
+            if (this.peek() === undefined || this.peek() === "}") {
+                const end = this.pos;
+                this.err(entryStart, end, "key without a value");
+                entries.push({
+                    key: undefined,
+                    start: entryStart,
+                    end,
+                    node: { kind: "error", start: entryStart, end },
+                });
+                continue;
+            }
+            const node = this.parseValue();
+            entries.push({
+                key: node.kind === "error" ? undefined : key,
+                start: entryStart,
+                end: node.end,
+                node,
+            });
+        }
+    }
+    parseVector() {
+        const start = this.pos;
+        this.pos++; // [
+        const items = [];
+        for (;;) {
+            this.skipWs();
+            const c = this.peek();
+            if (c === undefined) {
+                this.err(start, start + 1, "unclosed vector");
+                return { kind: "array", start, end: this.pos, items };
+            }
+            if (c === "]") {
+                this.pos++;
+                return { kind: "array", start, end: this.pos, items };
+            }
+            items.push(this.parseValue());
+        }
+    }
+}
+function parse(text) {
+    const p = new P(text);
+    p.skipWs();
+    if (p.pos >= text.length) {
+        p.err(0, 0, "empty document");
+        return { tree: { kind: "error", start: 0, end: 0 }, errors: p.errors };
+    }
+    const tree = p.parseValue();
+    p.skipWs();
+    if (p.pos < text.length)
+        p.err(p.pos, text.length, "unexpected trailing content");
+    return { tree, errors: p.errors };
+}
+function printScalar(v) {
+    if (v === null)
+        return "nil";
+    return JSON.stringify(v);
+}
+function printKey(k) {
+    return SAFE_KEY.test(k) ? `:${k}` : JSON.stringify(k);
+}
+const allScalar = (a) => a.every(v => v === null || typeof v !== "object");
+function printVal(v, depth) {
+    if (v === null || typeof v !== "object")
+        return printScalar(v);
+    const ind = indentOf(depth);
+    const inner = indentOf(depth + 1);
+    if (Array.isArray(v)) {
+        if (v.length === 0)
+            return "[]";
+        if (allScalar(v))
+            return `[${v.map(x => printScalar(x)).join(" ")}]`;
+        return `[\n${v.map(x => inner + printVal(x, depth + 1)).join("\n")}\n${ind}]`;
+    }
+    const keys = Object.keys(v);
+    if (keys.length === 0)
+        return "{}";
+    const body = keys.map(k => `${inner}${printKey(k)} ${printVal(v[k], depth + 1)}`).join("\n");
+    return `{\n${body}\n${ind}}`;
+}
+function print(value) {
+    return `${printVal(value, 0)}\n`;
+}
+function opToEdit(op, text) {
+    switch (op.type) {
+        case "replace":
+            return [{ start: op.node.start, end: op.node.end, text: printVal(op.value, op.depth) }];
+        case "insert": {
+            const { obj, key, value, depth } = op;
+            const inner = indentOf(depth + 1);
+            const printed = `${printKey(key)} ${printVal(value, depth + 1)}`;
+            if (obj.entries.length === 0) {
+                return [
+                    {
+                        start: obj.start + 1,
+                        end: obj.start + 1,
+                        text: `\n${inner}${printed}\n${indentOf(depth)}`,
+                    },
+                ];
+            }
+            const anchor = (op.after ?? obj.entries[obj.entries.length - 1]).end;
+            const between = text.slice(obj.start + 1, obj.entries[0].start);
+            const sep = between.includes("\n") ? `\n${inner}` : " ";
+            return [{ start: anchor, end: anchor, text: sep + printed }];
+        }
+        case "delete": {
+            // Forward-tiling spans; see the JSON adapter for the rationale.
+            const { obj, entry } = op;
+            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 sepStart = prev !== undefined ? prev.end : obj.start + 1;
+            return [
+                { start: sepStart, end: entry.start, text: "" },
+                { start: entry.start, end: entry.end, text: "" },
+            ];
+        }
+    }
+}
+export const ednFormat = { name: "EDN", parse, print, opToEdit };

package/dist/formats/index.d.ts

@@ -0,0 +1,6 @@
+export { type FormatAdapter, type JsonValue, lineColOf, type ParseError, valueOf, } from "./cst.js";
+export { ednFormat } from "./edn.js";
+export { jsonFormat } from "./json.js";
+export { formatSpoke, valueHub } from "./lens.js";
+export { tomlFormat } from "./toml.js";
+export { yamlFormat } from "./yaml.js";

package/dist/formats/index.js

@@ -0,0 +1,8 @@
+// formats — concrete-syntax lenses over a shared abstract value.
+// See cst.ts for the machinery, lens.ts for the reactive wiring.
+export { lineColOf, valueOf, } from "./cst.js";
+export { ednFormat } from "./edn.js";
+export { jsonFormat } from "./json.js";
+export { formatSpoke, valueHub } from "./lens.js";
+export { tomlFormat } from "./toml.js";
+export { yamlFormat } from "./yaml.js";

package/dist/formats/json.d.ts

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

package/dist/formats/json.js

@@ -0,0 +1,332 @@
+// json.ts — tolerant JSON adapter.
+//
+// Recovery strategy: garbage at a value/key position is consumed up to
+// the next delimiter at bracket depth zero (`,` `}` `]`) and becomes an
+// ErrorNode; a missing comma between entries is a zero-width error that
+// leaves both neighbouring entries valid. So a half-typed edit breaks
+// only its own region — the rest of the document stays addressable for
+// surgical writes.
+import { indentOf, } from "./cst.js";
+const WS = /[ \t\r\n]/;
+const NUM = /^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?/;
+const DELIM = new Set([",", "}", "]", undefined]);
+class P {
+    text;
+    pos = 0;
+    errors = [];
+    constructor(text) {
+        this.text = text;
+    }
+    err(start, end, message) {
+        this.errors.push({ start, end, message });
+    }
+    skipWs() {
+        while (this.pos < this.text.length && WS.test(this.text[this.pos]))
+            this.pos++;
+    }
+    peek() {
+        return this.text[this.pos];
+    }
+    /** Consume a garbage run: balanced brackets, strings capped at EOL,
+     *  stops at `,` `}` `]` at depth zero. Returns the error node. */
+    garbage(start, message) {
+        let depth = 0;
+        while (this.pos < this.text.length) {
+            const c = this.text[this.pos];
+            if (c === '"') {
+                this.pos++;
+                while (this.pos < this.text.length) {
+                    const s = this.text[this.pos];
+                    if (s === "\\")
+                        this.pos += 2;
+                    else if (s === '"' || s === "\n") {
+                        this.pos++;
+                        break;
+                    }
+                    else
+                        this.pos++;
+                }
+                continue;
+            }
+            if (c === "{" || c === "[")
+                depth++;
+            else if (c === "}" || c === "]") {
+                if (depth === 0)
+                    break;
+                depth--;
+            }
+            else if (c === "," && depth === 0)
+                break;
+            this.pos++;
+        }
+        let end = this.pos;
+        while (end > start && WS.test(this.text[end - 1]))
+            end--;
+        if (end === start)
+            end = Math.min(start + 1, this.text.length);
+        this.err(start, end, message);
+        return { kind: "error", start, end };
+    }
+    /** Raw string token; `ok: false` on an unterminated string. */
+    scanString() {
+        const start = this.pos;
+        this.pos++; // opening quote
+        let out = "";
+        while (this.pos < this.text.length) {
+            const c = this.text[this.pos];
+            if (c === '"') {
+                this.pos++;
+                return { value: out, end: this.pos, ok: true };
+            }
+            if (c === "\n")
+                break;
+            if (c === "\\") {
+                const esc = this.text[this.pos + 1];
+                this.pos += 2;
+                if (esc === "n")
+                    out += "\n";
+                else if (esc === "t")
+                    out += "\t";
+                else if (esc === "r")
+                    out += "\r";
+                else if (esc === "b")
+                    out += "\b";
+                else if (esc === "f")
+                    out += "\f";
+                else if (esc === "u") {
+                    const hex = this.text.slice(this.pos, this.pos + 4);
+                    if (/^[0-9a-fA-F]{4}$/.test(hex)) {
+                        out += String.fromCharCode(Number.parseInt(hex, 16));
+                        this.pos += 4;
+                    }
+                }
+                else
+                    out += esc ?? "";
+                continue;
+            }
+            out += c;
+            this.pos++;
+        }
+        this.err(start, this.pos, "unterminated string");
+        return { value: out, end: this.pos, ok: false };
+    }
+    parseValue() {
+        const start = this.pos;
+        const c = this.peek();
+        if (c === "{")
+            return this.parseObject();
+        if (c === "[")
+            return this.parseArray();
+        if (c === '"') {
+            const s = this.scanString();
+            if (!s.ok)
+                return { kind: "error", start, end: s.end };
+            return this.checkTail({ kind: "scalar", start, end: s.end, value: s.value }, start);
+        }
+        const rest = this.text.slice(this.pos);
+        const num = NUM.exec(rest);
+        if (num && num[0].length > 0 && (c === "-" || (c >= "0" && c <= "9"))) {
+            this.pos += num[0].length;
+            return this.checkTail({ kind: "scalar", start, end: this.pos, value: Number(num[0]) }, start);
+        }
+        for (const [word, value] of [
+            ["true", true],
+            ["false", false],
+            ["null", null],
+        ]) {
+            if (rest.startsWith(word)) {
+                this.pos += word.length;
+                return this.checkTail({ kind: "scalar", start, end: this.pos, value }, start);
+            }
+        }
+        return this.garbage(start, "expected a value");
+    }
+    /** A scalar must be followed by a delimiter; trailing junk turns the
+     *  whole run into an error node (typing `808x` must not push `808`). */
+    checkTail(node, start) {
+        const c = this.peek();
+        if (DELIM.has(c) || (c !== undefined && WS.test(c)) || c === ":")
+            return node;
+        return this.garbage(start, "malformed value");
+    }
+    parseObject() {
+        const start = this.pos;
+        this.pos++; // {
+        const entries = [];
+        for (;;) {
+            this.skipWs();
+            const c = this.peek();
+            if (c === undefined) {
+                this.err(start, start + 1, "unclosed object");
+                return { kind: "object", start, end: this.pos, entries };
+            }
+            if (c === "}") {
+                this.pos++;
+                return { kind: "object", start, end: this.pos, entries };
+            }
+            const entryStart = this.pos;
+            if (c !== '"') {
+                const node = this.garbage(entryStart, "expected a key");
+                entries.push({ key: undefined, start: entryStart, end: node.end, node });
+                if (this.peek() === ",")
+                    this.pos++;
+                continue;
+            }
+            const key = this.scanString();
+            if (!key.ok) {
+                const node = { kind: "error", start: entryStart, end: key.end };
+                entries.push({ key: undefined, start: entryStart, end: key.end, node });
+                if (this.peek() === ",")
+                    this.pos++;
+                continue;
+            }
+            this.skipWs();
+            if (this.peek() !== ":") {
+                const node = this.garbage(entryStart, "expected ':' after key");
+                entries.push({ key: undefined, start: entryStart, end: node.end, node });
+                if (this.peek() === ",")
+                    this.pos++;
+                continue;
+            }
+            this.pos++; // :
+            this.skipWs();
+            const node = this.parseValue();
+            entries.push({
+                key: node.kind === "error" ? undefined : key.value,
+                start: entryStart,
+                end: node.end,
+                node,
+            });
+            this.skipWs();
+            const d = this.peek();
+            if (d === ",") {
+                this.pos++;
+                continue;
+            }
+            if (d === "}")
+                continue; // loop closes
+            if (d === undefined)
+                continue; // loop reports unclosed
+            if (d === '"') {
+                // Missing comma — recover, both entries stay valid.
+                this.err(this.pos, this.pos + 1, "expected ',' between entries");
+                continue;
+            }
+            const junk = this.garbage(this.pos, "expected ',' or '}'");
+            entries.push({ key: undefined, start: junk.start, end: junk.end, node: junk });
+            if (this.peek() === ",")
+                this.pos++;
+        }
+    }
+    parseArray() {
+        const start = this.pos;
+        this.pos++; // [
+        const items = [];
+        for (;;) {
+            this.skipWs();
+            const c = this.peek();
+            if (c === undefined) {
+                this.err(start, start + 1, "unclosed array");
+                return { kind: "array", start, end: this.pos, items };
+            }
+            if (c === "]") {
+                this.pos++;
+                return { kind: "array", start, end: this.pos, items };
+            }
+            const node = this.parseValue();
+            items.push(node);
+            this.skipWs();
+            const d = this.peek();
+            if (d === ",") {
+                this.pos++;
+                continue;
+            }
+            if (d === "]" || d === undefined)
+                continue;
+            this.err(this.pos, this.pos + 1, "expected ',' or ']'");
+        }
+    }
+}
+function parse(text) {
+    const p = new P(text);
+    p.skipWs();
+    if (p.pos >= text.length) {
+        p.err(0, 0, "empty document");
+        return { tree: { kind: "error", start: 0, end: 0 }, errors: p.errors };
+    }
+    const tree = p.parseValue();
+    p.skipWs();
+    if (p.pos < text.length)
+        p.err(p.pos, text.length, "unexpected trailing content");
+    return { tree, errors: p.errors };
+}
+function printScalar(v) {
+    return JSON.stringify(v);
+}
+const allScalar = (a) => a.every(v => v === null || typeof v !== "object");
+function printVal(v, depth) {
+    if (v === null || typeof v !== "object")
+        return printScalar(v);
+    const ind = indentOf(depth);
+    const inner = indentOf(depth + 1);
+    if (Array.isArray(v)) {
+        if (v.length === 0)
+            return "[]";
+        if (allScalar(v))
+            return `[${v.map(x => printScalar(x)).join(", ")}]`;
+        return `[\n${v.map(x => inner + printVal(x, depth + 1)).join(",\n")}\n${ind}]`;
+    }
+    const keys = Object.keys(v);
+    if (keys.length === 0)
+        return "{}";
+    const body = keys
+        .map(k => `${inner}${JSON.stringify(k)}: ${printVal(v[k], depth + 1)}`)
+        .join(",\n");
+    return `{\n${body}\n${ind}}`;
+}
+function print(value) {
+    return `${printVal(value, 0)}\n`;
+}
+function opToEdit(op, text) {
+    switch (op.type) {
+        case "replace":
+            return [{ start: op.node.start, end: op.node.end, text: printVal(op.value, op.depth) }];
+        case "insert": {
+            const { obj, key, value, depth } = op;
+            const inner = indentOf(depth + 1);
+            const printed = `${JSON.stringify(key)}: ${printVal(value, depth + 1)}`;
+            if (obj.entries.length === 0) {
+                return [
+                    {
+                        start: obj.start + 1,
+                        end: obj.start + 1,
+                        text: `\n${inner}${printed}\n${indentOf(depth)}`,
+                    },
+                ];
+            }
+            const anchor = (op.after ?? obj.entries[obj.entries.length - 1]).end;
+            // Match the document's separator style: newline if entries are
+            // line-separated, inline otherwise.
+            const between = text.slice(obj.start + 1, obj.entries[0].start);
+            const sep = between.includes("\n") ? `,\n${inner}` : ", ";
+            return [{ start: anchor, end: anchor, text: sep + printed }];
+        }
+        case "delete": {
+            // Forward-tiling spans so consecutive deletes never overlap; a
+            // last-entry delete adds its leading separator as a second edit
+            // (harmlessly dropped when the previous entry is deleted too).
+            const { obj, entry } = op;
+            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 sepStart = prev !== undefined ? prev.end : obj.start + 1;
+            return [
+                { start: sepStart, end: entry.start, text: "" },
+                { start: entry.start, end: entry.end, text: "" },
+            ];
+        }
+    }
+}
+export const jsonFormat = { name: "JSON", parse, print, opToEdit };

package/dist/formats/lens.d.ts

@@ -0,0 +1,8 @@
+import { type Cell, type Writable } from "../core/cell.js";
+import { type FormatAdapter, type JsonValue } from "./cst.js";
+/** Writable hub for a shared abstract value (deep-equality pruned). */
+export declare function valueHub(initial: JsonValue): Writable<Cell<JsonValue>>;
+/** 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 declare function formatSpoke(hub: Writable<Cell<JsonValue>>, adapter: FormatAdapter): Writable<Cell<string>>;