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

package/dist/components/expressions-editor/intellisence/use-completions.d.ts

@@ -0,0 +1,14 @@
+import type { CompletionItem, WordAtCursor } from "../types.js";
+import type { Token } from "../../../expressions/lexer/types.js";
+export declare function useCompletions(completionProvider?: (tokens: Token[], cursorPosition: number) => CompletionItem[] | Promise<CompletionItem[]>): {
+    selectedItem: CompletionItem | null;
+    fetchCompletions: (tokens: Token[], cursorPosition: number, word: WordAtCursor) => Promise<void>;
+    updateFilter: (prefix: string) => void;
+    navigate: (direction: "up" | "down") => void;
+    dismiss: () => void;
+    items: CompletionItem[];
+    filteredItems: CompletionItem[];
+    selectedIndex: number;
+    isOpen: boolean;
+    isLoading: boolean;
+};

package/dist/components/expressions-editor/intellisence/use-completions.js

@@ -0,0 +1,78 @@
+import { useState, useCallback, useRef } from "react";
+import { filterCompletionsByPrefix } from "./filter-completions-by-prefix.js";
+export function useCompletions(completionProvider) {
+    const [state, setState] = useState({
+        items: [],
+        filteredItems: [],
+        selectedIndex: 0,
+        isOpen: false,
+        isLoading: false,
+    });
+    const requestIdRef = useRef(0);
+    const fetchCompletions = useCallback(async (tokens, cursorPosition, word) => {
+        if (!completionProvider)
+            return;
+        const requestId = ++requestIdRef.current;
+        setState((prev) => ({ ...prev, isLoading: true, isOpen: true }));
+        try {
+            const result = await Promise.resolve(completionProvider(tokens, cursorPosition));
+            if (requestId !== requestIdRef.current)
+                return;
+            const filtered = filterCompletionsByPrefix(result, word.word);
+            setState({
+                items: result,
+                filteredItems: filtered,
+                selectedIndex: 0,
+                isOpen: filtered.length > 0,
+                isLoading: false,
+            });
+        }
+        catch {
+            if (requestId !== requestIdRef.current)
+                return;
+            setState((prev) => ({
+                ...prev,
+                isOpen: false,
+                isLoading: false,
+            }));
+        }
+    }, [completionProvider]);
+    const updateFilter = useCallback((prefix) => {
+        setState((prev) => {
+            const filtered = filterCompletionsByPrefix(prev.items, prefix);
+            return {
+                ...prev,
+                filteredItems: filtered,
+                selectedIndex: 0,
+                isOpen: filtered.length > 0,
+            };
+        });
+    }, []);
+    const navigate = useCallback((direction) => {
+        setState((prev) => {
+            if (prev.filteredItems.length === 0)
+                return prev;
+            const delta = direction === "down" ? 1 : -1;
+            const count = prev.filteredItems.length;
+            const nextIndex = (prev.selectedIndex + delta + count) % count;
+            return { ...prev, selectedIndex: nextIndex };
+        });
+    }, []);
+    const dismiss = useCallback(() => {
+        setState((prev) => ({
+            ...prev,
+            isOpen: false,
+            isLoading: false,
+            selectedIndex: 0,
+        }));
+    }, []);
+    const selectedItem = state.isOpen && state.filteredItems.length > 0 ? state.filteredItems[state.selectedIndex] : null;
+    return {
+        ...state,
+        selectedItem,
+        fetchCompletions,
+        updateFilter,
+        navigate,
+        dismiss,
+    };
+}

package/dist/components/expressions-editor/replace-word-at-cursor.d.ts

@@ -0,0 +1,5 @@
+import type { WordAtCursor } from "./types.js";
+export declare function replaceWordAtCursor(text: string, wordRange: WordAtCursor, replacement: string): {
+    value: string;
+    cursorPosition: number;
+};

package/dist/components/expressions-editor/replace-word-at-cursor.js

@@ -0,0 +1,7 @@
+export function replaceWordAtCursor(text, wordRange, replacement) {
+    const before = text.substring(0, wordRange.start);
+    const after = text.substring(wordRange.end);
+    const value = before + replacement + after;
+    const cursorPosition = wordRange.start + replacement.length;
+    return { value, cursorPosition };
+}

package/dist/components/expressions-editor/token-highlighter-default.d.ts

