@seljs/editor 1.0.0

package/dist/completion/tree-context.js

@@ -0,0 +1,154 @@
+import { syntaxTree } from "@codemirror/language";
+/**
+ * Walk up the tree looking for a MemberExpression ancestor.
+ * A MemberExpression has two Identifier children (or child nodes) separated by ".".
+ * The dot position is: firstChild.to + 1 (the "." character is between them).
+ * We are in dot-access context when pos >= dotPos.
+ */
+const findDotAccess = (state, node, pos) => {
+    let current = node;
+    while (current) {
+        /*
+         * Stop at ArgList boundary — don't match outer MemberExpressions
+         * that wrap the entire call (e.g., `erc20.balanceOf(user)` at `user`)
+         */
+        if (current.name === "ArgList") {
+            break;
+        }
+        if (current.name === "MemberExpression" ||
+            current.name === "OptionalExpression") {
+            const firstChild = current.firstChild;
+            if (firstChild) {
+                /*
+                 * The dot is immediately after the first child
+                 * For MemberExpression: firstChild.to is where the "." starts
+                 * (the token "." is not a named node, it's between firstChild and secondChild)
+                 */
+                // position after "."
+                const dotPos = firstChild.to + 1;
+                if (pos >= dotPos) {
+                    const receiverText = state.doc.sliceString(current.from, firstChild.to);
+                    return {
+                        kind: "dot-access",
+                        receiverText,
+                        from: dotPos,
+                    };
+                }
+            }
+        }
+        current = current.parent;
+    }
+    return undefined;
+};
+/**
+ * Count commas in ArgList text that appear before pos.
+ * Commas are anonymous tokens not exposed as named children,
+ * so we scan the raw source text.
+ */
+const countCommasBefore = (argList, state, pos) => {
+    /*
+     * Only scan from the opening "(" up to pos
+     * skip "("
+     */
+    const open = argList.from + 1;
+    const end = Math.min(pos, argList.to);
+    const text = state.doc.sliceString(open, end);
+    let count = 0;
+    for (const ch of text) {
+        if (ch === ",") {
+            count++;
+        }
+    }
+    return count;
+};
+/**
+ * Extract function name and optional receiver name from a CallExpression node.
+ *
+ * Tree shapes:
+ *   foo(...)          → CallExpression > Identifier, ArgList
+ *   erc20.foo(...)    → CallExpression > MemberExpression(Identifier "erc20", Identifier "foo"), ArgList
+ */
+const extractCallInfo = (state, callExpr) => {
+    // The callee is everything before the ArgList (first child)
+    const callee = callExpr.firstChild;
+    if (!callee) {
+        return undefined;
+    }
+    if (callee.name === "Identifier") {
+        // Simple function call: foo(...)
+        return { functionName: state.doc.sliceString(callee.from, callee.to) };
+    }
+    if (callee.name === "MemberExpression") {
+        /*
+         * Method call: receiver.method(...)
+         * MemberExpression has two children: receiver and method name (Identifier)
+         */
+        const lastChild = callee.lastChild;
+        if (lastChild?.name === "Identifier") {
+            const functionName = state.doc.sliceString(lastChild.from, lastChild.to);
+            // Receiver is first child of MemberExpression
+            const receiverNode = callee.firstChild;
+            const receiverName = receiverNode?.name === "Identifier"
+                ? state.doc.sliceString(receiverNode.from, receiverNode.to)
+                : undefined;
+            return { functionName, receiverName };
+        }
+    }
+    return undefined;
+};
+const findWordStart = (state, pos) => {
+    const text = state.doc.sliceString(0, pos);
+    const match = /\w+$/.exec(text);
+    return match ? pos - match[0].length : pos;
+};
+/**
+ * Walk up the tree looking for an ArgList ancestor.
+ * When found, count commas before pos to get paramIndex,
+ * then extract function name and optional receiver from the CallExpression.
+ */
+const findCallArg = (state, node, pos) => {
+    let current = node;
+    while (current) {
+        if (current.name === "ArgList") {
+            const paramIndex = countCommasBefore(current, state, pos);
+            const callExpr = current.parent;
+            if (callExpr?.name === "CallExpression") {
+                const info = extractCallInfo(state, callExpr);
+                if (info) {
+                    return {
+                        kind: "call-arg",
+                        functionName: info.functionName,
+                        receiverName: info.receiverName,
+                        paramIndex,
+                        from: pos,
+                    };
+                }
+            }
+        }
+        current = current.parent;
+    }
+    return undefined;
+};
+/**
+ * Extract completion context from the Lezer syntax tree at the given position.
+ */
+export const getCompletionContext = (state, pos) => {
+    const tree = syntaxTree(state);
+    const node = tree.resolveInner(pos, -1);
+    /*
+     * Check for dot-access first: cursor is after a "." in a MemberExpression
+     * This must come before call-arg so that dot-access inside parentheses
+     * (e.g., `contract.method(contract.)`) is handled correctly.
+     */
+    const dotAccess = findDotAccess(state, node, pos);
+    if (dotAccess) {
+        return dotAccess;
+    }
+    // Check for call-arg: cursor is inside an ArgList
+    const callArg = findCallArg(state, node, pos);
+    if (callArg) {
+        return callArg;
+    }
+    // Default: top-level completion
+    return { kind: "top-level", from: findWordStart(state, pos) };
+};

