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

package/dist/expression.js

@@ -0,0 +1,236 @@
+import { Budget, fail, scalarType } from "./common.js";
+export function tableType(type, expr) {
+    if (typeof type === "string")
+        fail("E_TYPE", expr.span);
+    return type;
+}
+export function infer(expr, get, budget, columns) {
+    budget.charge(expr.span);
+    const visit = (child) => infer(child, get, budget, columns);
+    const requireType = (child, expected) => {
+        if (visit(child) !== expected)
+            fail("E_TYPE", child.span);
+    };
+    switch (expr.kind) {
+        case "literal":
+            return scalarType(expr.value);
+        case "name":
+            return get(expr.name, expr);
+        case "row-field": {
+            if (!columns)
+                fail("E_ROW_SCOPE", expr.span);
+            const column = columns.find((c) => c.name === expr.field);
+            if (!column)
+                fail("E_COLUMN_UNKNOWN", expr.span);
+            return column.type;
+        }
+        case "list": {
+            let item = "never";
+            for (const child of expr.items) {
+                const type = visit(child);
+                if (type !== "text" && type !== "number" && type !== "boolean")
+                    fail("E_TYPE", child.span);
+                if (item !== "never" && item !== type)
+                    fail("E_TYPE", child.span);
+                item = type;
+            }
+            return `list:${item}`;
+        }
+        case "unary": {
+            const type = expr.operator === "not" ? "boolean" : "number";
+            requireType(expr.operand, type);
+            return type;
+        }
+        case "binary": {
+            const a = visit(expr.left), b = visit(expr.right);
+            if (expr.operator === "==" || expr.operator === "!=") {
+                if (a !== b || (a !== "number" && a !== "text" && a !== "boolean"))
+                    fail("E_TYPE", expr.span);
+                return "boolean";
+            }
+            const logical = expr.operator === "and" || expr.operator === "or";
+            if (a !== (logical ? "boolean" : "number") || a !== b)
+                fail("E_TYPE", expr.span);
+            return logical || ["<", "<=", ">", ">="].includes(expr.operator)
+                ? "boolean"
+                : "number";
+        }
+        case "call": {
+            const args = expr.arguments;
+            const arity = expr.name === "if"
+                ? 3
+                : ["count", "percent", "money"].includes(expr.name)
+                    ? 1
+                    : 2;
+            if (args.length !== arity &&
+                !(expr.name === "round" && args.length === 1))
+                fail("E_FUNCTION_ARITY", expr.span);
+            if (expr.name === "if") {
+                requireType(args[0], "boolean");
+                const a = visit(args[1]), b = visit(args[2]);
+                if (typeof a !== "string" || typeof b !== "string")
+                    fail("E_TYPE", expr.span);
+                if (a === b)
+                    return a;
+                if (a === "list:never" && b.startsWith("list:"))
+                    return b;
+                if (b === "list:never" && a.startsWith("list:"))
+                    return a;
+                fail("E_TYPE", expr.span);
+            }
+            if (expr.name === "count") {
+                const type = visit(args[0]);
+                if (typeof type === "string" && !type.startsWith("list:"))
+                    fail("E_TYPE", expr.span);
+                return "number";
+            }
+            if (expr.name === "sum" || expr.name === "mean") {
+                const schema = tableType(visit(args[0]), args[0]);
+                const column = args[1];
+                if (column.kind !== "literal" || typeof column.value !== "string")
+                    fail("E_TYPE", column.span);
+                const found = schema.find((c) => c.name === column.value);
+                if (!found)
+                    fail("E_COLUMN_UNKNOWN", column.span);
+                if (found.type !== "number")
+                    fail("E_TYPE", column.span);
+                return "number";
+            }
+            args.forEach((arg) => requireType(arg, "number"));
+            return ["fixed", "percent", "money"].includes(expr.name)
+                ? "text"
+                : "number";
+        }
+    }
+}
+export function numeric(value, expr) {
+    if (!Number.isFinite(value))
+        fail("E_NUMBER_RANGE", expr.span, "evaluate");
+    return value === 0 ? 0 : value;
+}
+export function format(value, metadata) {
+    if (typeof value !== "number")
+        return String(value);
+    if (Math.abs(value) >= 1e21 || (value !== 0 && Math.abs(value) < 1e-10))
+        return String(value);
+    return new Intl.NumberFormat(metadata.locale, {
+        useGrouping: false,
+        maximumFractionDigits: 10,
+    }).format(value);
+}
+export function evaluate(expr, env) {
+    env.budget.charge(expr.span);
+    const visit = (child) => evaluate(child, env);
+    const number = (child) => visit(child);
+    switch (expr.kind) {
+        case "literal":
+            return expr.value;
+        case "name":
+            return env.get(expr.name);
+        case "row-field":
+            return env.row.get(expr.field);
+        case "list":
+            return expr.items.map((item) => visit(item));
+        case "unary":
+            return expr.operator === "not"
+                ? !visit(expr.operand)
+                : numeric((expr.operator === "-" ? -1 : 1) * number(expr.operand), expr);
+        case "binary": {
+            const a = visit(expr.left);
+            if (expr.operator === "and")
+                return a ? visit(expr.right) : false;
+            if (expr.operator === "or")
+                return a ? true : visit(expr.right);
+            const b = visit(expr.right);
+            if (expr.operator === "==")
+                return a === b;
+            if (expr.operator === "!=")
+                return a !== b;
+            const x = a, y = b;
+            switch (expr.operator) {
+                case "+":
+                    return numeric(x + y, expr);
+                case "-":
+                    return numeric(x - y, expr);
+                case "*":
+                    return numeric(x * y, expr);
+                case "/":
+                case "%":
+                    if (y === 0)
+                        fail("E_DIV_ZERO", expr.span, "evaluate");
+                    return numeric(expr.operator === "/" ? x / y : x % y, expr);
+                case "<":
+                    return x < y;
+                case "<=":
+                    return x <= y;
+                case ">":
+                    return x > y;
+                case ">=":
+                    return x >= y;
+            }
+            throw new Error("Unreachable validated binary operator.");
+        }
+        case "call": {
+            const args = expr.arguments;
+            if (expr.name === "if")
+                return visit(args[0]) ? visit(args[1]) : visit(args[2]);
+            if (expr.name === "count") {
+                const value = visit(args[0]);
+                return "rows" in value ? value.rows.length : value.length;
+            }
+            if (expr.name === "sum" || expr.name === "mean") {
+                const table = visit(args[0]);
+                const index = table.columns.findIndex((c) => c.name === visit(args[1]));
+                if (expr.name === "mean" && !table.rows.length)
+                    fail("E_EMPTY_MEAN", expr.span, "evaluate");
+                let total = 0;
+                for (const row of table.rows) {
+                    env.budget.charge(expr.span);
+                    total = numeric(total + row.cells[index], expr);
+                }
+                return expr.name === "sum"
+                    ? total
+                    : numeric(total / table.rows.length, expr);
+            }
+            const a = number(args[0]);
+            const b = args[1] ? number(args[1]) : 0;
+            if ((expr.name === "round" || expr.name === "fixed") &&
+                (!Number.isInteger(b) || b < 0 || b > 10))
+                fail("E_DIGITS_RANGE", expr.span, "evaluate");
+            switch (expr.name) {
+                case "min":
+                    return Math.min(a, b);
+                case "max":
+                    return Math.max(a, b);
+                case "pow":
+                    return numeric(Math.pow(a, b), expr);
+                case "round":
+                    return numeric(Math.round(numeric(a * 10 ** b, expr)) / 10 ** b, expr);
+                case "fixed":
+                    return new Intl.NumberFormat(env.metadata.locale, {
+                        useGrouping: false,
+                        minimumFractionDigits: b,
+                        maximumFractionDigits: b,
+                    }).format(a);
+                case "percent":
+                    return new Intl.NumberFormat(env.metadata.locale, {
+                        style: "percent",
+                        useGrouping: false,
+                        minimumFractionDigits: 0,
+                        maximumFractionDigits: 1,
+                    }).format(a);
+                case "money": {
+                    const digits = env.metadata.currency === "JPY" ? 0 : 2;
+                    return new Intl.NumberFormat(env.metadata.locale, {
+                        style: "currency",
+                        currency: env.metadata.currency,
+                        currencyDisplay: "symbol",
+                        useGrouping: true,
+                        minimumFractionDigits: digits,
+                        maximumFractionDigits: digits,
+                    }).format(a);
+                }
+            }
+        }
+    }
+}

