@1771technologies/lytenyte-pro 2.0.4-dev.3 → 2.1.0

package/dist/expressions/parser/types.d.ts

@@ -0,0 +1,101 @@
+import type { BinaryExpressionOperator, UnaryOperator } from "../lexer/types.js";
+interface BaseNode {
+    start: number;
+    end: number;
+}
+export interface NumberLiteral extends BaseNode {
+    type: "NumberLiteral";
+    value: number;
+}
+export interface StringLiteral extends BaseNode {
+    type: "StringLiteral";
+    value: string;
+}
+export interface BooleanLiteral extends BaseNode {
+    type: "BooleanLiteral";
+    value: boolean;
+}
+export interface NullLiteral extends BaseNode {
+    type: "NullLiteral";
+    value: null;
+}
+export interface UndefinedLiteral extends BaseNode {
+    type: "UndefinedLiteral";
+    value: undefined;
+}
+export interface Identifier extends BaseNode {
+    type: "Identifier";
+    name: string;
+}
+export interface BinaryExpression extends BaseNode {
+    type: "BinaryExpression";
+    operator: BinaryExpressionOperator;
+    left: ASTNode;
+    right: ASTNode;
+}
+export interface UnaryExpression extends BaseNode {
+    type: "UnaryExpression";
+    operator: UnaryOperator;
+    operand: ASTNode;
+}
+export interface ConditionalExpression extends BaseNode {
+    type: "ConditionalExpression";
+    test: ASTNode;
+    consequent: ASTNode;
+    alternate: ASTNode;
+}
+export interface MemberExpression extends BaseNode {
+    type: "MemberExpression";
+    object: ASTNode;
+    property: ASTNode;
+    computed: boolean;
+}
+export interface OptionalMemberExpression extends BaseNode {
+    type: "OptionalMemberExpression";
+    object: ASTNode;
+    property: ASTNode;
+    computed: boolean;
+}
+export interface ArrayLiteral extends BaseNode {
+    type: "ArrayLiteral";
+    readonly elements: readonly (ASTNode | SpreadElement)[];
+}
+export interface ObjectLiteral extends BaseNode {
+    type: "ObjectLiteral";
+    readonly properties: readonly ObjectProperty[];
+}
+export interface ObjectProperty extends BaseNode {
+    type: "ObjectProperty";
+    key: ASTNode;
+    value: ASTNode;
+    computed: boolean;
+}
+export interface CallExpression extends BaseNode {
+    type: "CallExpression";
+    callee: ASTNode;
+    readonly args: readonly ASTNode[];
+}
+export interface PipeExpression extends BaseNode {
+    type: "PipeExpression";
+    input: ASTNode;
+    transform: ASTNode;
+}
+export interface TemplateLiteral extends BaseNode {
+    type: "TemplateLiteral";
+    readonly parts: readonly (StringLiteral | ASTNode)[];
+}
+export interface SpreadElement extends BaseNode {
+    type: "SpreadElement";
+    argument: ASTNode;
+}
+export interface ArrowFunctionExpression extends BaseNode {
+    type: "ArrowFunctionExpression";
+    params: string[];
+    body: ASTNode;
+}
+export interface DateLiteralNode extends BaseNode {
+    type: "DateLiteralNode";
+    value: string;
+}
+export type ASTNode = NumberLiteral | StringLiteral | BooleanLiteral | NullLiteral | UndefinedLiteral | Identifier | BinaryExpression | UnaryExpression | ConditionalExpression | MemberExpression | OptionalMemberExpression | ArrayLiteral | ObjectLiteral | CallExpression | PipeExpression | TemplateLiteral | SpreadElement | ArrowFunctionExpression | DateLiteralNode;
+export {};

package/dist/expressions/parser/types.js

@@ -0,0 +1 @@
+export {};

package/dist/expressions/plugin.d.ts

@@ -0,0 +1,20 @@
+import type { ASTNode } from "./parser/types.js";
+import type { ParserContext } from "./parser/parser-context.js";
+export type EvalFn = (node: ASTNode, context: Record<string, unknown>) => unknown;
+export interface Plugin {
+    name: string;
+    scan?: (source: string, pos: number) => {
+        type: string;
+        value: string;
+        end: number;
+    } | null;
+    parsePrefix?: (ctx: ParserContext) => ASTNode | null;
+    parseInfix?: (ctx: ParserContext, left: ASTNode, minPrec: number) => ASTNode | null;
+    parsePostfix?: (ctx: ParserContext, node: ASTNode) => ASTNode | null;
+    parseUnary?: (ctx: ParserContext, parseNext: (ctx: ParserContext) => ASTNode) => ASTNode | null;
+    infixPrecedence?: (ctx: ParserContext) => number | undefined;
+    optimize?: (node: ASTNode, optimize: (n: ASTNode) => ASTNode) => ASTNode | null;
+    evaluate?: (node: ASTNode, context: Record<string, unknown>, evaluate: EvalFn) => {
+        value: unknown;
+    } | null;
+}

