@malloydata/motly-ts-parser 0.0.1

package/build/session.d.ts

@@ -0,0 +1,45 @@
+import { MOTLYValue, MOTLYError, MOTLYSchemaError, MOTLYValidationError } from "motly-ts-interface";
+/**
+ * A stateful MOTLY parsing session.
+ *
+ * Pure TypeScript implementation — no WASM, no native dependencies.
+ * API-compatible with the Rust `MotlySession`.
+ */
+export declare class MOTLYSession {
+    private value;
+    private schema;
+    private disposed;
+    /**
+     * Parse MOTLY source and apply it to the session's value in place.
+     * Returns only parse errors.
+     */
+    parse(source: string): MOTLYError[];
+    /**
+     * Parse MOTLY source as a schema and store it in the session.
+     * The schema is parsed fresh (not merged).
+     */
+    parseSchema(source: string): MOTLYError[];
+    /**
+     * Reset the session's value to empty, keeping the schema.
+     */
+    reset(): void;
+    /**
+     * Return a deep clone of the session's current value.
+     */
+    getValue(): MOTLYValue;
+    /**
+     * Validate the session's value against its stored schema.
+     * Returns an empty array if no schema has been set.
+     */
+    validateSchema(): MOTLYSchemaError[];
+    /**
+     * Validate that all `$`-references in the session's value resolve.
+     */
+    validateReferences(): MOTLYValidationError[];
+    /**
+     * No-op for pure TS (no native resources to free).
+     * After calling `dispose()`, all other methods will throw.
+     */
+    dispose(): void;
+    private ensureAlive;
+}

package/build/session.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MOTLYSession = void 0;
+const parser_1 = require("./parser");
+const interpreter_1 = require("./interpreter");
+const validate_1 = require("./validate");
+/**
+ * A stateful MOTLY parsing session.
+ *
+ * Pure TypeScript implementation — no WASM, no native dependencies.
+ * API-compatible with the Rust `MotlySession`.
+ */
+class MOTLYSession {
+    constructor() {
+        this.value = {};
+        this.schema = null;
+        this.disposed = false;
+    }
+    /**
+     * Parse MOTLY source and apply it to the session's value in place.
+     * Returns only parse errors.
+     */
+    parse(source) {
+        this.ensureAlive();
+        try {
+            const stmts = (0, parser_1.parse)(source);
+            this.value = (0, interpreter_1.execute)(stmts, this.value);
+            return [];
+        }
+        catch (e) {
+            if (isMotlyError(e))
+                return [e];
+            throw e;
+        }
+    }
+    /**
+     * Parse MOTLY source as a schema and store it in the session.
+     * The schema is parsed fresh (not merged).
+     */
+    parseSchema(source) {
+        this.ensureAlive();
+        try {
+            const stmts = (0, parser_1.parse)(source);
+            this.schema = (0, interpreter_1.execute)(stmts, {});
+            return [];
+        }
+        catch (e) {
+            if (isMotlyError(e))
+                return [e];
+            throw e;
+        }
+    }
+    /**
+     * Reset the session's value to empty, keeping the schema.
+     */
+    reset() {
+        this.ensureAlive();
+        this.value = {};
+    }
+    /**
+     * Return a deep clone of the session's current value.
+     */
+    getValue() {
+        this.ensureAlive();
+        return deepClone(this.value);
+    }
+    /**
+     * Validate the session's value against its stored schema.
+     * Returns an empty array if no schema has been set.
+     */
+    validateSchema() {
+        this.ensureAlive();
+        if (this.schema === null)
+            return [];
+        return (0, validate_1.validateSchema)(this.value, this.schema);
+    }
+    /**
+     * Validate that all `$`-references in the session's value resolve.
+     */
+    validateReferences() {
+        this.ensureAlive();
+        return (0, validate_1.validateReferences)(this.value);
+    }
+    /**
+     * No-op for pure TS (no native resources to free).
+     * After calling `dispose()`, all other methods will throw.
+     */
+    dispose() {
+        this.disposed = true;
+    }
+    ensureAlive() {
+        if (this.disposed) {
+            throw new Error("MOTLYSession has been disposed");
+        }
+    }
+}
+exports.MOTLYSession = MOTLYSession;
+function isMotlyError(e) {
+    return (typeof e === "object" &&
+        e !== null &&
+        "code" in e &&
+        "message" in e &&
+        "begin" in e &&
+        "end" in e);
+}
+function deepClone(value) {
+    const result = {};
+    if (value.deleted)
+        result.deleted = true;
+    if (value.eq !== undefined) {
+        if (value.eq instanceof Date) {
+            result.eq = new Date(value.eq.getTime());
+        }
+        else if (Array.isArray(value.eq)) {
+            result.eq = value.eq.map(cloneNode);
+        }
+        else {
+            result.eq = value.eq;
+        }
+    }
+    if (value.properties) {
+        const props = {};
+        for (const key of Object.keys(value.properties)) {
+            props[key] = cloneNode(value.properties[key]);
+        }
+        result.properties = props;
+    }
+    return result;
+}
+function cloneNode(node) {
+    if ("linkTo" in node) {
+        return { linkTo: node.linkTo };
+    }
+    return deepClone(node);
+}

package/build/validate.d.ts

@@ -0,0 +1,3 @@
+import { MOTLYValue, MOTLYSchemaError, MOTLYValidationError } from "motly-ts-interface";
+export declare function validateReferences(root: MOTLYValue): MOTLYValidationError[];
+export declare function validateSchema(tag: MOTLYValue, schema: MOTLYValue): MOTLYSchemaError[];