package/dist/grid.d.ts

@@ -0,0 +1,5 @@
+import type { ControlDefinition, SliderDefinition, Span } from "@tinta-lang/types";
+/** Decimal tokens become exact millionths before any binary64 grid arithmetic. */
+export declare function units(raw: string): bigint | undefined;
+export declare function grid(min: string, max: string, step: string, span: Span): SliderDefinition["grid"];
+export declare function inDomain(control: ControlDefinition, value: unknown): boolean;

package/dist/grid.js

@@ -0,0 +1,57 @@
+import { fail } from "./common.js";
+/** Decimal tokens become exact millionths before any binary64 grid arithmetic. */
+export function units(raw) {
+    const match = /^([+-]?)(\d+)(?:\.(\d+))?(?:[eE]([+-]?\d+))?$/.exec(raw);
+    if (!match)
+        return undefined;
+    const fraction = match[3] ?? "";
+    if (/^0+$/.test(match[2] + fraction))
+        return 0n;
+    const exponent = Number(match[4] ?? 0) + 6 - fraction.length;
+    if (Math.abs(exponent) > 400)
+        return undefined;
+    let value = BigInt(match[2] + fraction);
+    if (exponent >= 0)
+        value *= 10n ** BigInt(exponent);
+    else {
+        const divisor = 10n ** BigInt(-exponent);
+        if (value % divisor !== 0n)
+            return undefined;
+        value /= divisor;
+    }
+    return match[1] === "-" ? -value : value;
+}
+export function grid(min, max, step, span) {
+    const a = units(min), b = units(max), s = units(step);
+    if (a === undefined ||
+        b === undefined ||
+        s === undefined ||
+        a >= b ||
+        s < 1n ||
+        a < -1000000000000000n ||
+        b > 1000000000000000n ||
+        (b - a) % s !== 0n ||
+        (b - a) / s > 100000n)
+        fail("E_STATE_DOMAIN", span);
+    return {
+        scale: 1000000,
+        minUnits: String(a),
+        stepUnits: String(s),
+        ticks: Number((b - a) / s),
+    };
+}
+export function inDomain(control, value) {
+    if (control.kind === "toggle")
+        return typeof value === "boolean";
+    if (control.kind === "choice")
+        return typeof value === "string" && control.options.includes(value);
+    if (typeof value !== "number" || !Number.isFinite(value))
+        return false;
+    const n = units(String(value));
+    if (n === undefined)
+        return false;
+    const offset = n - BigInt(control.grid.minUnits), step = BigInt(control.grid.stepUnits);
+    return (offset >= 0n &&
+        offset <= step * BigInt(control.grid.ticks) &&
+        offset % step === 0n);
+}