package/dist/expressions/plugin.js

@@ -0,0 +1 @@
+export {};

package/dist/expressions/plugins/access.d.ts

@@ -0,0 +1,2 @@
+import type { Plugin } from "../plugin.js";
+export declare const accessPlugin: Plugin;

package/dist/expressions/plugins/access.js

@@ -0,0 +1,138 @@
+import { current, advance, expect } from "../parser/parser-context.js";
+import { parseExpression } from "../parser/parse-expression.js";
+export const accessPlugin = {
+    name: "access",
+    parsePostfix: (ctx, node) => {
+        const tok = current(ctx);
+        // Member access: .prop
+        if (tok.type === "Punctuation" && tok.value === ".") {
+            advance(ctx);
+            const prop = expect(ctx, "Identifier");
+            return {
+                type: "MemberExpression",
+                object: node,
+                property: { type: "Identifier", name: prop.value, start: prop.start, end: prop.end },
+                computed: false,
+                start: node.start,
+                end: prop.end,
+            };
+        }
+        // Computed member access: [expr]
+        if (tok.type === "Punctuation" && tok.value === "[") {
+            advance(ctx);
+            const property = parseExpression(ctx, 0);
+            const end = expect(ctx, "Punctuation", "]").end;
+            return {
+                type: "MemberExpression",
+                object: node,
+                property,
+                computed: true,
+                start: node.start,
+                end,
+            };
+        }
+        // Optional chaining: ?.prop or ?.[expr]
+        if (tok.type === "OptionalChain") {
+            advance(ctx);
+            if (current(ctx).type === "Punctuation" && current(ctx).value === "[") {
+                advance(ctx);
+                const property = parseExpression(ctx, 0);
+                const end = expect(ctx, "Punctuation", "]").end;
+                return {
+                    type: "OptionalMemberExpression",
+                    object: node,
+                    property,
+                    computed: true,
+                    start: node.start,
+                    end,
+                };
+            }
+            const prop = expect(ctx, "Identifier");
+            return {
+                type: "OptionalMemberExpression",
+                object: node,
+                property: { type: "Identifier", name: prop.value, start: prop.start, end: prop.end },
+                computed: false,
+                start: node.start,
+                end: prop.end,
+            };
+        }
+        // Function call: (args)
+        if (tok.type === "Punctuation" && tok.value === "(") {
+            advance(ctx);
+            const args = [];
+            while (!(current(ctx).type === "Punctuation" && current(ctx).value === ")")) {
+                if (args.length > 0)
+                    expect(ctx, "Punctuation", ",");
+                if (current(ctx).type === "Punctuation" && current(ctx).value === ")")
+                    break;
+                args.push(parseExpression(ctx, 0));
+            }
+            const end = expect(ctx, "Punctuation", ")").end;
+            return {
+                type: "CallExpression",
+                callee: node,
+                args,
+                start: node.start,
+                end,
+            };
+        }
+        return null;
+    },
+    optimize: (node, opt) => {
+        if (node.type === "MemberExpression" || node.type === "OptionalMemberExpression") {
+            const n = node;
+            return {
+                ...node,
+                object: opt(n.object),
+                property: n.computed ? opt(n.property) : n.property,
+            };
+        }
+        if (node.type === "CallExpression") {
+            const n = node;
+            return { ...node, callee: opt(n.callee), args: n.args.map((a) => opt(a)) };
+        }
+        return null;
+    },
+    evaluate: (node, context, evalFn) => {
+        if (node.type === "MemberExpression") {
+            const n = node;
+            const object = evalFn(n.object, context);
+            if (n.computed) {
+                const property = evalFn(n.property, context);
+                return { value: object[property] };
+            }
+            return { value: object[n.property.name] };
+        }
+        if (node.type === "OptionalMemberExpression") {
+            const n = node;
+            const object = evalFn(n.object, context);
+            if (object == null)
+                return { value: undefined };
+            if (n.computed) {
+                const property = evalFn(n.property, context);
+                return { value: object[property] };
+            }
+            return { value: object[n.property.name] };
+        }
+        if (node.type === "CallExpression") {
+            const n = node;
+            const args = n.args.map((a) => evalFn(a, context));
+            // Method call — preserve this binding
+            if (n.callee.type === "MemberExpression" || n.callee.type === "OptionalMemberExpression") {
+                const obj = evalFn(n.callee.object, context);
+                if (n.callee.type === "OptionalMemberExpression" && obj == null) {
+                    return { value: undefined };
+                }
+                const prop = n.callee.computed
+                    ? evalFn(n.callee.property, context)
+                    : n.callee.property.name;
+                const method = obj[prop];
+                return { value: method.apply(obj, args) };
+            }
+            const fn = evalFn(n.callee, context);
+            return { value: fn(...args) };
+        }
+        return null;
+    },
+};

