@tinta-lang/engine 0.0.0-stage → 0.1.0-dev.0

package/dist/session.js

@@ -0,0 +1,304 @@
+import { attempt, Budget, fail, freeze, record } from "./common.js";
+import { programs } from "./programs.js";
+import { evaluate, format, } from "./expression.js";
+import { prepare } from "./charts.js";
+import { inDomain } from "./grid.js";
+function compare(a, b) {
+    if (typeof a === "string" && typeof b === "string") {
+        const x = [...a], y = [...b];
+        for (let i = 0; i < Math.min(x.length, y.length); i++) {
+            const delta = x[i].codePointAt(0) - y[i].codePointAt(0);
+            if (delta)
+                return delta;
+        }
+        return x.length - y.length;
+    }
+    return a < b ? -1 : a > b ? 1 : 0;
+}
+function revision(program, state, number) {
+    const bound = programs.get(program);
+    const span = program.flow[0]?.span ??
+        program.declarations[0]?.span ?? {
+        uri: program.sourceUri,
+        start: { offset: 0, line: 1, column: 1 },
+        end: { offset: 0, line: 1, column: 1 },
+    };
+    const budget = new Budget(span, "evaluate", { limits: bound.limits });
+    const values = record(), tables = record();
+    const get = (name) => Object.hasOwn(values, name) ? values[name] : tables[name];
+    const env = { get, budget, metadata: program.metadata };
+    for (const d of bound.order) {
+        if (d.kind === "let")
+            values[d.name] = bound.constants.get(d.name);
+        else if (d.kind === "calc")
+            values[d.name] = evaluate(d.expression, env);
+        else if (d.kind === "data")
+            tables[d.name] = d.table;
+        else if (d.kind === "view") {
+            const table = tables[d.source];
+            const rows = table.rows.filter((row) => {
+                budget.charge(d.span);
+                return (!d.where ||
+                    evaluate(d.where, {
+                        ...env,
+                        row: new Map(table.columns.map((c, i) => [c.name, row.cells[i]])),
+                    }));
+            });
+            if (d.sort) {
+                const index = table.columns.findIndex((c) => c.name === d.sort);
+                rows.sort((a, b) => {
+                    budget.charge(d.span);
+                    return (compare(a.cells[index], b.cells[index]) * (d.descending ? -1 : 1));
+                });
+            }
+            tables[d.name] = { columns: table.columns, rows };
+        }
+        else
+            values[d.name] = state[d.name];
+    }
+    let marks = 0;
+    const text = (id, value) => {
+        budget.limit("textValueUnits", value.length);
+        return { kind: "text", id, value };
+    };
+    const element = (id, tag, children, attributes = {}) => ({
+        kind: "element",
+        id,
+        tag,
+        attributes,
+        children,
+    });
+    function resolve(node) {
+        const children = () => "children" in node ? node.children.flatMap(resolve) : [];
+        switch (node.kind) {
+            case "text":
+            case "raw-html":
+                return [text(node.id, node.value)];
+            case "interpolation":
+                return [
+                    text(node.id, format(evaluate(node.expression, env), program.metadata)),
+                ];
+            case "when":
+                return evaluate(node.condition, env) ? children() : [];
+            case "details":
+                return [
+                    element(node.id, "details", [
+                        element(node.id, "summary", [text(node.id, node.summary)]),
+                        ...children(),
+                    ]),
+                ];
+            case "control":
+                return [
+                    {
+                        kind: "control",
+                        id: node.id,
+                        definition: bound.controls.get(node.name),
+                        value: state[node.name],
+                    },
+                ];
+            case "chart": {
+                const chart = prepare(node.chart, tables[node.chart.source], env, bound.controls);
+                marks += chart.points.length + chart.bins.length;
+                budget.limit("documentChartMarks", marks, node.span);
+                return [{ kind: "chart", id: node.id, chart }];
+            }
+            case "image":
+                return [
+                    {
+                        kind: "image",
+                        id: node.id,
+                        destination: node.destination,
+                        alt: node.alt,
+                        ...(node.title !== undefined ? { title: node.title } : {}),
+                    },
+                ];
+            case "paragraph":
+            case "emphasis":
+            case "strong":
+            case "delete":
+            case "blockquote":
+                return [
+                    element(node.id, {
+                        paragraph: "p",
+                        emphasis: "em",
+                        strong: "strong",
+                        delete: "del",
+                        blockquote: "blockquote",
+                    }[node.kind], children()),
+                ];
+            case "heading":
+                return [
+                    element(node.id, `h${node.level}`, children(), { id: node.anchor }),
+                ];
+            case "link": {
+                const safe = /^(?:https?:|mailto:|#)/i.test(node.destination) &&
+                    ![...node.destination].some((char) => char.codePointAt(0) <= 32);
+                return [
+                    element(node.id, safe ? "a" : "span", children(), safe
+                        ? {
+                            href: node.destination,
+                            ...(node.title === undefined ? {} : { title: node.title }),
+                        }
+                        : {}),
+                ];
+            }
+            case "code": {
+                const code = element(node.id, "code", [text(node.id, node.value)]);
+                return [node.block ? element(node.id, "pre", [code]) : code];
+            }
+            case "break":
+                return node.hard ? [element(node.id, "br", [])] : [text(node.id, "\n")];
+            case "thematic-break":
+                return [element(node.id, "hr", [])];
+            case "list":
+                return [
+                    element(node.id, node.ordered ? "ol" : "ul", node.items.map((item) => element(item.id, "li", [
+                        ...(item.checked === undefined
+                            ? []
+                            : [
+                                element(item.id, "input", [], {
+                                    type: "checkbox",
+                                    disabled: true,
+                                    checked: item.checked,
+                                }),
+                            ]),
+                        ...item.children.flatMap(resolve),
+                    ])), node.ordered ? { start: node.start } : {}),
+                ];
+            case "markdown-table":
+                return [
+                    element(node.id, "table", [
+                        element(node.id, "thead", [
+                            element(node.id, "tr", node.header.map((cell) => element(node.id, "th", cell.flatMap(resolve), {
+                                scope: "col",
+                            }))),
+                        ]),
+                        element(node.id, "tbody", node.rows.map((row) => element(node.id, "tr", row.map((cell) => element(node.id, "td", cell.flatMap(resolve)))))),
+                    ]),
+                ];
+            case "data-table": {
+                const table = tables[node.source];
+                return [
+                    element(node.id, "table", [
+                        element(node.id, "caption", [
+                            text(node.id, `${node.title} — ${table.rows.length} ${table.rows.length === 1 ? "row" : "rows"}`),
+                        ]),
+                        element(node.id, "thead", [
+                            element(node.id, "tr", table.columns.map((c) => element(node.id, "th", [text(node.id, c.name)], {
+                                scope: "col",
+                            }))),
+                        ]),
+                        element(node.id, "tbody", table.rows.map((row) => element(node.id, "tr", row.cells.map((cell) => element(node.id, "td", [
+                            text(node.id, format(cell, program.metadata)),
+                        ]))))),
+                    ]),
+                    ...(table.rows.length
+                        ? []
+                        : [text(node.id, "No rows match the current choices.")]),
+                ];
+            }
+        }
+    }
+    return freeze({
+        number,
+        state,
+        values,
+        tables,
+        nodes: program.flow.flatMap(resolve),
+        diagnostics: [],
+    });
+}
+export function createSession(program, options) {
+    const fallback = {
+        uri: program.sourceUri,
+        start: { offset: 0, line: 1, column: 1 },
+        end: { offset: 0, line: 1, column: 1 },
+    };
+    return attempt(() => {
+        const bound = programs.get(program);
+        if (!bound)
+            fail("E_PROTOCOL", fallback, "host");
+        const baseline = record();
+        for (const [name, control] of bound.controls)
+            baseline[name] = control.initial;
+        const validate = (update) => {
+            for (const [name, value] of Object.entries(update)) {
+                const control = bound.controls.get(name);
+                if (!control)
+                    fail("E_STATE_NAME", fallback, "evaluate");
+                if (!inDomain(control, value))
+                    fail("E_STATE_DOMAIN", control.span, "evaluate");
+            }
+        };
+        if (options?.baseline) {
+            validate(options.baseline);
+            if (Object.keys(options.baseline).length !== bound.controls.size)
+                fail("E_STATE_DOMAIN", fallback, "evaluate");
+            Object.assign(baseline, options.baseline);
+        }
+        for (const name of Object.keys(baseline))
+            if (Object.is(baseline[name], -0))
+                baseline[name] = 0;
+        freeze(baseline);
+        let current = revision(program, baseline, 0);
+        let destroyed = false, notifying = false;
+        const listeners = new Set();
+        const setControls = (update) => {
+            const diagnostics = [];
+            return attempt(() => {
+                if (destroyed || notifying)
+                    fail("E_PROTOCOL", fallback, "host");
+                validate(update);
+                const candidate = Object.assign(record(), current.state, update);
+                for (const name of Object.keys(candidate))
+                    if (Object.is(candidate[name], -0))
+                        candidate[name] = 0;
+                if (Object.keys(candidate).every((name) => candidate[name] === current.state[name]))
+                    return current;
+                const next = revision(program, candidate, current.number + 1);
+                current = next;
+                notifying = true;
+                try {
+                    for (const listener of [...listeners]) {
+                        if (destroyed)
+                            break;
+                        try {
+                            listener(current);
+                        }
+                        catch {
+                            diagnostics.push({
+                                code: "E_INTERNAL",
+                                severity: "error",
+                                phase: "host",
+                                message: "A subscriber failed after the revision committed.",
+                                span: fallback,
+                            });
+                        }
+                    }
+                }
+                finally {
+                    notifying = false;
+                }
+                return current;
+            }, diagnostics);
+        };
+        return {
+            program,
+            getRevision: () => current,
+            setControls,
+            setControl: (name, value) => setControls({ [name]: value }),
+            reset: () => setControls(baseline),
+            subscribe: (listener) => {
+                if (!destroyed)
+                    listeners.add(listener);
+                return () => {
+                    listeners.delete(listener);
+                };
+            },
+            destroy: () => {
+                destroyed = true;
+                listeners.clear();
+            },
+        };
+    });
+}

package/package.json

@@ -1,6 +1,77 @@
 {
   "name": "@tinta-lang/engine",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.0-dev.0",
+  "private": false,
+  "type": "module",
+  "license": "MIT",
+  "engines": {
+    "node": ">=24.21.0 <25"
+  },
+  "publishConfig": {
+    "access": "public",
+    "tag": "next"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./chart-presentation": {
+      "types": "./dist/chart-presentation.d.ts",
+      "import": "./dist/chart-presentation.js"
+    },
+    "./runtime": {
+      "types": "./dist/runtime.d.ts",
+      "import": "./dist/runtime.js"
+    }
+  },
+  "dependencies": {
+    "@tinta-lang/types": "0.1.0-dev.0",
+    "@tinta-lang/syntax": "0.1.0-dev.0",
+    "@noble/hashes": "2.4.0"
+  },
+  "files": [
+    "LICENSE",
+    "THIRD_PARTY_NOTICES.txt",
+    "dist/analysis.d.ts",
+    "dist/analysis.js",
+    "dist/binding.d.ts",
+    "dist/binding.js",
+    "dist/chart-presentation.d.ts",
+    "dist/chart-presentation.js",
+    "dist/charts.d.ts",
+    "dist/charts.js",
+    "dist/codec.d.ts",
+    "dist/codec.js",
+    "dist/common.d.ts",
+    "dist/common.js",
+    "dist/compiler.d.ts",
+    "dist/compiler.js",
+    "dist/expression.d.ts",
+    "dist/expression.js",
+    "dist/grid.d.ts",
+    "dist/grid.js",
+    "dist/imports.d.ts",
+    "dist/imports.js",
+    "dist/index.d.ts",
+    "dist/index.js",
+    "dist/inspect.d.ts",
+    "dist/inspect.js",
+    "dist/program-validator.d.ts",
+    "dist/program-validator.js",
+    "dist/programs.d.ts",
+    "dist/programs.js",
+    "dist/registry.d.ts",
+    "dist/registry.js",
+    "dist/runtime.d.ts",
+    "dist/runtime.js",
+    "dist/session.d.ts",
+    "dist/session.js"
+  ],
+  "types": "./dist/index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/planta7/tinta.git",
+    "directory": "packages/engine"
+  }
 }

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.