package/dist/editor/create-editor.d.ts

@@ -0,0 +1,4 @@
+import { EditorView } from "@codemirror/view";
+import type { SELEditorConfig } from "./types";
+export declare function createSELEditor(config: SELEditorConfig): EditorView;
+//# sourceMappingURL=create-editor.d.ts.map

package/dist/editor/create-editor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-editor.d.ts","sourceRoot":"","sources":["../../src/editor/create-editor.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAI9C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAE/C,wBAAgB,eAAe,CAAC,MAAM,EAAE,eAAe,GAAG,UAAU,CAYnE"}

package/dist/editor/create-editor.js

@@ -0,0 +1,14 @@
+import { EditorState } from "@codemirror/state";
+import { EditorView } from "@codemirror/view";
+import { buildExtensions } from "./editor-config";
+export function createSELEditor(config) {
+    const extensions = buildExtensions(config);
+    const state = EditorState.create({
+        doc: config.value ?? "",
+        extensions,
+    });
+    return new EditorView({
+        state,
+        parent: config.parent,
+    });
+}

package/dist/editor/editor-config.d.ts

@@ -0,0 +1,4 @@
+import { type Extension } from "@codemirror/state";
+import type { SELEditorConfig } from "./types";
+export declare const buildExtensions: (config: SELEditorConfig) => Extension[];
+//# sourceMappingURL=editor-config.d.ts.map

package/dist/editor/editor-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"editor-config.d.ts","sourceRoot":"","sources":["../../src/editor/editor-config.ts"],"names":[],"mappings":"AAGA,OAAO,EAAe,KAAK,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAYhE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAE/C,eAAO,MAAM,eAAe,GAAI,QAAQ,eAAe,KAAG,SAAS,EAqElE,CAAC"}

package/dist/editor/editor-config.js

