@malloydata/motly-ts-parser 0.0.1

package/build/ast.d.ts

@@ -0,0 +1,62 @@
+/** A scalar or reference value. */
+export type ScalarValue = {
+    kind: "string";
+    value: string;
+} | {
+    kind: "number";
+    value: number;
+} | {
+    kind: "boolean";
+    value: boolean;
+} | {
+    kind: "date";
+    value: string;
+} | {
+    kind: "reference";
+    ups: number;
+    path: RefPathSegment[];
+};
+/** A segment in a reference path: either a named property or an array index. */
+export type RefPathSegment = {
+    kind: "name";
+    name: string;
+} | {
+    kind: "index";
+    index: number;
+};
+/** A value that can be assigned with `=`. */
+export type TagValue = {
+    kind: "scalar";
+    value: ScalarValue;
+} | {
+    kind: "array";
+    elements: ArrayElement[];
+};
+/** An element in an array literal. */
+export interface ArrayElement {
+    value: TagValue | null;
+    properties: Statement[] | null;
+}
+/** A parsed statement (the IR between the parser and interpreter). */
+export type Statement = {
+    kind: "setEq";
+    path: string[];
+    value: TagValue;
+    properties: Statement[] | null;
+    preserveProperties: boolean;
+} | {
+    kind: "replaceProperties";
+    path: string[];
+    properties: Statement[];
+    preserveValue: boolean;
+} | {
+    kind: "updateProperties";
+    path: string[];
+    properties: Statement[];
+} | {
+    kind: "define";
+    path: string[];
+    deleted: boolean;
+} | {
+    kind: "clearAll";
+};

package/build/ast.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/index.d.ts

@@ -0,0 +1,2 @@
+export type { MOTLYScalar, MOTLYRef, MOTLYValue, MOTLYNode, MOTLYError, MOTLYSchemaError, MOTLYValidationError, } from "motly-ts-interface";
+export { MOTLYSession } from "./session";

package/build/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MOTLYSession = void 0;
+var session_1 = require("./session");
+Object.defineProperty(exports, "MOTLYSession", { enumerable: true, get: function () { return session_1.MOTLYSession; } });

package/build/interpreter.d.ts

@@ -0,0 +1,4 @@
+import { Statement } from "./ast";
+import { MOTLYValue } from "motly-ts-interface";
+/** Execute a list of parsed statements against an existing MOTLYValue. */
+export declare function execute(statements: Statement[], root: MOTLYValue): MOTLYValue;

package/build/interpreter.js