package/dist/expressions/plugins/arrows.d.ts

@@ -0,0 +1,2 @@
+import type { Plugin } from "../plugin.js";
+export declare const arrowsPlugin: Plugin;

package/dist/expressions/plugins/arrows.js

@@ -0,0 +1,83 @@
+import { current, advance, expect } from "../parser/parser-context.js";
+import { parseExpression } from "../parser/parse-expression.js";
+function isArrowParams(ctx) {
+    let i = ctx.pos + 1;
+    let depth = 1;
+    while (i < ctx.tokens.length && depth > 0) {
+        const t = ctx.tokens[i];
+        if (t.type === "Punctuation" && t.value === "(")
+            depth++;
+        else if (t.type === "Punctuation" && t.value === ")")
+            depth--;
+        if (depth > 0)
+            i++;
+    }
+    const after = ctx.tokens[i + 1];
+    return after?.type === "Arrow";
+}
+function parseArrowFunction(ctx) {
+    const start = current(ctx).start;
+    advance(ctx); // consume (
+    const params = [];
+    while (!(current(ctx).type === "Punctuation" && current(ctx).value === ")")) {
+        if (params.length > 0)
+            expect(ctx, "Punctuation", ",");
+        const param = expect(ctx, "Identifier");
+        params.push(param.value);
+    }
+    expect(ctx, "Punctuation", ")"); // consume )
+    advance(ctx); // consume =>
+    const body = parseExpression(ctx, 0);
+    return {
+        type: "ArrowFunctionExpression",
+        params,
+        body,
+        start,
+        end: body.end,
+    };
+}
+export const arrowsPlugin = {
+    name: "arrows",
+    parsePrefix: (ctx) => {
+        const tok = current(ctx);
+        // Single-param arrow: identifier => expr
+        if (tok.type === "Identifier" && ctx.tokens[ctx.pos + 1]?.type === "Arrow") {
+            advance(ctx); // consume identifier
+            advance(ctx); // consume =>
+            const body = parseExpression(ctx, 0);
+            return {
+                type: "ArrowFunctionExpression",
+                params: [tok.value],
+                body,
+                start: tok.start,
+                end: body.end,
+            };
+        }
+        // Multi-param arrow: (a, b) => expr
+        if (tok.type === "Punctuation" && tok.value === "(" && isArrowParams(ctx)) {
+            return parseArrowFunction(ctx);
+        }
+        return null;
+    },
+    optimize: (node, opt) => {
+        if (node.type === "ArrowFunctionExpression") {
+            return { ...node, body: opt(node.body) };
+        }
+        return null;
+    },
+    evaluate: (node, context, evalFn) => {
+        if (node.type === "ArrowFunctionExpression") {
+            const n = node;
+            return {
+                value: (...args) => {
+                    const childContext = { ...context };
+                    for (let i = 0; i < n.params.length; i++) {
+                        childContext[n.params[i]] = args[i];
+                    }
+                    return evalFn(n.body, childContext);
+                },
+            };
+        }
+        return null;
+    },
+};

package/dist/expressions/plugins/booleans.d.ts

@@ -0,0 +1,2 @@
+import type { Plugin } from "../plugin.js";
+export declare const booleansPlugin: Plugin;

package/dist/expressions/plugins/booleans.js

@@ -0,0 +1,34 @@
+import { current, advance } from "../parser/parser-context.js";
+export const booleansPlugin = {
+    name: "booleans",
+    parsePrefix: (ctx) => {
+        const tok = current(ctx);
+        if (tok.type === "Boolean") {
+            advance(ctx);
+            return {
+                type: "BooleanLiteral",
+                value: tok.value === "true",
+                start: tok.start,
+                end: tok.end,
+            };
+        }
+        if (tok.type === "Null") {
+            advance(ctx);
+            return { type: "NullLiteral", value: null, start: tok.start, end: tok.end };
+        }
+        if (tok.type === "Undefined") {
+            advance(ctx);
+            return { type: "UndefinedLiteral", value: undefined, start: tok.start, end: tok.end };
+        }
+        return null;
+    },
+    evaluate: (node) => {
+        if (node.type === "BooleanLiteral")
+            return { value: node.value };
+        if (node.type === "NullLiteral")
+            return { value: null };
+        if (node.type === "UndefinedLiteral")
+            return { value: undefined };
+        return null;
+    },
+};