@@ -0,0 +1,64 @@
+import { closeBrackets, closeBracketsKeymap } from "@codemirror/autocomplete";
+import { defaultKeymap, history, historyKeymap } from "@codemirror/commands";
+import { bracketMatching } from "@codemirror/language";
+import { EditorState } from "@codemirror/state";
+import { EditorView, keymap, placeholder } from "@codemirror/view";
+import { celLanguageSupport } from "@seljs/cel-lezer";
+import { SELChecker, rules } from "@seljs/checker";
+import { selDarkTheme, selLightTheme } from "./theme";
+import { createTypeDisplay } from "./type-display";
+import { createSchemaCompletion } from "../completion/schema-completion";
+import { createSemanticHighlighter } from "../language/semantic-highlighter";
+import { createTokenizerConfig } from "../language/tokenizer-config";
+import { createSELLinter } from "../linting/sel-linter";
+export const buildExtensions = (config) => {
+    const checker = new SELChecker(config.schema, { rules: [...rules.builtIn] });
+    const extensions = [];
+    // Language support (includes syntax highlighting)
+    extensions.push(celLanguageSupport(config.dark));
+    extensions.push(bracketMatching());
+    // Semantic highlighting (schema-aware identifier coloring)
+    const tokenizerConfig = createTokenizerConfig(config.schema);
+    extensions.push(createSemanticHighlighter(tokenizerConfig, config.dark));
+    // Autocomplete (type-aware via checker)
+    extensions.push(createSchemaCompletion(config.schema, checker));
+    extensions.push(closeBrackets());
+    // Keybindings
+    extensions.push(keymap.of([...closeBracketsKeymap, ...defaultKeymap, ...historyKeymap]));
+    extensions.push(history());
+    // Theme
+    extensions.push(config.dark ? selDarkTheme : selLightTheme);
+    // Validation / linting (built-in checker used when no validate callback provided)
+    const validate = config.validate ??
+        ((expression) => checker.check(expression).diagnostics);
+    extensions.push(createSELLinter({
+        validate,
+        delay: config.validateDelay,
+    }));
+    // onChange listener
+    if (config.onChange) {
+        const onChange = config.onChange;
+        extensions.push(EditorView.updateListener.of((update) => {
+            if (update.docChanged) {
+                onChange(update.state.doc.toString());
+            }
+        }));
+    }
+    // Read-only
+    if (config.readOnly) {
+        extensions.push(EditorState.readOnly.of(true));
+    }
+    // Placeholder
+    if (config.placeholder) {
+        extensions.push(placeholder(config.placeholder));
+    }
+    // Type display panel
+    if (config.showType) {
+        extensions.push(createTypeDisplay(checker, config.dark ?? false));
+    }
+    // User-provided extensions (last, so they can override)
+    if (config.extensions) {
+        extensions.push(...config.extensions);
+    }
+    return extensions;
+};

package/dist/editor/index.d.ts

@@ -0,0 +1,6 @@
+export { createSELEditor } from "./create-editor";
+export { buildExtensions } from "./editor-config";
+export { selLightTheme, selDarkTheme } from "./theme";
+export type { SELEditorConfig } from "./types";
+export type { EditorView } from "@codemirror/view";
+//# sourceMappingURL=index.d.ts.map

package/dist/editor/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/editor/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AACtD,YAAY,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAC/C,YAAY,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/editor/index.js

@@ -0,0 +1,3 @@
+export { createSELEditor } from "./create-editor";
+export { buildExtensions } from "./editor-config";
+export { selLightTheme, selDarkTheme } from "./theme";

package/dist/editor/theme.d.ts

@@ -0,0 +1,3 @@
+export declare const selLightTheme: import("@codemirror/state").Extension;
+export declare const selDarkTheme: import("@codemirror/state").Extension;
+//# sourceMappingURL=theme.d.ts.map

package/dist/editor/theme.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"theme.d.ts","sourceRoot":"","sources":["../../src/editor/theme.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,aAAa,uCAoBxB,CAAC;AAEH,eAAO,MAAM,YAAY,uCAuBxB,CAAC"}

package/dist/editor/theme.js

