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

package/dist/components/pill-manager/container.js

@@ -3,14 +3,20 @@ import { forwardRef, memo, useEffect, useRef, useState } from "react";
 import { usePillRoot } from "./root.context.js";
 import { usePillRow } from "./pill-row.context.js";
 import { dragX, dragY, getDragData, useCombinedRefs, useSelector, } from "@1771technologies/lytenyte-core/internal";
-import { getFocusables } from "@1771technologies/lytenyte-shared";
+import { equal, getFocusables } from "@1771technologies/lytenyte-shared";
 function ContainerBase(props, forwarded) {
-    const { setCloned, orientation, rows, movedRef } = usePillRoot();
+    const { setCloned, cloned, orientation, rows, movedRef, onPillRowChange, onPillItemActiveChange } = usePillRoot();
     const { row } = usePillRow();
     const [over, setOver] = useState(false);
+    const [external, setExternal] = useState(false);
     const x = useSelector(dragX);
     const y = useSelector(dragY);
     const [container, setContainer] = useState(null);
+    const ds = getDragData();
+    useEffect(() => {
+        if (!ds)
+            setExternal(false);
+    }, [ds]);
     const wasOver = useRef(false);
     useEffect(() => {
         if (!container)
@@ -20,12 +26,26 @@ function ContainerBase(props, forwarded) {
             setOver(false);
             return;
         }
-        const { item: dragged, id } = ds.pill.data;
+        let { item: dragged, id } = ds.pill.data;
+        // We resolve the external item to a dragged item here.
+        const originalId = id;
+        if (id === "__external__") {
+            const d = dragged;
+            if (!d[row.id])
+                return;
+            id = row.id;
+            dragged = row.pills.find((x) => x.id === d[row.id]);
+            if (!dragged) {
+                console.error("Specified an external item, but that item is not in the pill group.");
+                return;
+            }
+        }
         const bb = container.getBoundingClientRect();
         const isOver = bb.left < x && bb.right > x && bb.top < y && bb.bottom > y;
         // The current drag is from the current row.
         if (id === row.id) {
             movedRef.current = !isOver ? { id: row.id, pillId: dragged.id } : null;
+            setExternal(isOver && originalId === "__external__");
             return;
         }
         const thisRow = rows.findIndex((x) => x.id === row.id);
@@ -43,11 +63,11 @@ function ContainerBase(props, forwarded) {
             setCloned((prev) => {
                 if (!prev)
                     throw new Error("Can't call drag function without cloning nodes.");
-                const newPill = { ...prev[thisRow] };
-                newPill.pills = newPills;
-                const newDef = [...prev];
-                newDef[thisRow] = newPill;
-                return newDef;
+                const newPillSpec = { ...prev[thisRow] };
+                newPillSpec.pills = newPills;
+                const newPillRows = [...prev];
+                newPillRows[thisRow] = newPillSpec;
+                return newPillRows;
             });
         }
         else {
@@ -80,7 +100,7 @@ function ContainerBase(props, forwarded) {
     }, [container, movedRef, over, row, rows, setCloned, x, y]);
     const combined = useCombinedRefs(forwarded, setContainer);
     const rtl = useRef(null);
-    return (_jsx("div", { ...props, ref: combined, "data-ln-over": over, "data-ln-orientation": orientation, "data-ln-pill-container": true, "data-ln-pill-type": row.type, tabIndex: 0, onKeyDown: (ev) => {
+    return (_jsx("div", { ...props, ref: combined, "data-ln-over": over, "data-ln-external-over": external, "data-ln-orientation": orientation, "data-ln-pill-container": true, "data-ln-pill-type": row.type, tabIndex: 0, onKeyDown: (ev) => {
             if (rtl.current == null) {
                 const dir = getComputedStyle(ev.currentTarget).direction;
                 rtl.current = dir === "rtl";
@@ -118,6 +138,32 @@ function ContainerBase(props, forwarded) {
         }, onDrop: (e) => {
             e.preventDefault();
             e.stopPropagation();
+            const ds = getDragData();
+            if (!ds?.pill?.data || ds.pill.data.id != "__external__")
+                return;
+            let { item: dragged } = ds.pill.data;
+            // We resolve the external item to a dragged item here.
+            const d = dragged;
+            if (!d[row.id])
+                return;
+            dragged = row.pills.find((x) => x.id === d[row.id]);
+            const changed = cloned?.filter((x, i) => {
+                return !equal(x, rows[i]);
+            });
+            if (!dragged.active) {
+                const next = true;
+                const nextPill = { ...dragged, active: next };
+                const nextPills = [...row.pills];
+                nextPills.splice(nextPills.indexOf(dragged), 1, nextPill);
+                const nextRow = { ...row, pills: nextPills };
+                const index = rows.indexOf(row);
+                onPillItemActiveChange({ index, item: nextPill, row: nextRow });
+            }
+            dragged.active = true;
+            if (changed?.length) {
+                onPillRowChange({ changed, full: cloned });
+            }
+            setCloned(null);
         }, onDragOver: (e) => {
             e.dataTransfer.dropEffect = "move";
             e.preventDefault();

package/dist/components/pill-manager/item.js

@@ -53,7 +53,18 @@ function PillItemBase({ item, elementEnd, ...props }, ref) {
         const ds = getDragData();
         if (!ds?.pill?.data)
             return;
-        const { item: dragged, id: dragRowId } = ds.pill.data;
+        let { item: dragged, id: dragRowId } = ds.pill.data;
+        const original = dragRowId;
+        // We resolve the external item to a dragged item here.
+        if (dragRowId === "__external__") {
+            const d = dragged;
+            if (!d[row.id])
+                return;
+            dragRowId = row.id;
+            dragged = row.pills.find((x) => x.id === d[row.id]);
+            if (!dragged)
+                return;
+        }
         const accepts = new Set([...(row.accepts ?? []), row.id]);
         if (!accepts.has(dragRowId) && !item.tags?.some((x) => accepts.has(x)))
             return;
@@ -93,6 +104,9 @@ function PillItemBase({ item, elementEnd, ...props }, ref) {
             prevSwapId.current = currentSwapId;
             prevRowId.current = currentRowId;
             setCloned((prev) => {
+                if (original === "__external__" && !prev) {
+                    prev = structuredClone(rows);
+                }
                 if (!prev)
                     throw new Error("Can't call drag function without cloning nodes.");
                 const thisRow = prev.findIndex((x) => x.id === row.id);

package/dist/components/select-all.js

@@ -6,7 +6,7 @@ export function SelectAll({ api, slot, }) {
     const s = api.useSelectionState();
     const selected = useMemo(() => {
         const selected = s.kind === "isolated" ? s.selected && s.exceptions.size === 0 : s.selected && s.children.size === 0;
-        return selected;
+        return !!selected;
     }, [s]);
     const indeterminate = useMemo(() => {
         if (s.kind === "isolated")

package/dist/components/tree-view/root.d.ts

@@ -1,6 +1,7 @@
 import { type ReactNode } from "react";
 import { type RowGroup, type RowLeaf, type RowSelectionLinked } from "@1771technologies/lytenyte-shared";
 import type { TreeViewChildParams, TreeViewItem, TreeViewSelectAllParams } from "./types.js";
+import type { DragItem, RowNode } from "../../types.js";
 export interface TreeViewProps<T extends TreeViewItem> {
     readonly items: T[];
     readonly children?: (props: TreeViewChildParams<T>) => ReactNode;
@@ -22,6 +23,14 @@ export interface TreeViewProps<T extends TreeViewItem> {
      * and drag is still being prototyped.
      */
     readonly draggable?: boolean;
+    /**
+     * @alpha
+     * @internal
+     *
+     * Do not use this property unless you know what you are doing. Support for tree view drag
+     * and drag is still being prototyped.
+     */
+    readonly getDragTags?: (row: RowNode<T>, leafs: RowLeaf<T>[]) => Record<string, DragItem>;
     /**
      * @alpha
      * @internal

package/dist/components/tree-view/root.js

@@ -7,7 +7,7 @@ import { useClientDataSource } from "../../data-source-client/use-client-data-so
 import { usePiece } from "@1771technologies/lytenyte-core/internal";
 import { Root } from "../../root/root.js";
 import { Grid } from "@1771technologies/lytenyte-core";
-function TreeViewBase({ items, rowSelectAllShow: rowSelectAll = true, defaultExpansion, rowHeight = 28, children = TreeChildren, branchJoinSeparator = "/", rowSelectionEnabled = true, rowSelection, onRowSelectionChange, rowGroupExpansions, onRowGroupExpansionChange, selectAllSlot, draggable, onItemsReordered, }, forwarded) {
+function TreeViewBase({ items, rowSelectAllShow: rowSelectAll = true, defaultExpansion, rowHeight = 28, children = TreeChildren, branchJoinSeparator = "/", rowSelectionEnabled = true, rowSelection, onRowSelectionChange, rowGroupExpansions, onRowGroupExpansionChange, selectAllSlot, draggable, getDragTags, onItemsReordered, }, forwarded) {
     const groupFn = useMemo(() => {
         return (x) => x.data.path;
     }, []);
@@ -46,8 +46,10 @@ function TreeViewBase({ items, rowSelectAllShow: rowSelectAll = true, defaultExp
             width: 20,
             widthMin: 20,
             cellRenderer: ({ row, rowIndex, api, indeterminate, selected }) => {
+                const tags = getDragTags?.(row, api.rowLeafs(row.id).map((x) => api.rowById(x)));
                 const { props, isDragActive } = api.useRowDrag({
                     rowIndex,
+                    tags,
                 });
                 const over = over$.useValue();
                 const isBefore = isBefore$.useValue();
@@ -76,7 +78,7 @@ function TreeViewBase({ items, rowSelectAllShow: rowSelectAll = true, defaultExp
                 });
             },
         };
-    }, [children, draggable, isBefore$, itemLookup, over$, rowSelectionEnabled, selectAllSlot]);
+    }, [children, draggable, getDragTags, isBefore$, itemLookup, over$, rowSelectionEnabled, selectAllSlot]);
     useImperativeHandle(forwarded, () => {
         return {
             rowsSelected: () => (api?.rowsSelected().rows ?? []).filter((x) => x.id !== "__ln_select_all"),

package/dist/data-source-client/hooks/use-flattened-groups.js

@@ -39,7 +39,7 @@ export function useFlattenedGroups(root, agg, leafs, workingSet, sort, expandedF
     }, [agg, expandedFn, ignoreIsLast, leafs, root, sort, sortFallback, suppressLeafExpansion, workingSet]);
     return flat;
 }
-const nodeChildrenToRows = (root, agg, leafs, workingSet, sort, isLast) => {
+const nodeChildrenToRows = (root, agg, leafs, workingSet, sort, _) => {
     const values = root.values();
     const rows = [];
     for (const v of values) {
@@ -57,7 +57,7 @@ const nodeChildrenToRows = (root, agg, leafs, workingSet, sort, isLast) => {
             rows.push(row);
         }
     }
-    if (!isLast && sort)
+    if (sort)
         return rows.sort(sort);
     return rows;
 };

package/dist/expressions/compiler/compile.d.ts

@@ -0,0 +1,3 @@
+import type { ASTNode } from "../parser/types.js";
+import type { Plugin } from "../plugin.js";
+export declare function compile(ast: ASTNode, plugins?: Plugin[]): ASTNode;

package/dist/expressions/compiler/compile.js

@@ -0,0 +1,4 @@
+import { optimize } from "./optimize.js";
+export function compile(ast, plugins) {
+    return optimize(ast, plugins);
+}

package/dist/expressions/compiler/eval-constant.d.ts

@@ -0,0 +1,2 @@
+import type { BinaryExpressionOperator } from "../lexer/types.js";
+export declare function evalConstant(op: BinaryExpressionOperator, left: unknown, right: unknown): unknown | undefined;

package/dist/expressions/compiler/eval-constant.js

@@ -0,0 +1,19 @@
+export function evalConstant(op, left, right) {
+    if (typeof left === "number" && typeof right === "number") {
+        switch (op) {
+            case "+":
+                return left + right;
+            case "-":
+                return left - right;
+            case "*":
+                return left * right;
+            case "/":
+                return left / right;
+            case "%":
+                return left % right;
+            case "**":
+                return left ** right;
+        }
+    }
+    return undefined;
+}

package/dist/expressions/compiler/is-constant.d.ts

@@ -0,0 +1,2 @@
+import type { ASTNode } from "../parser/types.js";
+export declare function isConstant(node: ASTNode): boolean;

package/dist/expressions/compiler/is-constant.js

@@ -0,0 +1,6 @@
+export function isConstant(node) {
+    return (node.type === "NumberLiteral" ||
+        node.type === "StringLiteral" ||
+        node.type === "BooleanLiteral" ||
+        node.type === "NullLiteral");
+}

package/dist/expressions/compiler/make-constant.d.ts

@@ -0,0 +1,2 @@
+import type { ASTNode } from "../parser/types.js";
+export declare function makeConstant(value: unknown, start: number, end: number): ASTNode;

package/dist/expressions/compiler/make-constant.js

@@ -0,0 +1,11 @@
+export function makeConstant(value, start, end) {
+    if (typeof value === "number")
+        return { type: "NumberLiteral", value, start, end };
+    if (typeof value === "string")
+        return { type: "StringLiteral", value, start, end };
+    if (typeof value === "boolean")
+        return { type: "BooleanLiteral", value, start, end };
+    if (value === null)
+        return { type: "NullLiteral", value: null, start, end };
+    return { type: "UndefinedLiteral", value: undefined, start, end };
+}

package/dist/expressions/compiler/optimize.d.ts

@@ -0,0 +1,3 @@
+import type { ASTNode } from "../parser/types.js";
+import type { Plugin } from "../plugin.js";
+export declare function optimize(node: ASTNode, plugins?: Plugin[]): ASTNode;

package/dist/expressions/compiler/optimize.js

@@ -0,0 +1,47 @@
+import { isConstant } from "./is-constant.js";
+import { valueOf } from "./value-of.js";
+import { evalConstant } from "./eval-constant.js";
+import { makeConstant } from "./make-constant.js";
+export function optimize(node, plugins) {
+    const opt = (n) => optimize(n, plugins);
+    // Try plugin optimization first
+    if (plugins) {
+        for (const plugin of plugins) {
+            if (plugin.optimize) {
+                const result = plugin.optimize(node, opt);
+                if (result)
+                    return result;
+            }
+        }
+    }
+    switch (node.type) {
+        case "BinaryExpression": {
+            const left = opt(node.left);
+            const right = opt(node.right);
+            if (isConstant(left) && isConstant(right)) {
+                const result = evalConstant(node.operator, valueOf(left), valueOf(right));
+                if (result !== undefined) {
+                    return makeConstant(result, node.start, node.end);
+                }
+            }
+            return { ...node, left, right };
+        }
+        case "UnaryExpression": {
+            const operand = opt(node.operand);
+            if (isConstant(operand)) {
+                const val = valueOf(operand);
+                if (node.operator === "-" && typeof val === "number") {
+                    return {
+                        type: "NumberLiteral",
+                        value: -val,
+                        start: node.start,
+                        end: node.end,
+                    };
+                }
+            }
+            return { ...node, operand };
+        }
+        default:
+            return node;
+    }
+}

package/dist/expressions/compiler/value-of.d.ts

@@ -0,0 +1,2 @@
+import type { ASTNode } from "../parser/types.js";
+export declare function valueOf(node: ASTNode): unknown;

package/dist/expressions/compiler/value-of.js

@@ -0,0 +1,11 @@
+export function valueOf(node) {
+    if (node.type === "NumberLiteral")
+        return node.value;
+    if (node.type === "StringLiteral")
+        return node.value;
+    if (node.type === "BooleanLiteral")
+        return node.value;
+    if (node.type === "NullLiteral")
+        return null;
+    return undefined;
+}

package/dist/expressions/errors/clamp-offset.d.ts

@@ -0,0 +1 @@
+export declare function clampOffset(source: string, offset: number): number;

package/dist/expressions/errors/clamp-offset.js

@@ -0,0 +1,3 @@
+export function clampOffset(source, offset) {
+    return Math.max(0, Math.min(offset, source.length));
+}

package/dist/expressions/errors/expression-error.d.ts

@@ -0,0 +1,10 @@
+import type { ErrorLocation } from "./types.js";
+/** Syntax error thrown during parsing. Contains source location and formatted caret display. */
+export declare class ExpressionError extends Error {
+    readonly rawMessage: string;
+    readonly start: number;
+    readonly end: number;
+    readonly source: string;
+    readonly suggestion?: string;
+    constructor(message: string, location: ErrorLocation, suggestion?: string);
+}

package/dist/expressions/errors/expression-error.js

@@ -0,0 +1,19 @@
+import { formatError } from "./format-error.js";
+/** Syntax error thrown during parsing. Contains source location and formatted caret display. */
+export class ExpressionError extends Error {
+    rawMessage;
+    start;
+    end;
+    source;
+    suggestion;
+    constructor(message, location, suggestion) {
+        const formatted = formatError(message, location, suggestion);
+        super(formatted);
+        this.name = "ExpressionError";
+        this.rawMessage = message;
+        this.start = location.start;
+        this.end = location.end;
+        this.source = location.source;
+        this.suggestion = suggestion;
+    }
+}

package/dist/expressions/errors/format-error.d.ts

@@ -0,0 +1,3 @@
+import type { ErrorLocation } from "./types.js";
+/** Format an error message with source context, caret display, and position info. */
+export declare function formatError(message: string, location: ErrorLocation, suggestion?: string): string;

package/dist/expressions/errors/format-error.js

@@ -0,0 +1,27 @@
+import { clampOffset } from "./clamp-offset.js";
+import { getLineStart } from "./get-line-start.js";
+import { getLineEnd } from "./get-line-end.js";
+import { offsetToPosition } from "./offset-to-position.js";
+/** Format an error message with source context, caret display, and position info. */
+export function formatError(message, location, suggestion) {
+    const { source } = location;
+    const start = clampOffset(source, location.start);
+    const rawEnd = clampOffset(source, location.end);
+    const end = Math.max(start + 1, rawEnd);
+    const startPos = offsetToPosition(source, start);
+    const lineStart = getLineStart(source, start);
+    const lineEnd = getLineEnd(source, start);
+    const lineText = source.slice(lineStart, lineEnd);
+    const caretStart = start - lineStart;
+    const caretEnd = Math.min(end, lineEnd);
+    const caretLength = Math.max(1, caretEnd - start);
+    const gutter = `${startPos.line} | `;
+    const padding = " ".repeat(gutter.length + caretStart);
+    const carets = "^".repeat(caretLength);
+    let result = `${message}\n\n${gutter}${lineText}\n${padding}${carets}`;
+    if (suggestion) {
+        result += ` Did you mean "${suggestion}"?`;
+    }
+    result += `\n\nat line ${startPos.line}, column ${startPos.column} (offset ${start}-${end})`;
+    return result;
+}

package/dist/expressions/errors/get-line-end.d.ts

@@ -0,0 +1 @@
+export declare function getLineEnd(source: string, offset: number): number;

package/dist/expressions/errors/get-line-end.js

@@ -0,0 +1,8 @@
+import { clampOffset } from "./clamp-offset.js";
+const NEWLINE_CODE = 10;
+export function getLineEnd(source, offset) {
+    let index = clampOffset(source, offset);
+    while (index < source.length && source.charCodeAt(index) !== NEWLINE_CODE)
+        index++;
+    return index;
+}

package/dist/expressions/errors/get-line-start.d.ts

@@ -0,0 +1 @@
+export declare function getLineStart(source: string, offset: number): number;

package/dist/expressions/errors/get-line-start.js

@@ -0,0 +1,8 @@
+import { clampOffset } from "./clamp-offset.js";
+const NEWLINE_CODE = 10;
+export function getLineStart(source, offset) {
+    let index = clampOffset(source, offset);
+    while (index > 0 && source.charCodeAt(index - 1) !== NEWLINE_CODE)
+        index--;
+    return index;
+}

package/dist/expressions/errors/index.d.ts

@@ -0,0 +1,7 @@
+export type { SourcePosition, ErrorLocation } from "./types.js";
+export { clampOffset } from "./clamp-offset.js";
+export { getLineStart } from "./get-line-start.js";
+export { getLineEnd } from "./get-line-end.js";
+export { offsetToPosition } from "./offset-to-position.js";
+export { formatError } from "./format-error.js";
+export { ExpressionError } from "./expression-error.js";

package/dist/expressions/errors/index.js

@@ -0,0 +1,6 @@
+export { clampOffset } from "./clamp-offset.js";
+export { getLineStart } from "./get-line-start.js";
+export { getLineEnd } from "./get-line-end.js";
+export { offsetToPosition } from "./offset-to-position.js";
+export { formatError } from "./format-error.js";
+export { ExpressionError } from "./expression-error.js";

package/dist/expressions/errors/offset-to-position.d.ts

@@ -0,0 +1,2 @@
+import type { SourcePosition } from "./types.js";
+export declare function offsetToPosition(source: string, offset: number): SourcePosition;

package/dist/expressions/errors/offset-to-position.js

@@ -0,0 +1,17 @@
+import { clampOffset } from "./clamp-offset.js";
+const NEWLINE_CODE = 10;
+export function offsetToPosition(source, offset) {
+    const safeOffset = clampOffset(source, offset);
+    let line = 1;
+    let column = 1;
+    for (let index = 0; index < safeOffset; index++) {
+        if (source.charCodeAt(index) === NEWLINE_CODE) {
+            line++;
+            column = 1;
+        }
+        else {
+            column++;
+        }
+    }
+    return { line, column, offset: safeOffset };
+}

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

@@ -0,0 +1,10 @@
+export interface SourcePosition {
+    line: number;
+    column: number;
+    offset: number;
+}
+export interface ErrorLocation {
+    source: string;
+    start: number;
+    end: number;
+}

package/dist/expressions/errors/types.js

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

package/dist/expressions/evaluator/evaluate-binary.d.ts

@@ -0,0 +1,4 @@
+import type { BinaryExpression } from "../parser/types.js";
+import type { Plugin } from "../plugin.js";
+import type { RunOptions } from "./evaluate.js";
+export declare function evaluateBinary(node: BinaryExpression, context: Record<string, unknown>, depth: number, plugins?: Plugin[], options?: RunOptions): unknown;

package/dist/expressions/evaluator/evaluate-binary.js

@@ -0,0 +1,21 @@
+import { evaluateNode } from "./evaluate.js";
+export function evaluateBinary(node, context, depth, plugins, options) {
+    const left = evaluateNode(node.left, context, depth + 1, plugins, options);
+    const right = evaluateNode(node.right, context, depth + 1, plugins, options);
+    switch (node.operator) {
+        case "+":
+            return left + right;
+        case "-":
+            return left - right;
+        case "*":
+            return left * right;
+        case "/":
+            return left / right;
+        case "%":
+            return left % right;
+        case "**":
+            return left ** right;
+        default:
+            throw new Error(`Unknown binary operator: ${node.operator}`);
+    }
+}

package/dist/expressions/evaluator/evaluate-unary.d.ts

@@ -0,0 +1,2 @@
+import type { UnaryOperator } from "../lexer/types.js";
+export declare function evaluateUnary(operator: UnaryOperator, operand: unknown): unknown;

package/dist/expressions/evaluator/evaluate-unary.js

@@ -0,0 +1,10 @@
+export function evaluateUnary(operator, operand) {
+    switch (operator) {
+        case "-":
+            return -operand;
+        case "+":
+            return +operand;
+        default:
+            throw new Error(`Unknown unary operator: ${operator}`);
+    }
+}

package/dist/expressions/evaluator/evaluate.d.ts

@@ -0,0 +1,15 @@
+import type { ASTNode } from "../parser/types.js";
+import type { Token } from "../lexer/types.js";
+import type { Plugin } from "../plugin.js";
+export interface RunOptions {
+    undefinedIdentifierFallback?: unknown;
+}
+export declare class Evaluator {
+    private plugins?;
+    constructor(plugins?: Plugin[]);
+    run: (input: string | ASTNode, context?: Record<string, unknown>, options?: RunOptions) => unknown;
+    ast: (input: string) => ASTNode;
+    tokens: (input: string, tokensizeWhitespace?: boolean) => Token[];
+    tokensSafe: (input: string, tokensizeWhitespace?: boolean) => Token[];
+}
+export declare function evaluateNode(node: ASTNode, context: Record<string, unknown>, depth: number, plugins?: Plugin[], options?: RunOptions): unknown;

package/dist/expressions/evaluator/evaluate.js

@@ -0,0 +1,62 @@
+import { parse } from "../parser/parse.js";
+import { compile } from "../compiler/compile.js";
+import { tokenize, tokenizeSafe } from "../lexer/tokenize/tokenize.js";
+import { evaluateBinary } from "./evaluate-binary.js";
+import { evaluateUnary } from "./evaluate-unary.js";
+const MAX_DEPTH = 1000;
+export class Evaluator {
+    plugins;
+    constructor(plugins) {
+        this.plugins = plugins;
+    }
+    run = (input, context = {}, options) => {
+        const node = typeof input === "string" ? compile(parse(input, 0, this.plugins), this.plugins) : input;
+        return evaluateNode(node, context, 0, this.plugins, options);
+    };
+    ast = (input) => {
+        return compile(parse(input, 0, this.plugins), this.plugins);
+    };
+    tokens = (input, tokensizeWhitespace) => {
+        return tokenize(input, this.plugins, tokensizeWhitespace);
+    };
+    tokensSafe = (input, tokensizeWhitespace) => {
+        return tokenizeSafe(input, this.plugins, tokensizeWhitespace);
+    };
+}
+export function evaluateNode(node, context, depth, plugins, options) {
+    if (depth > MAX_DEPTH) {
+        throw new Error("Maximum evaluation depth exceeded");
+    }
+    // Try plugin evaluation first
+    if (plugins) {
+        const evalFn = (n, ctx) => evaluateNode(n, ctx, depth + 1, plugins, options);
+        for (const plugin of plugins) {
+            if (plugin.evaluate) {
+                const result = plugin.evaluate(node, context, evalFn);
+                if (result !== null)
+                    return result.value;
+            }
+        }
+    }
+    // Core built-in evaluation
+    switch (node.type) {
+        case "NumberLiteral":
+            return node.value;
+        case "Identifier": {
+            if (!(node.name in context)) {
+                if (options && "undefinedIdentifierFallback" in options)
+                    return options.undefinedIdentifierFallback;
+                throw new Error(`Identifier "${node.name}" is not defined`);
+            }
+            return context[node.name];
+        }
+        case "BinaryExpression":
+            return evaluateBinary(node, context, depth, plugins, options);
+        case "UnaryExpression":
+            return evaluateUnary(node.operator, evaluateNode(node.operand, context, depth + 1, plugins, options));
+        case "SpreadElement":
+            throw new Error("Unexpected spread element outside of array literal");
+        default:
+            throw new Error(`Unknown node type: ${node.type}`);
+    }
+}

package/dist/expressions/index.d.ts

@@ -0,0 +1,5 @@
+export { Evaluator } from "./evaluator/evaluate.js";
+export type { Plugin, EvalFn } from "./plugin.js";
+export type { Token } from "./lexer/types.js";
+export { accessPlugin, arrowsPlugin, booleansPlugin, collectionsPlugin, comparisonPlugin, logicalPlugin, membershipPlugin, pipePlugin, standardPlugins, stringsPlugin, ternaryPlugin, } from "./plugins/standard.js";
+export { createResolvedIdentifierPlugin } from "./plugins/resolved-identifier.js";