@1771technologies/lytenyte-pro 2.0.4-dev.2 → 2.0.4-dev.4

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/logical.d.ts

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

package/dist/expressions/plugins/logical.js

@@ -0,0 +1,103 @@
+import { current, advance } from "../parser/parser-context.js";
+import { parseExpression } from "../parser/parse-expression.js";
+const LOGICAL_PRECEDENCE = {
+    "||": 10,
+    "&&": 20,
+    "??": 25,
+};
+export const logicalPlugin = {
+    name: "logical",
+    infixPrecedence: (ctx) => {
+        const tok = current(ctx);
+        if (tok.type === "Operator" && (tok.value === "&&" || tok.value === "||")) {
+            return LOGICAL_PRECEDENCE[tok.value];
+        }
+        if (tok.type === "NullishCoalescing") {
+            return LOGICAL_PRECEDENCE["??"];
+        }
+        return undefined;
+    },
+    parseInfix: (ctx, left, minPrec) => {
+        const tok = current(ctx);
+        let op;
+        let prec;
+        if (tok.type === "Operator" && (tok.value === "&&" || tok.value === "||")) {
+            op = tok.value;
+            prec = LOGICAL_PRECEDENCE[op];
+        }
+        else if (tok.type === "NullishCoalescing") {
+            op = "??";
+            prec = LOGICAL_PRECEDENCE["??"];
+        }
+        if (op === undefined || prec === undefined || prec < minPrec)
+            return null;
+        advance(ctx);
+        const right = parseExpression(ctx, prec + 1);
+        return {
+            type: "BinaryExpression",
+            operator: op,
+            left,
+            right,
+            start: left.start,
+            end: right.end,
+        };
+    },
+    parseUnary: (ctx, parseNext) => {
+        const tok = current(ctx);
+        if (tok.type === "Operator" && tok.value === "!") {
+            advance(ctx);
+            const operand = parseNext(ctx);
+            return {
+                type: "UnaryExpression",
+                operator: "!",
+                operand,
+                start: tok.start,
+                end: operand.end,
+            };
+        }
+        return null;
+    },
+    optimize: (node, opt) => {
+        if (node.type === "UnaryExpression" && node.operator === "!") {
+            const operand = opt(node.operand);
+            if (operand.type === "BooleanLiteral") {
+                return {
+                    type: "BooleanLiteral",
+                    value: !operand.value,
+                    start: node.start,
+                    end: node.end,
+                };
+            }
+            return { ...node, operand };
+        }
+        if (node.type === "BinaryExpression" &&
+            (node.operator === "&&" || node.operator === "||" || node.operator === "??")) {
+            const left = opt(node.left);
+            const right = opt(node.right);
+            return { ...node, left, right };
+        }
+        return null;
+    },
+    evaluate: (node, context, evalFn) => {
+        if (node.type === "UnaryExpression" && node.operator === "!") {
+            const operand = evalFn(node.operand, context);
+            return { value: !operand };
+        }
+        if (node.type === "BinaryExpression") {
+            const op = node.operator;
+            if (op === "&&") {
+                const left = evalFn(node.left, context);
+                return { value: left ? evalFn(node.right, context) : left };
+            }
+            if (op === "||") {
+                const left = evalFn(node.left, context);
+                return { value: left ? left : evalFn(node.right, context) };
+            }
+            if (op === "??") {
+                const left = evalFn(node.left, context);
+                return { value: left != null ? left : evalFn(node.right, context) };
+            }
+        }
+        return null;
+    },
+};

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

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

package/dist/expressions/plugins/membership.js