@@ -0,0 +1,43 @@
+import { EditorView } from "@codemirror/view";
+export const selLightTheme = EditorView.theme({
+    "&": {
+        fontSize: "14px",
+        backgroundColor: "#ffffff",
+        color: "#1e1e1e",
+    },
+    ".cm-content": {
+        caretColor: "#000000",
+        fontFamily: "'JetBrains Mono', 'Fira Code', 'Consolas', monospace",
+        padding: "4px 0",
+    },
+    "&.cm-focused .cm-cursor": {
+        borderLeftColor: "#000000",
+    },
+    "&.cm-focused .cm-selectionBackground, .cm-selectionBackground": {
+        backgroundColor: "#d7d4f0",
+    },
+    ".cm-gutters": {
+        display: "none",
+    },
+});
+export const selDarkTheme = EditorView.theme({
+    "&": {
+        fontSize: "14px",
+        backgroundColor: "#1e1e1e",
+        color: "#d4d4d4",
+    },
+    ".cm-content": {
+        caretColor: "#ffffff",
+        fontFamily: "'JetBrains Mono', 'Fira Code', 'Consolas', monospace",
+        padding: "4px 0",
+    },
+    "&.cm-focused .cm-cursor": {
+        borderLeftColor: "#ffffff",
+    },
+    "&.cm-focused .cm-selectionBackground, .cm-selectionBackground": {
+        backgroundColor: "#264f78",
+    },
+    ".cm-gutters": {
+        display: "none",
+    },
+}, { dark: true });

package/dist/editor/type-display.d.ts

@@ -0,0 +1,4 @@
+import { type Extension } from "@codemirror/state";
+import type { SELChecker } from "@seljs/checker";
+export declare function createTypeDisplay(checker: SELChecker, dark: boolean): Extension;
+//# sourceMappingURL=type-display.d.ts.map

package/dist/editor/type-display.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-display.d.ts","sourceRoot":"","sources":["../../src/editor/type-display.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,SAAS,EAA2B,MAAM,mBAAmB,CAAC;AAG5E,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AA6DjD,wBAAgB,iBAAiB,CAChC,OAAO,EAAE,UAAU,EACnB,IAAI,EAAE,OAAO,GACX,SAAS,CA4BX"}

package/dist/editor/type-display.js

@@ -0,0 +1,75 @@
+import { StateEffect, StateField } from "@codemirror/state";
+import { EditorView, showPanel } from "@codemirror/view";
+const setType = StateEffect.define();
+const typeField = StateField.define({
+    create: () => null,
+    update(value, tr) {
+        for (const e of tr.effects) {
+            if (e.is(setType)) {
+                return e.value;
+            }
+        }
+        return value;
+    },
+});
+function createTypePanel(dark) {
+    return (view) => {
+        const dom = document.createElement("div");
+        dom.className = "sel-type-display";
+        dom.style.cssText = [
+            "display: flex",
+            "align-items: center",
+            "gap: 6px",
+            `padding: 3px 8px`,
+            "font-size: 12px",
+            `font-family: 'JetBrains Mono', 'Fira Code', 'Consolas', monospace`,
+            `color: ${dark ? "#9ca3af" : "#6b7280"}`,
+            `background: ${dark ? "#262626" : "#f9fafb"}`,
+            `border-top: 1px solid ${dark ? "#374151" : "#e5e7eb"}`,
+        ].join("; ");
+        const update = () => {
+            const type = view.state.field(typeField);
+            dom.textContent = "";
+            if (type) {
+                const label = document.createElement("span");
+                label.style.color = dark ? "#6b7280" : "#9ca3af";
+                label.textContent = "output";
+                const typeSpan = document.createElement("span");
+                typeSpan.style.color = dark ? "#93c5fd" : "#2563eb";
+                typeSpan.style.fontWeight = "500";
+                typeSpan.textContent = type;
+                dom.append(label, " ", typeSpan);
+            }
+        };
+        update();
+        return {
+            dom,
+            update: () => {
+                update();
+            },
+        };
+    };
+}
+export function createTypeDisplay(checker, dark) {
+    let debounceTimer;
+    const plugin = EditorView.updateListener.of((update) => {
+        if (!update.docChanged && !update.startState.field(typeField, false)) {
+            return;
+        }
+        if (debounceTimer) {
+            clearTimeout(debounceTimer);
+        }
+        debounceTimer = setTimeout(() => {
+            const doc = update.state.doc.toString().trim();
+            if (!doc) {
+                update.view.dispatch({ effects: setType.of(null) });
+                return;
+            }
+            const result = checker.check(doc);
+            update.view.dispatch({
+                effects: setType.of(result.valid ? (result.type ?? null) : null),
+            });
+        }, 200);
+    });
+    return [typeField, plugin, showPanel.of(createTypePanel(dark))];
+}

