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

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

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

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

@@ -0,0 +1,35 @@
+import { scanString } from "../lexer/tokenize/scan-string.js";
+import { current, advance } from "../parser/parser-context.js";
+import { ExpressionError } from "../errors/expression-error.js";
+export const quotedIdentifierPlugin = {
+    name: "quoted-identifier",
+    scan(source, pos) {
+        if (source[pos] !== "@")
+            return null;
+        const next = source[pos + 1];
+        if (next !== '"' && next !== "'")
+            return null;
+        try {
+            const r = scanString(source, pos + 1);
+            // Store the full source text (@"Age Group") so the token overlay renders correctly.
+            return { type: "QuotedIdentifier", value: source.slice(pos, r.end), end: r.end };
+        }
+        catch (e) {
+            // Rethrow with start=pos so the ExpressionError token covers the leading @ character.
+            // Without this, scanString reports start at the opening quote (pos+1), leaving @ uncovered.
+            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 !== "QuotedIdentifier")
+            return null;
+        advance(ctx);
+        // Strip the leading @" (or @') and the trailing quote to get the bare identifier name.
+        const name = tok.value.slice(2, -1);
+        return { type: "Identifier", name, start: tok.start, end: tok.end };
+    },
+};

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,15 @@
+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";
+import { quotedIdentifierPlugin } from "./quoted-identifier.js";
+import { dateLiteralPlugin } from "./date-literal.js";
+export declare const standardPlugins: Plugin[];
+export { dateLiteralPlugin, stringsPlugin, booleansPlugin, comparisonPlugin, logicalPlugin, ternaryPlugin, pipePlugin, membershipPlugin, accessPlugin, arrowsPlugin, collectionsPlugin, quotedIdentifierPlugin, };

package/dist/expressions/plugins/standard.js

@@ -0,0 +1,27 @@
+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";
+import { quotedIdentifierPlugin } from "./quoted-identifier.js";
+import { dateLiteralPlugin } from "./date-literal.js";
+export const standardPlugins = [
+    dateLiteralPlugin,
+    arrowsPlugin,
+    collectionsPlugin,
+    stringsPlugin,
+    booleansPlugin,
+    comparisonPlugin,
+    logicalPlugin,
+    membershipPlugin,
+    ternaryPlugin,
+    pipePlugin,
+    accessPlugin,
+    quotedIdentifierPlugin,
+];
+export { dateLiteralPlugin, stringsPlugin, booleansPlugin, comparisonPlugin, logicalPlugin, ternaryPlugin, pipePlugin, membershipPlugin, accessPlugin, arrowsPlugin, collectionsPlugin, quotedIdentifierPlugin, };

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;
+    },
+};

package/dist/expressions.d.ts

@@ -0,0 +1,2 @@
+export * from "./expressions/index.js";
+export * from "./components/expressions-editor/index.js";

package/dist/expressions.js

@@ -0,0 +1,2 @@
+export * from "./expressions/index.js";
+export * from "./components/expressions-editor/index.js";

package/dist/index.d.ts

@@ -103,6 +103,7 @@ export declare namespace Grid {
         type PivotField<Spec extends GridSpec> = LnTypes.PivotField<Spec>;
         type PivotModel<Spec extends GridSpec> = LnTypes.PivotModel<Spec>;
         type PivotState = LnTypes.PivotState;
+        type VirtualTarget = LnTypes.VirtualTarget;
     }
 }
 export type { UseClientDataSourceParams, RowSourceClient, } from "./data-source-client/use-client-data-source.js";

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "@1771technologies/lytenyte-pro",
   "description": "Blazingly fast headless React data grid with 100s of features.",
-  "version": "2.0.4-dev.3",
+  "version": "2.1.0",
   "type": "module",
   "license": "COMMERCIAL",
   "files": [
     "dist",
     "css",
+    "skills",
     "LICENSE",
     "SECURITY.md",
     "README.md"
@@ -59,10 +60,16 @@
       "import": "./dist/components.js",
       "require": "./dist/components.js"
     },
+    "./expressions": {
+      "types": "./dist/expressions.d.ts",
+      "import": "./dist/expressions.js",
+      "require": "./dist/expressions.js"
+    },
     "./grid.css": "./css/grid.css",
     "./grid-full.css": "./css/grid-full.css",
     "./light-dark.css": "./css/light-dark.css",
     "./all-colors.css": "./css/all-colors.css",
+    "./expression-editor.css": "./css/components/expression-editor.css",
     "./cotton-candy.css": "./css/cotton-candy.css",
     "./dark.css": "./css/dark.css",
     "./design.css": "./css/design.css",
@@ -79,12 +86,12 @@
     "access": "public"
   },
   "dependencies": {
-    "@1771technologies/lytenyte-core": "2.0.4-dev.3",
-    "@1771technologies/lytenyte-design": "2.0.4-dev.3",
-    "@1771technologies/lytenyte-shared": "2.0.4-dev.3"
+    "@1771technologies/lytenyte-core": "2.1.0",
+    "@1771technologies/lytenyte-shared": "2.1.0",
+    "@1771technologies/lytenyte-design": "2.1.0"
   },
   "devDependencies": {
-    "@1771technologies/grid-sample-data": "2.0.4-dev.3"
+    "@1771technologies/grid-sample-data": "2.1.0"
   },
   "peerDependencies": {
     "react": "18.0.0 || ^19.0.0",