@@ -0,0 +1,4 @@
+import type { Token } from "../../expressions/lexer/types.js";
+export declare function DefaultTokenHighlighter({ token }: {
+    token: Token;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/components/expressions-editor/token-highlighter-default.js

@@ -0,0 +1,20 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+const tokenToSyntaxColor = {
+    Number: "number",
+    String: "string",
+    TemplateLiteral: "string",
+    DateLiteral: "date",
+    Spread: "operator",
+    Punctuation: "operator",
+    Pipe: "operator",
+    Operator: "operator",
+    Arrow: "operator",
+    Identifier: "identifier",
+    QuotedIdentifier: "identifier",
+    ExpressionError: "error",
+    Unparsed: "punctuation",
+};
+export function DefaultTokenHighlighter({ token }) {
+    const expr = tokenToSyntaxColor[token.type];
+    return _jsx("span", { style: { color: `var(--ln-expr-${expr})` }, children: token.value });
+}

package/dist/components/expressions-editor/types.d.ts

@@ -0,0 +1,48 @@
+import type { CSSProperties, ReactNode } from "react";
+import type { Token } from "../../expressions/lexer/types.js";
+export type CompletionItem = {
+    label: string;
+    kind: string;
+    id: string;
+    value?: string;
+};
+export type KeybindingConfig = {
+    accept?: string[];
+    dismiss?: string[];
+    navigateUp?: string[];
+    navigateDown?: string[];
+};
+export type CompletionAction = {
+    type: "navigate";
+    direction: "up" | "down";
+} | {
+    type: "accept";
+} | {
+    type: "dismiss";
+} | {
+    type: "none";
+};
+export type WordAtCursor = {
+    word: string;
+    start: number;
+    end: number;
+};
+export type CursorCoordinates = {
+    top: number;
+    left: number;
+    lineHeight: number;
+};
+export type ExpressionEditorProps = {
+    value: string;
+    onChange: (value: string) => void;
+    tokenize: (value: string) => Token[];
+    highlight?: (props: {
+        token: Token;
+    }) => ReactNode;
+    completionProvider?: (tokens: Token[], index: number) => CompletionItem[] | Promise<CompletionItem[]>;
+    placeholder?: string;
+    disabled?: boolean;
+    readOnly?: boolean;
+    className?: string;
+    style?: CSSProperties;
+};

package/dist/components/expressions-editor/types.js

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

package/dist/components/expressions-editor/use-keyboard-navigation.d.ts

@@ -0,0 +1,10 @@
+import type { CompletionItem, WordAtCursor } from "./types";
+interface NavigationDeps {
+    readonly onValueChange: (value: string) => void;
+    readonly onAccepted: (value: string, cursorPosition: number) => void;
+    readonly textareaRef: React.RefObject<HTMLTextAreaElement | null>;
+}
+export declare function useKeyboardNavigation({ onValueChange, onAccepted, textareaRef }: NavigationDeps): {
+    acceptCompletion: (item: CompletionItem, word: WordAtCursor) => void;
+};
+export {};

package/dist/components/expressions-editor/use-keyboard-navigation.js

@@ -0,0 +1,37 @@
+import { useCallback } from "react";
+import { replaceWordAtCursor } from "./replace-word-at-cursor.js";
+export function useKeyboardNavigation({ onValueChange, onAccepted, textareaRef }) {
+    const acceptCompletion = useCallback((item, word) => {
+        const textarea = textareaRef.current;
+        if (!textarea)
+            return;
+        // Extend the replacement range to consume any @"..." / @'...' prefix the user already typed.
+        // The partial word may contain spaces (e.g. @"Age Gr → word is "Gr"), so scan backwards
+        // through word chars and spaces to find the opening @" / @'.
+        let adjustedWord = word;
+        const text = textarea.value;
+        let scan = word.start - 1;
+        // skip back over any chars that could be part of a quoted identifier value (spaces included)
+        while (scan > 0 && text[scan] !== '"' && text[scan] !== "'")
+            scan--;
+        if (scan >= 1 && (text[scan] === '"' || text[scan] === "'") && text[scan - 1] === "@") {
+            adjustedWord = { ...word, start: scan - 1 };
+        }
+        const charBeforeWord = adjustedWord.start > 0 ? text[adjustedWord.start - 1] : "";
+        const noSpaceBefore = charBeforeWord === "" ||
+            charBeforeWord === " " ||
+            charBeforeWord === "." ||
+            charBeforeWord === "(" ||
+            charBeforeWord === "[" ||
+            charBeforeWord === "{";
+        const rawInsertText = item.value ?? item.label;
+        const insertText = noSpaceBefore ? rawInsertText : " " + rawInsertText;
+        const { value, cursorPosition } = replaceWordAtCursor(text, adjustedWord, insertText);
+        textarea.value = value;
+        textarea.selectionStart = cursorPosition;
+        textarea.selectionEnd = cursorPosition;
+        onValueChange(value);
+        onAccepted(value, cursorPosition);
+    }, [onValueChange, onAccepted, textareaRef]);
+    return { acceptCompletion };
+}

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;