@@ -0,0 +1,236 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.execute = execute;
+/** Execute a list of parsed statements against an existing MOTLYValue. */
+function execute(statements, root) {
+    for (const stmt of statements) {
+        executeStatement(stmt, root);
+    }
+    return root;
+}
+function executeStatement(stmt, node) {
+    switch (stmt.kind) {
+        case "setEq":
+            executeSetEq(node, stmt.path, stmt.value, stmt.properties, stmt.preserveProperties);
+            break;
+        case "replaceProperties":
+            executeReplaceProperties(node, stmt.path, stmt.properties, stmt.preserveValue);
+            break;
+        case "updateProperties":
+            executeUpdateProperties(node, stmt.path, stmt.properties);
+            break;
+        case "define":
+            executeDefine(node, stmt.path, stmt.deleted);
+            break;
+        case "clearAll":
+            node.properties = {};
+            break;
+    }
+}
+function executeSetEq(node, path, value, properties, preserveProperties) {
+    // Reference without properties → produce a link
+    if (value.kind === "scalar" &&
+        value.value.kind === "reference" &&
+        properties === null &&
+        !preserveProperties) {
+        const [writeKey, parent] = buildAccessPath(node, path);
+        const props = getOrCreateProperties(parent);
+        props[writeKey] = {
+            linkTo: formatRefString(value.value.ups, value.value.path),
+        };
+        return;
+    }
+    const [writeKey, parent] = buildAccessPath(node, path);
+    if (properties !== null) {
+        // name = value { new_properties } - set value and replace properties
+        const result = createValueNode(value);
+        for (const s of properties) {
+            executeStatement(s, result);
+        }
+        const props = getOrCreateProperties(parent);
+        props[writeKey] = result;
+    }
+    else if (preserveProperties) {
+        // name = value { ... } - update value, preserve existing properties
+        const props = getOrCreateProperties(parent);
+        const existing = props[writeKey];
+        if (existing !== undefined && !isRef(existing)) {
+            const result = createValueNode(value);
+            if (existing.properties) {
+                result.properties = existing.properties;
+            }
+            props[writeKey] = result;
+        }
+        else {
+            props[writeKey] = createValueNode(value);
+        }
+    }
+    else {
+        // name = value - simple assignment
+        const props = getOrCreateProperties(parent);
+        props[writeKey] = createValueNode(value);
+    }
+}
+function executeReplaceProperties(node, path, properties, preserveValue) {
+    const [writeKey, parent] = buildAccessPath(node, path);
+    const result = {};
+    if (preserveValue) {
+        const props = getOrCreateProperties(parent);
+        const existing = props[writeKey];
+        if (existing !== undefined && !isRef(existing)) {
+            result.eq = existing.eq;
+        }
+    }
+    for (const stmt of properties) {
+        executeStatement(stmt, result);
+    }
+    const props = getOrCreateProperties(parent);
+    props[writeKey] = result;
+}
+function executeUpdateProperties(node, path, properties) {
+    const [writeKey, parent] = buildAccessPath(node, path);
+    const props = getOrCreateProperties(parent);
+    let target = props[writeKey];
+    if (target === undefined) {
+        target = {};
+        props[writeKey] = target;
+    }
+    if (isRef(target)) {
+        const newNode = {};
+        for (const stmt of properties) {
+            executeStatement(stmt, newNode);
+        }
+        props[writeKey] = newNode;
+    }
+    else {
+        for (const stmt of properties) {
+            executeStatement(stmt, target);
+        }
+    }
+}
+function executeDefine(node, path, deleted) {
+    const [writeKey, parent] = buildAccessPath(node, path);
+    const props = getOrCreateProperties(parent);
+    if (deleted) {
+        props[writeKey] = { deleted: true };
+    }
+    else {
+        props[writeKey] = {};
+    }
+}
+/** Navigate to the parent of the final path segment, creating intermediate nodes. */
+function buildAccessPath(node, path) {
+    let current = node;
+    for (let i = 0; i < path.length - 1; i++) {
+        const segment = path[i];
+        const props = getOrCreateProperties(current);
+        let entry = props[segment];
+        if (entry === undefined) {
+            entry = {};
+            props[segment] = entry;
+        }
+        if (isRef(entry)) {
+            entry = {};
+            props[segment] = entry;
+        }
+        current = entry;
+    }
+    return [path[path.length - 1], current];
+}
+/** Convert an AST TagValue to a MOTLYValue. */
+function createValueNode(value) {
+    if (value.kind === "array") {
+        return { eq: resolveArray(value.elements) };
+    }
+    const sv = value.value;
+    switch (sv.kind) {
+        case "string":
+            return { eq: sv.value };
+        case "number":
+            return { eq: sv.value };
+        case "boolean":
+            return { eq: sv.value };
+        case "date":
+            return { eq: new Date(sv.value) };
+        case "reference":
+            // Should not be reached for simple ref assignments (handled above).
+            return {};
+    }
+}
+/** Resolve an array of AST elements to MOTLYNodes. */
+function resolveArray(elements) {
+    return elements.map(resolveArrayElement);
+}
+function resolveArrayElement(el) {
+    // Reference without properties becomes a link
+    if (el.value !== null &&
+        el.value.kind === "scalar" &&
+        el.value.value.kind === "reference" &&
+        el.properties === null) {
+        return {
+            linkTo: formatRefString(el.value.value.ups, el.value.value.path),
+        };
+    }
+    const node = {};
+    if (el.value !== null) {
+        if (el.value.kind === "array") {
+            node.eq = resolveArray(el.value.elements);
+        }
+        else {
+            const sv = el.value.value;
+            switch (sv.kind) {
+                case "string":
+                    node.eq = sv.value;
+                    break;
+                case "number":
+                    node.eq = sv.value;
+                    break;
+                case "boolean":
+                    node.eq = sv.value;
+                    break;
+                case "date":
+                    node.eq = new Date(sv.value);
+                    break;
+                case "reference":
+                    // Reference with properties: ignore the reference value
+                    break;
+            }
+        }
+    }
+    if (el.properties !== null) {
+        for (const stmt of el.properties) {
+            executeStatement(stmt, node);
+        }
+    }
+    return node;
+}
+/** Format a reference path back to its string form: `$^^name[0].sub` */
+function formatRefString(ups, path) {
+    let s = "$";
+    for (let i = 0; i < ups; i++)
+        s += "^";
+    let first = true;
+    for (const seg of path) {
+        if (seg.kind === "name") {
+            if (!first)
+                s += ".";
+            s += seg.name;
+            first = false;
+        }
+        else {
+            s += `[${seg.index}]`;
+        }
+    }
+    return s;
+}
+/** Check if a MOTLYNode is a MOTLYRef. */
+function isRef(node) {
+    return "linkTo" in node;
+}
+/** Get or create the properties object on a MOTLYValue. */
+function getOrCreateProperties(node) {
+    if (!node.properties) {
+        node.properties = {};
+    }
+    return node.properties;
+}

package/build/parser.d.ts

@@ -0,0 +1,3 @@
+import { Statement } from "./ast";
+/** Parse a MOTLY input string into a list of statements. */
+export declare function parse(input: string): Statement[];