package/dist/expressions/plugins/collections.d.ts

@@ -0,0 +1,2 @@
+import type { Plugin } from "../plugin.js";
+export declare const collectionsPlugin: Plugin;

package/dist/expressions/plugins/collections.js

@@ -0,0 +1,70 @@
+import { current, advance } from "../parser/parser-context.js";
+import { parseArrayLiteral } from "../parser/parse-array-literal.js";
+import { parseObjectLiteral } from "../parser/parse-object-literal.js";
+import { parseExpression } from "../parser/parse-expression.js";
+export const collectionsPlugin = {
+    name: "collections",
+    parsePrefix: (ctx) => {
+        const tok = current(ctx);
+        // Array literal: [elements]
+        if (tok.type === "Punctuation" && tok.value === "[") {
+            return parseArrayLiteral(ctx);
+        }
+        // Object literal: { props }
+        if (tok.type === "Punctuation" && tok.value === "{") {
+            return parseObjectLiteral(ctx);
+        }
+        // Spread element: ...expr
+        if (tok.type === "Spread") {
+            advance(ctx);
+            const argument = parseExpression(ctx, 0);
+            return { type: "SpreadElement", argument, start: tok.start, end: argument.end };
+        }
+        return null;
+    },
+    optimize: (node, opt) => {
+        if (node.type === "ArrayLiteral") {
+            return { ...node, elements: node.elements.map((e) => opt(e)) };
+        }
+        if (node.type === "ObjectLiteral") {
+            return {
+                ...node,
+                properties: node.properties.map((p) => ({
+                    ...p,
+                    key: p.computed ? opt(p.key) : p.key,
+                    value: opt(p.value),
+                })),
+            };
+        }
+        return null;
+    },
+    evaluate: (node, context, evalFn) => {
+        if (node.type === "ArrayLiteral") {
+            const result = [];
+            for (const element of node.elements) {
+                if (element.type === "SpreadElement") {
+                    const spread = evalFn(element.argument, context);
+                    result.push(...spread);
+                }
+                else {
+                    result.push(evalFn(element, context));
+                }
+            }
+            return { value: result };
+        }
+        if (node.type === "ObjectLiteral") {
+            const result = {};
+            for (const prop of node.properties) {
+                const key = prop.computed
+                    ? evalFn(prop.key, context)
+                    : prop.key.type === "Identifier"
+                        ? prop.key.name
+                        : prop.key.value;
+                const value = evalFn(prop.value, context);
+                result[key] = value;
+            }
+            return { value: result };
+        }
+        return null;
+    },
+};

package/dist/expressions/plugins/comparison.d.ts

@@ -0,0 +1,2 @@
+import type { Plugin } from "../plugin.js";
+export declare const comparisonPlugin: Plugin;

package/dist/expressions/plugins/comparison.js

@@ -0,0 +1,51 @@
+import { current } from "../parser/parser-context.js";
+const COMPARISON_PRECEDENCE = {
+    "==": 30,
+    "!=": 30,
+    "<": 40,
+    ">": 40,
+    "<=": 40,
+    ">=": 40,
+};
+export const comparisonPlugin = {
+    name: "comparison",
+    infixPrecedence: (ctx) => {
+        const tok = current(ctx);
+        if (tok.type === "Operator") {
+            return COMPARISON_PRECEDENCE[tok.value];
+        }
+        return undefined;
+    },
+    optimize: (node, opt) => {
+        if (node.type === "BinaryExpression" && node.operator in COMPARISON_PRECEDENCE) {
+            const left = opt(node.left);
+            const right = opt(node.right);
+            return { ...node, left, right };
+        }
+        return null;
+    },
+    evaluate: (node, context, evalFn) => {
+        if (node.type === "BinaryExpression") {
+            const op = node.operator;
+            if (op in COMPARISON_PRECEDENCE) {
+                const left = evalFn(node.left, context);
+                const right = evalFn(node.right, context);
+                switch (op) {
+                    case "==":
+                        return { value: left === right };
+                    case "!=":
+                        return { value: left !== right };
+                    case "<":
+                        return { value: left < right };
+                    case ">":
+                        return { value: left > right };
+                    case "<=":
+                        return { value: left <= right };
+                    case ">=":
+                        return { value: left >= right };
+                }
+            }
+        }
+        return null;
+    },
+};