package/dist/editor/types.d.ts

@@ -0,0 +1,28 @@
+import type { SELDiagnostic } from "../linting/diagnostic-mapper";
+import type { Extension } from "@codemirror/state";
+import type { SELSchema } from "@seljs/schema";
+export interface SELEditorConfig {
+    /** Container element to mount into */
+    parent: HTMLElement;
+    /** Schema driving autocomplete and syntax highlighting */
+    schema: SELSchema;
+    /** Initial expression value */
+    value?: string;
+    /** Called on every expression change */
+    onChange?: (value: string) => void;
+    /** Validation function for error highlighting */
+    validate?: (expression: string) => SELDiagnostic[] | Promise<SELDiagnostic[]>;
+    /** Debounce delay for validation (default: 300ms) */
+    validateDelay?: number;
+    /** Dark mode */
+    dark?: boolean;
+    /** Whether the editor is read-only */
+    readOnly?: boolean;
+    /** Placeholder text */
+    placeholder?: string;
+    /** Show inferred output type below the editor */
+    showType?: boolean;
+    /** Additional CodeMirror extensions */
+    extensions?: Extension[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/editor/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/editor/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAClE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAE/C,MAAM,WAAW,eAAe;IAC/B,sCAAsC;IACtC,MAAM,EAAE,WAAW,CAAC;IAEpB,0DAA0D;IAC1D,MAAM,EAAE,SAAS,CAAC;IAElB,+BAA+B;IAC/B,KAAK,CAAC,EAAE,MAAM,CAAC;IAEf,wCAAwC;IACxC,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IAEnC,iDAAiD;IACjD,QAAQ,CAAC,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,aAAa,EAAE,GAAG,OAAO,CAAC,aAAa,EAAE,CAAC,CAAC;IAE9E,qDAAqD;IACrD,aAAa,CAAC,EAAE,MAAM,CAAC;IAEvB,gBAAgB;IAChB,IAAI,CAAC,EAAE,OAAO,CAAC;IAEf,sCAAsC;IACtC,QAAQ,CAAC,EAAE,OAAO,CAAC;IAEnB,uBAAuB;IACvB,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB,iDAAiD;IACjD,QAAQ,CAAC,EAAE,OAAO,CAAC;IAEnB,uCAAuC;IACvC,UAAU,CAAC,EAAE,SAAS,EAAE,CAAC;CACzB"}

package/dist/editor/types.js

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

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./language/index";
+export * from "./completion/index";
+export * from "./linting/index";
+export * from "./editor/index";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AACjC,cAAc,oBAAoB,CAAC;AACnC,cAAc,iBAAiB,CAAC;AAChC,cAAc,gBAAgB,CAAC"}

package/dist/index.js

@@ -0,0 +1,4 @@
+export * from "./language/index";
+export * from "./completion/index";
+export * from "./linting/index";
+export * from "./editor/index";

package/dist/language/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./tokenizer-config";
+//# sourceMappingURL=index.d.ts.map

package/dist/language/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/language/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC"}

package/dist/language/index.js

@@ -0,0 +1 @@
+export * from "./tokenizer-config";

package/dist/language/semantic-highlighter.d.ts

@@ -0,0 +1,4 @@
+import { type Extension } from "@codemirror/state";
+import type { TokenizerConfig } from "./tokenizer-config";
+export declare const createSemanticHighlighter: (config: TokenizerConfig, dark?: boolean) => Extension;
+//# sourceMappingURL=semantic-highlighter.d.ts.map

package/dist/language/semantic-highlighter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"semantic-highlighter.d.ts","sourceRoot":"","sources":["../../src/language/semantic-highlighter.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,SAAS,EAAmB,MAAM,mBAAmB,CAAC;AAQpE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AA0E1D,eAAO,MAAM,yBAAyB,GACrC,QAAQ,eAAe,EACvB,cAAY,KACV,SAgBF,CAAC"}

package/dist/language/semantic-highlighter.js

@@ -0,0 +1,76 @@
+import { syntaxTree } from "@codemirror/language";
+import { RangeSetBuilder } from "@codemirror/state";
+import { Decoration, ViewPlugin, } from "@codemirror/view";
+const LIGHT_COLORS = {
+    contract: "#00695c",
+    function: "#1565c0",
+    macro: "#6a1b9a",
+    variable: "#37474f",
+};
+const DARK_COLORS = {
+    contract: "#4db6ac",
+    function: "#64b5f6",
+    macro: "#ce93d8",
+    variable: "#b0bec5",
+};
+const createDecorations = (dark) => {
+    const colors = dark ? DARK_COLORS : LIGHT_COLORS;
+    return {
+        contract: Decoration.mark({
+            attributes: { style: `color: ${colors.contract}` },
+        }),
+        function: Decoration.mark({
+            attributes: { style: `color: ${colors.function}` },
+        }),
+        macro: Decoration.mark({ attributes: { style: `color: ${colors.macro}` } }),
+        variable: Decoration.mark({
+            attributes: { style: `color: ${colors.variable}` },
+        }),
+    };
+};
+const buildDecorations = (view, config, decos) => {
+    const builder = new RangeSetBuilder();
+    const tree = syntaxTree(view.state);
+    for (const { from, to } of view.visibleRanges) {
+        tree.iterate({
+            from,
+            to,
+            enter(node) {
+                if (node.name !== "Identifier") {
+                    return;
+                }
+                const name = view.state.doc.sliceString(node.from, node.to);
+                let deco;
+                if (config.contractNames.has(name)) {
+                    deco = decos.contract;
+                }
+                else if (config.functionNames.has(name)) {
+                    deco = decos.function;
+                }
+                else if (config.macroNames.has(name)) {
+                    deco = decos.macro;
+                }
+                else if (config.variableNames.has(name)) {
+                    deco = decos.variable;
+                }
+                if (deco) {
+                    builder.add(node.from, node.to, deco);
+                }
+            },
+        });
+    }
+    return builder.finish();
+};
+export const createSemanticHighlighter = function (config, dark = false) {
+    const decos = createDecorations(dark);
+    return ViewPlugin.define((view) => ({
+        decorations: buildDecorations(view, config, decos),
+        update(update) {
+            if (update.docChanged || update.viewportChanged) {
+                this.decorations = buildDecorations(update.view, config, decos);
+            }
+        },
+    }), {
+        decorations: (v) => v.decorations,
+    });
+};

package/dist/language/tokenizer-config.d.ts

@@ -0,0 +1,9 @@
+import type { SELSchema } from "@seljs/schema";
+export interface TokenizerConfig {
+    contractNames: Set<string>;
+    functionNames: Set<string>;
+    macroNames: Set<string>;
+    variableNames: Set<string>;
+}
+export declare const createTokenizerConfig: (schema: SELSchema) => TokenizerConfig;
+//# sourceMappingURL=tokenizer-config.d.ts.map

package/dist/language/tokenizer-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokenizer-config.d.ts","sourceRoot":"","sources":["../../src/language/tokenizer-config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAE/C,MAAM,WAAW,eAAe;IAC/B,aAAa,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAC3B,aAAa,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAC3B,UAAU,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACxB,aAAa,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;CAC3B;AAED,eAAO,MAAM,qBAAqB,GAAI,QAAQ,SAAS,KAAG,eAKxD,CAAC"}

package/dist/language/tokenizer-config.js

@@ -0,0 +1,6 @@
+export const createTokenizerConfig = (schema) => ({
+    contractNames: new Set(schema.contracts.map((c) => c.name)),
+    functionNames: new Set(schema.functions.map((f) => f.name)),
+    macroNames: new Set(schema.macros.map((m) => m.name)),
+    variableNames: new Set(schema.variables.map((v) => v.name)),
+});

package/dist/linting/diagnostic-mapper.d.ts

@@ -0,0 +1,28 @@
+import type { SELDiagnostic } from "@seljs/checker";
+interface CheckResult {
+    valid: boolean;
+    error?: Error;
+}
+/**
+ * Maps a TypeCheckResult-shaped object or a caught Error to SELDiagnostic[].
+ *
+ * Handles both failure modes from `@seljs/runtime`'s `env.check()`:
+ * 1. Returned result: `{ valid: false, error: TypeError }`
+ * 2. Thrown exception: `SELParseError` or `SELTypeError`
+ *
+ * Usage:
+ * ```ts
+ * const validate = (expression: string): SELDiagnostic[] => {
+ *   try {
+ *     const result = env.check(expression);
+ *     return mapCheckResult(result, expression.length);
+ *   } catch (error) {
+ *     return mapCheckResult(error as Error, expression.length);
+ *   }
+ * };
+ * ```
+ */
+declare const mapCheckResult: (resultOrError: CheckResult | Error, docLength: number) => SELDiagnostic[];
+export { mapCheckResult };
+export type { SELDiagnostic };
+//# sourceMappingURL=diagnostic-mapper.d.ts.map

package/dist/linting/diagnostic-mapper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diagnostic-mapper.d.ts","sourceRoot":"","sources":["../../src/linting/diagnostic-mapper.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAEpD,UAAU,WAAW;IACpB,KAAK,EAAE,OAAO,CAAC;IACf,KAAK,CAAC,EAAE,KAAK,CAAC;CACd;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,QAAA,MAAM,cAAc,GACnB,eAAe,WAAW,GAAG,KAAK,EAClC,WAAW,MAAM,KACf,aAAa,EA4Bf,CAAC;AAEF,OAAO,EAAE,cAAc,EAAE,CAAC;AAC1B,YAAY,EAAE,aAAa,EAAE,CAAC"}

package/dist/linting/diagnostic-mapper.js

@@ -0,0 +1,46 @@
+/**
+ * Maps a TypeCheckResult-shaped object or a caught Error to SELDiagnostic[].
+ *
+ * Handles both failure modes from `@seljs/runtime`'s `env.check()`:
+ * 1. Returned result: `{ valid: false, error: TypeError }`
+ * 2. Thrown exception: `SELParseError` or `SELTypeError`
+ *
+ * Usage:
+ * ```ts
+ * const validate = (expression: string): SELDiagnostic[] => {
+ *   try {
+ *     const result = env.check(expression);
+ *     return mapCheckResult(result, expression.length);
+ *   } catch (error) {
+ *     return mapCheckResult(error as Error, expression.length);
+ *   }
+ * };
+ * ```
+ */
+const mapCheckResult = (resultOrError, docLength) => {
+    // Thrown error path
+    if (resultOrError instanceof Error) {
+        return [
+            {
+                message: resultOrError.message,
+                severity: "error",
+                from: 0,
+                to: Math.max(0, docLength),
+            },
+        ];
+    }
+    // Returned result path
+    if (resultOrError.valid) {
+        return [];
+    }
+    const message = resultOrError.error?.message ?? "Invalid expression";
+    return [
+        {
+            message,
+            severity: "error",
+            from: 0,
+            to: Math.max(0, docLength),
+        },
+    ];
+};
+export { mapCheckResult };