@@ -0,0 +1,71 @@
+import { current, advance } from "../parser/parser-context.js";
+import { parseExpression } from "../parser/parse-expression.js";
+const MEMBERSHIP_PRECEDENCE = 40;
+export const membershipPlugin = {
+    name: "membership",
+    infixPrecedence: (ctx) => {
+        const tok = current(ctx);
+        if (tok.type === "Operator" && tok.value === "in") {
+            return MEMBERSHIP_PRECEDENCE;
+        }
+        if (tok.type === "Operator" && tok.value === "not") {
+            const next = ctx.tokens[ctx.pos + 1];
+            if (next && next.type === "Operator" && next.value === "in") {
+                return MEMBERSHIP_PRECEDENCE;
+            }
+        }
+        return undefined;
+    },
+    parseInfix: (ctx, left, minPrec) => {
+        const tok = current(ctx);
+        if (tok.type === "Operator" && tok.value === "in") {
+            if (MEMBERSHIP_PRECEDENCE < minPrec)
+                return null;
+            advance(ctx);
+            const right = parseExpression(ctx, MEMBERSHIP_PRECEDENCE + 1);
+            return {
+                type: "BinaryExpression",
+                operator: "in",
+                left,
+                right,
+                start: left.start,
+                end: right.end,
+            };
+        }
+        if (tok.type === "Operator" && tok.value === "not") {
+            const next = ctx.tokens[ctx.pos + 1];
+            if (next && next.type === "Operator" && next.value === "in") {
+                if (MEMBERSHIP_PRECEDENCE < minPrec)
+                    return null;
+                advance(ctx); // consume "not"
+                advance(ctx); // consume "in"
+                const right = parseExpression(ctx, MEMBERSHIP_PRECEDENCE + 1);
+                return {
+                    type: "BinaryExpression",
+                    operator: "not in",
+                    left,
+                    right,
+                    start: left.start,
+                    end: right.end,
+                };
+            }
+        }
+        return null;
+    },
+    evaluate: (node, context, evalFn) => {
+        if (node.type === "BinaryExpression") {
+            const op = node.operator;
+            if (op === "in") {
+                const left = evalFn(node.left, context);
+                const right = evalFn(node.right, context);
+                return { value: left in right };
+            }
+            if (op === "not in") {
+                const left = evalFn(node.left, context);
+                const right = evalFn(node.right, context);
+                return { value: !(left in right) };
+            }
+        }
+        return null;
+    },
+};

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

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

package/dist/expressions/plugins/pipe.js

@@ -0,0 +1,57 @@
+import { current, advance } from "../parser/parser-context.js";
+import { parsePipeTransform } from "../parser/parse-pipe-transform.js";
+const PIPE_PRECEDENCE = 5;
+export const pipePlugin = {
+    name: "pipe",
+    infixPrecedence: (ctx) => {
+        const tok = current(ctx);
+        if (tok.type === "Pipe") {
+            return PIPE_PRECEDENCE;
+        }
+        return undefined;
+    },
+    parseInfix: (ctx, left, minPrec) => {
+        const tok = current(ctx);
+        if (tok.type !== "Pipe")
+            return null;
+        if (PIPE_PRECEDENCE < minPrec)
+            return null;
+        advance(ctx);
+        const transform = parsePipeTransform(ctx);
+        return {
+            type: "PipeExpression",
+            input: left,
+            transform,
+            start: left.start,
+            end: transform.end,
+        };
+    },
+    optimize: (node, opt) => {
+        if (node.type === "PipeExpression") {
+            const n = node;
+            return {
+                ...node,
+                input: opt(n.input),
+                transform: opt(n.transform),
+            };
+        }
+        return null;
+    },
+    evaluate: (node, context, evalFn) => {
+        if (node.type === "PipeExpression") {
+            const n = node;
+            const input = evalFn(n.input, context);
+            // If the transform is a call expression, append input as last argument
+            if (n.transform.type === "CallExpression") {
+                const args = n.transform.args.map((a) => evalFn(a, context));
+                args.push(input);
+                const fn = evalFn(n.transform.callee, context);
+                return { value: fn(...args) };
+            }
+            // Otherwise treat as a function and call with input as sole argument
+            const fn = evalFn(n.transform, context);
+            return { value: fn(input) };
+        }
+        return null;
+    },
+};

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

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

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

@@ -0,0 +1,19 @@
+export function createResolvedIdentifierPlugin(options) {
+    const identifierSet = new Set(options.identifiers);
+    const argKeys = options.args;
+    return {
+        name: "resolved-identifier",
+        evaluate: (node, context) => {
+            if (node.type !== "Identifier")
+                return null;
+            if (!identifierSet.has(node.name))
+                return null;
+            const fn = context[node.name];
+            if (typeof fn !== "function") {
+                throw new Error(`Resolved identifier "${node.name}" is not a function in context`);
+            }
+            const args = argKeys.map((key) => context[key]);
+            return { value: fn(...args) };
+        },
+    };
+}

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

@@ -0,0 +1,13 @@
+import type { Plugin } from "../plugin.js";
+import { stringsPlugin } from "./strings.js";
+import { booleansPlugin } from "./booleans.js";
+import { comparisonPlugin } from "./comparison.js";
+import { logicalPlugin } from "./logical.js";
+import { ternaryPlugin } from "./ternary.js";
+import { pipePlugin } from "./pipe.js";
+import { membershipPlugin } from "./membership.js";
+import { accessPlugin } from "./access.js";
+import { arrowsPlugin } from "./arrows.js";
+import { collectionsPlugin } from "./collections.js";
+export declare const standardPlugins: Plugin[];
+export { stringsPlugin, booleansPlugin, comparisonPlugin, logicalPlugin, ternaryPlugin, pipePlugin, membershipPlugin, accessPlugin, arrowsPlugin, collectionsPlugin, };