package/dist/imports.d.ts

@@ -0,0 +1,4 @@
+import type { DataImport, DataImportOptions, Result } from "@tinta-lang/types";
+export declare function importCsv(bytes: Uint8Array, options: DataImportOptions): Result<DataImport>;
+/** A bounded JSON reader detects repeated keys before they can be erased. */
+export declare function importJson(bytes: Uint8Array, options: DataImportOptions): Result<DataImport>;

package/dist/imports.js

@@ -0,0 +1,293 @@
+import { decodeUtf8, encodeUtf8, parse } from "@tinta-lang/syntax";
+import { attempt, Budget, Failure, fail, scalarType } from "./common.js";
+import { registry } from "./registry.js";
+const span = {
+    uri: "tinta:import",
+    start: { offset: 0, line: 1, column: 1 },
+    end: { offset: 0, line: 1, column: 1 },
+};
+const numberToken = /^[+-]?(?:0|[1-9][0-9]*)(?:\.[0-9]+)?(?:[eE][+-]?[0-9]+)?$/;
+const validName = (name) => /^[A-Za-z_][A-Za-z0-9_]{0,63}$/.test(name) &&
+    !registry.reservedIdentifiers.includes(name);
+function decode(bytes, budget) {
+    budget.limit("importBytes", bytes.length);
+    try {
+        return decodeUtf8(bytes).replace(/^\uFEFF/, "");
+    }
+    catch {
+        fail("E_ENCODING", span, "decode");
+    }
+}
+function mapping(headers) {
+    const used = new Set();
+    return headers.map((header) => {
+        let name = header
+            .normalize("NFKD")
+            .replace(/\p{M}/gu, "")
+            .replace(/[^A-Za-z0-9_]+/g, "_")
+            .replace(/^_+|_+$/g, "") || "column";
+        if (/^[0-9]/.test(name) ||
+            registry.reservedIdentifiers.includes(name))
+            name = "column_" + name;
+        name = name.slice(0, 56);
+        let candidate = name, index = 2;
+        while (used.has(candidate))
+            candidate = `${name}_${index++}`;
+        used.add(candidate);
+        return candidate;
+    });
+}
+function candidate(headers, rows, options, budget, json) {
+    if (!validName(options.name) ||
+        !headers.length ||
+        headers.some((h) => !h.length) ||
+        new Set(headers).size !== headers.length)
+        fail("E_IMPORT_SCHEMA", span);
+    budget.limit("tableColumns", headers.length);
+    budget.limit("tableRows", rows.length);
+    budget.limit("totalCells", rows.length * headers.length);
+    const names = mapping(headers);
+    const inferred = headers.map((input, i) => {
+        const cells = rows.map((row) => row[i]);
+        let type = "text";
+        if (json) {
+            type = scalarType(cells[0]);
+            if (cells.some((c) => scalarType(c) !== type))
+                fail("E_IMPORT_SCHEMA", span);
+        }
+        else if (cells.length &&
+            cells.every((c) => c === "true" || c === "false"))
+            type = "boolean";
+        else if (cells.length &&
+            cells.every((c) => typeof c === "string" &&
+                numberToken.test(c) &&
+                c.length <= 128 &&
+                Number.isFinite(Number(c))))
+            type = "number";
+        return { input, name: names[i], type };
+    });
+    const columns = options.columns ? [...options.columns] : inferred;
+    if (columns.length !== headers.length ||
+        new Set(columns.map((c) => c.name)).size !== columns.length ||
+        columns.some((c, i) => c.input !== headers[i] ||
+            !validName(c.name) ||
+            !["text", "number", "boolean"].includes(c.type)))
+        fail("E_IMPORT_SCHEMA", span);
+    const lines = [
+        `@data ${options.name}`,
+        columns.map((c) => `${c.name}:${c.type}`).join(" | "),
+    ];
+    for (const row of rows) {
+        budget.charge();
+        if (row.length !== headers.length)
+            fail("E_IMPORT_SCHEMA", span);
+        lines.push(columns
+            .map((column, i) => {
+            const value = row[i];
+            if (json &&
+                column.type !== "text" &&
+                scalarType(value) !== column.type)
+                fail("E_IMPORT_SCHEMA", span);
+            if (column.type === "text") {
+                const text = String(value);
+                budget.limit("textValueUnits", text.length);
+                return JSON.stringify(text);
+            }
+            if (column.type === "boolean") {
+                if (value !== true &&
+                    value !== false &&
+                    value !== "true" &&
+                    value !== "false")
+                    fail("E_IMPORT_SCHEMA", span);
+                return String(value);
+            }
+            const token = String(value);
+            if (!numberToken.test(token) ||
+                token.length > 128 ||
+                !Number.isFinite(Number(token)))
+                fail("E_IMPORT_SCHEMA", span);
+            return String(Number(token));
+        })
+            .join(" | "));
+    }
+    lines.push("@end", "");
+    const source = lines.join("\n");
+    // A candidate must already fit the source parser's limits and string grammar.
+    const parsed = parse({ uri: span.uri, profile: "tinta", text: source });
+    if (!parsed.ok)
+        fail("E_IMPORT_SCHEMA", span);
+    return { source, columns, rowCount: rows.length };
+}
+export function importCsv(bytes, options) {
+    return attempt(() => {
+        const budget = new Budget(span, "decode");
+        const source = decode(bytes, budget), records = [];
+        let row = [], field = "", quoted = false, closed = false, start = true;
+        const cell = () => {
+            budget.limit("textValueUnits", field.length);
+            row.push(field);
+            budget.limit("tableColumns", row.length);
+            field = "";
+            closed = false;
+            start = true;
+        };
+        const record = () => {
+            const blank = row.length === 0 && field === "" && !closed;
+            cell();
+            if (blank)
+                fail("E_IMPORT_SCHEMA", span);
+            records.push(row);
+            budget.limit("tableRows", records.length - 1);
+            budget.limit("totalCells", Math.max(0, records.length - 1) * row.length);
+            row = [];
+        };
+        for (let i = 0; i < source.length; i++) {
+            budget.charge();
+            const char = source[i];
+            if (quoted) {
+                if (char === '"') {
+                    if (source[i + 1] === '"') {
+                        field += '"';
+                        i++;
+                    }
+                    else {
+                        quoted = false;
+                        closed = true;
+                    }
+                }
+                else
+                    field += char;
+            }
+            else if (char === ",")
+                cell();
+            else if (char === "\n" || char === "\r") {
+                record();
+                if (char === "\r" && source[i + 1] === "\n")
+                    i++;
+            }
+            else if (char === '"' && start) {
+                quoted = true;
+                start = false;
+            }
+            else {
+                if (closed || char === '"')
+                    fail("E_IMPORT_SCHEMA", span);
+                field += char;
+                start = false;
+            }
+            budget.limit("textValueUnits", field.length);
+        }
+        if (quoted)
+            fail("E_IMPORT_SCHEMA", span);
+        if (field.length || row.length || closed)
+            record();
+        const headers = records.shift();
+        if (!headers || records.some((r) => r.length !== headers.length))
+            fail("E_IMPORT_SCHEMA", span);
+        return candidate(headers, records, options, budget, false);
+    });
+}
+/** A bounded JSON reader detects repeated keys before they can be erased. */
+export function importJson(bytes, options) {
+    return attempt(() => {
+        const budget = new Budget(span, "decode");
+        const source = decode(bytes, budget);
+        let offset = 0;
+        const space = () => {
+            while (/[ \t\r\n]/.test(source[offset] ?? "x"))
+                offset++;
+        };
+        const token = (expected) => {
+            space();
+            if (source[offset++] !== expected)
+                fail("E_IMPORT_SCHEMA", span);
+        };
+        const string = () => {
+            space();
+            const begin = offset;
+            token('"');
+            let escaped = false;
+            while (offset < source.length) {
+                budget.charge();
+                const char = source[offset++];
+                if (char === '"' && !escaped) {
+                    try {
+                        const value = JSON.parse(source.slice(begin, offset));
+                        if (typeof value !== "string")
+                            fail("E_IMPORT_SCHEMA", span);
+                        encodeUtf8(value);
+                        budget.limit("textValueUnits", value.length);
+                        return value;
+                    }
+                    catch (error) {
+                        if (error instanceof Failure)
+                            throw error;
+                        fail("E_IMPORT_SCHEMA", span);
+                    }
+                }
+                escaped = char === "\\" && !escaped;
+            }
+            fail("E_IMPORT_SCHEMA", span);
+        };
+        const scalar = () => {
+            space();
+            if (source[offset] === '"')
+                return string();
+            const begin = offset;
+            while (offset < source.length && !/[,}\s]/.test(source[offset]))
+                offset++;
+            const raw = source.slice(begin, offset);
+            if (raw === "true" || raw === "false")
+                return raw === "true";
+            if (!/^-?(?:0|[1-9][0-9]*)(?:\.[0-9]+)?(?:[eE][+-]?[0-9]+)?$/.test(raw) ||
+                raw.length > 128 ||
+                !Number.isFinite(Number(raw)))
+                fail("E_IMPORT_SCHEMA", span);
+            return Number(raw) || 0;
+        };
+        const rows = [];
+        let headers;
+        token("[");
+        space();
+        if (source[offset] === "]")
+            fail("E_IMPORT_SCHEMA", span);
+        while (true) {
+            token("{");
+            space();
+            const fields = new Map();
+            if (source[offset] === "}")
+                fail("E_IMPORT_SCHEMA", span);
+            while (true) {
+                const key = string();
+                if (fields.has(key))
+                    fail("E_IMPORT_SCHEMA", span);
+                token(":");
+                fields.set(key, scalar());
+                budget.limit("tableColumns", fields.size);
+                space();
+                if (source[offset] === "}") {
+                    offset++;
+                    break;
+                }
+                token(",");
+            }
+            headers ??= [...fields.keys()];
+            if (fields.size !== headers.length ||
+                headers.some((key) => !fields.has(key)))
+                fail("E_IMPORT_SCHEMA", span);
+            rows.push(headers.map((key) => fields.get(key)));
+            budget.limit("tableRows", rows.length);
+            budget.limit("totalCells", rows.length * headers.length);
+            space();
+            if (source[offset] === "]") {
+                offset++;
+                break;
+            }
+            token(",");
+        }
+        space();
+        if (offset !== source.length)
+            fail("E_IMPORT_SCHEMA", span);
+        return candidate(headers, rows, options, budget, true);
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { compile } from "./compiler.js";
+export { createSession } from "./session.js";
+export { encodeProgram, decodeProgram } from "./codec.js";
+export { importCsv, importJson } from "./imports.js";
+export { chartPresentation, legendKey, numericDomain, } from "./chart-presentation.js";
+export { analyzeProgram } from "./analysis.js";
+export type { AnalyzedBinding } from "./analysis.js";

package/dist/index.js

@@ -0,0 +1,6 @@
+export { compile } from "./compiler.js";
+export { createSession } from "./session.js";
+export { encodeProgram, decodeProgram } from "./codec.js";
+export { importCsv, importJson } from "./imports.js";
+export { chartPresentation, legendKey, numericDomain, } from "./chart-presentation.js";
+export { analyzeProgram } from "./analysis.js";

package/dist/inspect.d.ts

@@ -0,0 +1,3 @@
+import { Budget } from "./common.js";
+/** Reject cycles, accessors and excessive structure before recursive schema traversal. */
+export declare function inspect(value: unknown, budget: Budget): void;

package/dist/inspect.js

@@ -0,0 +1,42 @@
+import { Budget, fail } from "./common.js";
+/** Reject cycles, accessors and excessive structure before recursive schema traversal. */
+export function inspect(value, budget) {
+    const stack = [{ value, depth: 0 }], seen = new Set();
+    let nodes = 0, units = 0;
+    while (stack.length) {
+        const item = stack.pop();
+        if (item.leave) {
+            seen.delete(item.value);
+            continue;
+        }
+        budget.charge();
+        if (++nodes > 2000000 || item.depth > 256)
+            fail("E_LIMIT", budget.span, "decode");
+        if (typeof item.value === "string") {
+            units += item.value.length;
+            if (units > 41943040)
+                fail("E_LIMIT", budget.span, "decode");
+        }
+        if (!item.value || typeof item.value !== "object")
+            continue;
+        if (seen.has(item.value))
+            fail("E_PROTOCOL", budget.span, "decode");
+        seen.add(item.value);
+        stack.push({ ...item, leave: true });
+        const proto = Object.getPrototypeOf(item.value);
+        if (proto !== Object.prototype &&
+            proto !== Array.prototype &&
+            proto !== null)
+            fail("E_PROTOCOL", budget.span, "decode");
+        for (const key of Reflect.ownKeys(item.value)) {
+            if (typeof key !== "string")
+                fail("E_PROTOCOL", budget.span, "decode");
+            if (Array.isArray(item.value) && key === "length")
+                continue;
+            const descriptor = Object.getOwnPropertyDescriptor(item.value, key);
+            if (!Object.hasOwn(descriptor, "value") || !descriptor.enumerable)
+                fail("E_PROTOCOL", budget.span, "decode");
+            stack.push({ value: descriptor.value, depth: item.depth + 1 });
+        }
+    }
+}

package/dist/program-validator.d.ts

@@ -0,0 +1,19 @@
+export function validate(data: any, { instancePath, parentData, parentDataProperty, rootData, dynamicAnchors, }?: {
+    instancePath?: string | undefined;
+    rootData?: any;
+    dynamicAnchors?: {} | undefined;
+}): boolean;
+export namespace validate {
+    namespace evaluated {
+        let props: boolean;
+        let dynamicProps: boolean;
+        let dynamicItems: boolean;
+    }
+}
+export default validate20;
+declare function validate20(data: any, { instancePath, parentData, parentDataProperty, rootData, dynamicAnchors, }?: {
+    instancePath?: string | undefined;
+    rootData?: any;
+    dynamicAnchors?: {} | undefined;
+}): boolean;
+declare namespace validate20 { }