package/dist/expressions/plugins/date-identifier.d.ts

@@ -0,0 +1,4 @@
+import type { Plugin } from "../plugin.js";
+export declare function createDateIdentifierPlugin(options: {
+    identifiers: string[];
+}): Plugin;

package/dist/expressions/plugins/date-identifier.js

@@ -0,0 +1,29 @@
+function toDate(value) {
+    if (value instanceof Date)
+        return value;
+    if (typeof value === "string" || typeof value === "number") {
+        const d = new Date(value);
+        return isNaN(d.getTime()) ? null : d;
+    }
+    return null;
+}
+export function createDateIdentifierPlugin(options) {
+    const identifierSet = new Set(options.identifiers);
+    return {
+        name: "date-identifier",
+        evaluate: (node, context) => {
+            if (node.type !== "Identifier")
+                return null;
+            if (!identifierSet.has(node.name))
+                return null;
+            const raw = context[node.name];
+            const date = toDate(raw);
+            if (date === null) {
+                if (raw === undefined || raw === null)
+                    return { value: null };
+                throw new Error(`Context value for "${node.name}" cannot be coerced to a Date`);
+            }
+            return { value: date };
+        },
+    };
+}

package/dist/expressions/plugins/date-literal.d.ts

@@ -0,0 +1,2 @@
+import type { Plugin } from "../plugin.js";
+export declare const dateLiteralPlugin: Plugin;

package/dist/expressions/plugins/date-literal.js

@@ -0,0 +1,71 @@
+import { scanString } from "../lexer/tokenize/scan-string.js";
+import { current, advance } from "../parser/parser-context.js";
+import { ExpressionError } from "../errors/expression-error.js";
+const DATE_OPS = new Set(["==", "!=", "<", ">", "<=", ">="]);
+export const dateLiteralPlugin = {
+    name: "date-literal",
+    scan(source, pos) {
+        if (source[pos] !== "d")
+            return null;
+        const next = source[pos + 1];
+        if (next !== '"' && next !== "'")
+            return null;
+        try {
+            const r = scanString(source, pos + 1);
+            // Store the full source text (d"2023-02-11") so the editor overlay renders it correctly.
+            return { type: "DateLiteral", value: source.slice(pos, r.end), end: r.end };
+        }
+        catch (e) {
+            if (e instanceof ExpressionError) {
+                throw new ExpressionError(e.rawMessage, { source, start: pos, end: e.end });
+            }
+            throw e;
+        }
+    },
+    parsePrefix(ctx) {
+        const tok = current(ctx);
+        if (tok.type !== "DateLiteral")
+            return null;
+        advance(ctx);
+        // tok.value is the full d"2023-02-11" — strip the d" prefix and closing quote for the AST.
+        const dateStr = tok.value.slice(2, -1);
+        return { type: "DateLiteralNode", value: dateStr, start: tok.start, end: tok.end };
+    },
+    evaluate(node, context, evalFn) {
+        if (node.type === "DateLiteralNode") {
+            const d = new Date(node.value);
+            if (isNaN(d.getTime())) {
+                throw new Error(`Invalid date literal: "${node.value}"`);
+            }
+            return { value: d };
+        }
+        // Intercept comparison operators when at least one operand is a Date.
+        // This must run before comparisonPlugin (place dateLiteralPlugin first in the array).
+        if (node.type === "BinaryExpression") {
+            const op = node.operator;
+            if (!DATE_OPS.has(op))
+                return null;
+            const left = evalFn(node.left, context);
+            const right = evalFn(node.right, context);
+            if (!(left instanceof Date) && !(right instanceof Date))
+                return null;
+            const lt = left instanceof Date ? left.getTime() : Number(left);
+            const rt = right instanceof Date ? right.getTime() : Number(right);
+            switch (op) {
+                case "==":
+                    return { value: lt === rt };
+                case "!=":
+                    return { value: lt !== rt };
+                case "<":
+                    return { value: lt < rt };
+                case ">":
+                    return { value: lt > rt };
+                case "<=":
+                    return { value: lt <= rt };
+                case ">=":
+                    return { value: lt >= rt };
+            }
+        }
+        return null;
+    },
+};

package/dist/expressions/plugins/logical.d.ts

@@ -0,0 +1,2 @@
+import type { Plugin } from "../plugin.js";
+export declare const logicalPlugin: Plugin;