package/dist/expressions/plugins/standard.js

@@ -0,0 +1,23 @@
+import { stringsPlugin } from "./strings.js";
+import { booleansPlugin } from "./booleans.js";
+import { comparisonPlugin } from "./comparison.js";
+import { logicalPlugin } from "./logical.js";
+import { ternaryPlugin } from "./ternary.js";
+import { pipePlugin } from "./pipe.js";
+import { membershipPlugin } from "./membership.js";
+import { accessPlugin } from "./access.js";
+import { arrowsPlugin } from "./arrows.js";
+import { collectionsPlugin } from "./collections.js";
+export const standardPlugins = [
+    arrowsPlugin,
+    collectionsPlugin,
+    stringsPlugin,
+    booleansPlugin,
+    comparisonPlugin,
+    logicalPlugin,
+    membershipPlugin,
+    ternaryPlugin,
+    pipePlugin,
+    accessPlugin,
+];
+export { stringsPlugin, booleansPlugin, comparisonPlugin, logicalPlugin, ternaryPlugin, pipePlugin, membershipPlugin, accessPlugin, arrowsPlugin, collectionsPlugin, };

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

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

package/dist/expressions/plugins/strings.js

@@ -0,0 +1,44 @@
+import { current, advance } from "../parser/parser-context.js";
+import { parseTemplateLiteral } from "../parser/parse-template-literal.js";
+export const stringsPlugin = {
+    name: "strings",
+    parsePrefix: (ctx) => {
+        const tok = current(ctx);
+        if (tok.type === "String") {
+            advance(ctx);
+            return { type: "StringLiteral", value: tok.value.slice(1, -1), start: tok.start, end: tok.end };
+        }
+        if (tok.type === "TemplateLiteral") {
+            return parseTemplateLiteral(ctx);
+        }
+        return null;
+    },
+    optimize: (node, opt) => {
+        if (node.type === "TemplateLiteral") {
+            return {
+                ...node,
+                parts: node.parts.map((p) => (p.type === "StringLiteral" ? p : opt(p))),
+            };
+        }
+        return null;
+    },
+    evaluate: (node, context, evalFn) => {
+        if (node.type === "StringLiteral") {
+            return { value: node.value };
+        }
+        if (node.type === "TemplateLiteral") {
+            const parts = node.parts;
+            let result = "";
+            for (const part of parts) {
+                if (part.type === "StringLiteral") {
+                    result += part.value;
+                }
+                else {
+                    result += String(evalFn(part, context));
+                }
+            }
+            return { value: result };
+        }
+        return null;
+    },
+};

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

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

package/dist/expressions/plugins/ternary.js

@@ -0,0 +1,58 @@
+import { current, advance, expect } from "../parser/parser-context.js";
+import { parseExpression } from "../parser/parse-expression.js";
+import { isConstant } from "../compiler/is-constant.js";
+import { valueOf } from "../compiler/value-of.js";
+const TERNARY_PRECEDENCE = 1;
+export const ternaryPlugin = {
+    name: "ternary",
+    infixPrecedence: (ctx) => {
+        const tok = current(ctx);
+        if (tok.type === "Punctuation" && tok.value === "?") {
+            return TERNARY_PRECEDENCE;
+        }
+        return undefined;
+    },
+    parseInfix: (ctx, left, minPrec) => {
+        const tok = current(ctx);
+        if (tok.type !== "Punctuation" || tok.value !== "?")
+            return null;
+        if (TERNARY_PRECEDENCE < minPrec)
+            return null;
+        advance(ctx);
+        const consequent = parseExpression(ctx, 0);
+        expect(ctx, "Punctuation", ":");
+        const alternate = parseExpression(ctx, 0);
+        return {
+            type: "ConditionalExpression",
+            test: left,
+            consequent,
+            alternate,
+            start: left.start,
+            end: alternate.end,
+        };
+    },
+    optimize: (node, opt) => {
+        if (node.type === "ConditionalExpression") {
+            const n = node;
+            const test = opt(n.test);
+            if (isConstant(test)) {
+                return valueOf(test) ? opt(n.consequent) : opt(n.alternate);
+            }
+            return {
+                ...node,
+                test,
+                consequent: opt(n.consequent),
+                alternate: opt(n.alternate),
+            };
+        }
+        return null;
+    },
+    evaluate: (node, context, evalFn) => {
+        if (node.type === "ConditionalExpression") {
+            const n = node;
+            const test = evalFn(n.test, context);
+            return { value: test ? evalFn(n.consequent, context) : evalFn(n.alternate, context) };
+        }
+        return null;
+    },
+};