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

package/README.md

@@ -35,7 +35,7 @@ to **LyteNyte Grid PRO** for advanced enterprise features and support.
 [![NPM Version](https://img.shields.io/npm/v/%401771technologies%2Flytenyte-core?label=Core&style=flat&logo=npm&logoColor=white)](https://www.npmjs.com/package/@1771technologies/lytenyte-core)
 [![GitHub branch status](https://img.shields.io/github/checks-status/1771-Technologies/lytenyte/main?style=flat&logo=github)](https://github.com/1771-Technologies/lytenyte/tree/main)
 [![GitHub Repo stars](https://img.shields.io/github/stars/1771-Technologies/lytenyte?style=flat&logo=github)](https://github.com/1771-Technologies/lytenyte)
-[![Contributor Covenant](https://img.shields.io/badge/Contributor%20Covenant-2.1-4baaaa?style=flat)](code_of_conduct.md)
+[![Contributor Covenant](https://img.shields.io/badge/Contributor%20Covenant-2.1-4baaaa?style=flat)](https://github.com/1771-Technologies/lytenyte/blob/main/CODE_OF_CONDUCT.md)
 [![CI Status](https://img.shields.io/github/actions/workflow/status/1771-Technologies/lytenyte/release.yml?branch=main&style=flat&label=CI&logo=github)](https://github.com/1771-Technologies/lytenyte/actions/workflows/release.yml?query=branch%3Amain)
 [![Follow on X](https://img.shields.io/twitter/follow/1771tech?label=follow+1771tech&style=social&logo=x&logoColor=black)](https://x.com/1771tech)
 [![LinkedIn](https://img.shields.io/badge/LinkedIn-Follow-0A66C2?style=flat&logo=linkedin&logoColor=white)](https://www.linkedin.com/company/1771technologies)
@@ -55,14 +55,34 @@ to **LyteNyte Grid PRO** for advanced enterprise features and support.
 
 LyteNyte Grid is available in two editions:
 
-1. **LyteNyte Grid Core: Free, open-source edition** for building high-performance data tables.
-   Includes sorting, filtering, editing, row selection, detail views, and more. Also includes advanced
-   features such as aggregation, row grouping, and data export, often locked behind paywalls in other grids.
+1. **LyteNyte Grid Core:** Free, **open-source edition** for building high-performance data tables. Includes sorting,
+   filtering, editing, row selection, detail views, and more. Also includes advanced features such
+   as aggregation, row grouping, and cell range selection, often locked behind paywalls in other grids.
 
-2. **LyteNyte Grid PRO: Commercial edition** that extends Core with powerful enterprise
-   features such as server-side data loading, pivoting, tree data, component managers,
-   and advanced filtering. Build custom menus, popovers and dialogs,
-   and workflow-driven UIs with ease.
+2. **LyteNyte Grid PRO: Commercial edition** that extends Core with powerful enterprise features,
+   including server-side data loading, pivoting, tree data, component managers, and advanced
+   filtering. Build custom menus, popovers, expressions, and workflow-driven UIs with ease.
+
+## AI-Enhanced Workflows
+
+**LyteNyte Grid AI Skills** are structured context files for Claude Code, Windsurf, Cursor, and other AI coding agents.
+Skills provide agents with accurate, curated context for LyteNyte Grid, allowing them to generate complex
+grid implementations with greater speed and reliability.
+
+Instead of building the grid manually, developers can describe the
+desired result and let the agent generate the implementation.
+
+**Install LyteNyte Grid AI Skills**
+
+```bash
+npx skills add 1771-Technologies/lytenyte
+```
+
+Once installed, the Skill activates automatically whenever you work on a LyteNyte Grid task. No
+special prompting is needed. Skills are actively maintained by the 1771 Technologies
+team and versioned alongside each LyteNyte Grid release.
+
+See our [AI Skills Overview guide](https://1771technologies.com/docs/ai-skills-overview) to learn more.
 
 ## Features
 
@@ -79,6 +99,16 @@ LyteNyte Grid is available in two editions:
 
 </details>
 
+<details>
+<summary><b>🤖&nbsp; AI Enhanced Workflows</b></summary>
+<br>
+
+| Feature                                                               | Core | PRO |
+| --------------------------------------------------------------------- | :--: | :-: |
+| [AI Skills](https://www.1771technologies.com/docs/ai-skills-overview) |  ✅  | ✅  |
+
+</details>
+
 <details>
 <summary><b>🔌&nbsp; API Extensions</b></summary>
 <br>
@@ -198,8 +228,8 @@ LyteNyte Grid is available in two editions:
 | &nbsp;&nbsp;&nbsp;↳ [Checkbox Row Selection](https://www.1771technologies.com/docs/row-selection#checkbox-selection)     |  ✅  | ✅  |
 | &nbsp;&nbsp;&nbsp;↳ [Isolated Row Selection](https://www.1771technologies.com/docs/row-selection#isolated-row-selection) |  ✅  | ✅  |
 | &nbsp;&nbsp;&nbsp;↳ [Linked Row Selection](https://www.1771technologies.com/docs/row-selection#linked-row-selection)     |  ✅  | ✅  |
-| [Cell Selection](https://www.1771technologies.com/docs/cell-selection#single-range-selection)                            |  —   | ✅  |
-| [Cell Range Selection](https://www.1771technologies.com/docs/cell-selection#multi-range-selection)                       |  —   | ✅  |
+| [Cell Selection](https://www.1771technologies.com/docs/cell-selection#single-range-selection)                            |  ✅  | ✅  |
+| [Cell Range Selection](https://www.1771technologies.com/docs/cell-selection#multi-range-selection)                       |  ✅  | ✅  |
 
 </details>
 
@@ -239,6 +269,19 @@ LyteNyte Grid is available in two editions:
 
 </details>
 
+<details>
+<summary><b>🧮&nbsp; Expressions</b> &nbsp;</summary>
+<br>
+
+| Feature                                                                          | Core | PRO |
+| -------------------------------------------------------------------------------- | :--: | :-: |
+| [Expressions Engine](https://www.1771technologies.com/docs/expressions-overview) |  —   | ✅  |
+| [Filter Expressions](https://www.1771technologies.com/docs/expression-filters)   |  —   | ✅  |
+| [Expression Editor](https://www.1771technologies.com/docs/expression-editor)     |  —   | ✅  |
+| [Expression Plugins](https://www.1771technologies.com/docs/expression-plugins)   |  —   | ✅  |
+
+</details>
+
 <details>
 <summary><b>📦&nbsp; Grouping & Aggregations</b></summary>
 <br>
@@ -377,7 +420,7 @@ npm install --save @1771technologies/lytenyte-pro
 
 > [!NOTE]
 > You can install and use LyteNyte Grid PRO
-> without license but a watermark will be displayed.
+> without a license, but a watermark will be displayed.
 
 **Core:**
 

package/css/components/expression-editor.css

@@ -0,0 +1,106 @@
+@layer ln-grid {
+  [data-ln-expression-editor] {
+    --ln-expr-number: light-dark(#b45309, #fab387);
+    --ln-expr-string: light-dark(#15803d, #a6e3a1);
+    --ln-expr-date: light-dark(#0e7490, #89dceb);
+    --ln-expr-keyword: light-dark(#7c3aed, #cba6f7);
+    --ln-expr-identifier: light-dark(#0369a1, #89b4fa);
+    --ln-expr-operator: light-dark(#be185d, #f38ba8);
+    --ln-expr-punctuation: light-dark(#6b7280, #6c7086);
+    --ln-expr-error: light-dark(#dc2626, #f38ba8);
+  }
+
+  /* These must be identical otherwise the highlight will not match the input. */
+  [data-ln-expression-editor] {
+    font-family:
+      ui-monospace, "Cascadia Code", "Segoe UI Mono", "Liberation Mono", Menlo, Monaco, Consolas, monospace;
+    font-size: var(--ln-font-sm);
+    white-space: nowrap;
+    word-break: normal;
+    overflow-wrap: normal;
+    tab-size: 2;
+    box-sizing: border-box;
+  }
+
+  [data-ln-expression-input] {
+    caret-color: var(--ln-text);
+    box-sizing: border-box;
+
+    transition-property: border-color;
+    transition-duration: var(--ln-transition-duration);
+    transition-timing-function: var(--ln-transition-fn);
+  }
+
+  /* Completion popover */
+  @keyframes ln-expr-popover-in {
+    from {
+      opacity: 0;
+      translate: 0 -4px;
+    }
+    to {
+      opacity: 1;
+      translate: 0 0;
+    }
+  }
+
+  [data-ln-expression-popover] {
+    background-color: var(--ln-bg-popover);
+    border: 1px solid var(--ln-border-popover);
+    border-radius: var(--ln-radius-md);
+    box-shadow: var(--ln-shadow-400);
+    padding: var(--ln-space-05);
+    min-width: 200px;
+    max-width: 360px;
+    box-sizing: border-box;
+    overflow: hidden;
+
+    &:popover-open {
+      animation: ln-expr-popover-in var(--ln-transition-duration) var(--ln-transition-fn) both;
+    }
+  }
+
+  [data-ln-expression-completion-list] {
+    list-style: none;
+    margin: 0;
+    padding: 0;
+    max-height: 220px;
+    overflow-y: auto;
+    overscroll-behavior: contain;
+
+    /* Thin scrollbar */
+    scrollbar-width: thin;
+    scrollbar-color: var(--ln-border-strong) transparent;
+  }
+
+  [data-ln-expression-completion-item] {
+    display: flex;
+    align-items: center;
+    gap: var(--ln-space-10);
+    padding-block: var(--ln-space-05);
+    padding-inline: var(--ln-space-10);
+    border-radius: var(--ln-radius);
+    font-family:
+      ui-monospace, "Cascadia Code", "Segoe UI Mono", "Liberation Mono", Menlo, Monaco, Consolas, monospace;
+    font-size: var(--ln-font-sm);
+    color: var(--ln-text);
+    cursor: pointer;
+    user-select: none;
+
+    transition-property: background-color, color;
+    transition-duration: var(--ln-transition-duration);
+    transition-timing-function: var(--ln-transition-fn);
+
+    &:hover {
+      background-color: var(--ln-bg-row-hover);
+    }
+
+    &[data-ln-selected] {
+      background-color: var(--ln-primary-10);
+      color: var(--ln-text-dark);
+
+      &:hover {
+        background-color: var(--ln-primary-10);
+      }
+    }
+  }
+}

package/dist/components/column-manager/column-manager.d.ts

@@ -9,5 +9,10 @@ export interface ColumnManagerProps<Spec extends GridSpec = GridSpec> {
         columns: Column<Spec>[];
         row: RowNode<Spec["data"]>;
     }) => ReactNode;
+    /**
+     * @alpha
+     * Use with caution.
+     */
+    readonly getPillManagerTag?: (column: Column<Spec>) => Record<string, string>;
 }
-export declare function ColumnManager<Spec extends GridSpec = GridSpec>({ columns: provided, base, onColumnsChange, endElement, }: ColumnManagerProps<Spec>): import("react/jsx-runtime").JSX.Element;
+export declare function ColumnManager<Spec extends GridSpec = GridSpec>({ columns: provided, base, onColumnsChange, endElement, getPillManagerTag, }: ColumnManagerProps<Spec>): import("react/jsx-runtime").JSX.Element;

package/dist/components/column-manager/column-manager.js

@@ -3,7 +3,7 @@ import { useMemo } from "react";
 import { TreeView } from "../tree-view/index.js";
 import { Checkbox } from "../checkbox/checkbox.js";
 import { computePathMatrix } from "@1771technologies/lytenyte-shared";
-export function ColumnManager({ columns: provided, base, onColumnsChange, endElement, }) {
+export function ColumnManager({ columns: provided, base, onColumnsChange, endElement, getPillManagerTag, }) {
     const nonAdjacentSplit = useMemo(() => {
         const paths = computePathMatrix(provided);
         const adjusted = [];
@@ -24,7 +24,28 @@ export function ColumnManager({ columns: provided, base, onColumnsChange, endEle
     const items = useMemo(() => {
         return nonAdjacentSplit.map((x) => ({ id: x.id, path: x.groupPath ?? [], name: x.name, column: x }));
     }, [nonAdjacentSplit]);
-    return (_jsx(TreeView, { items: items, rowSelectionEnabled: false, draggable: true, rowHeight: 30, rowSelectAllShow: false, defaultExpansion: true, onItemsReordered: (x) => {
+    const getDragItems = useMemo(() => {
+        if (!getPillManagerTag)
+            return undefined;
+        return (row, leafs) => {
+            if (leafs.length || row.kind !== "leaf")
+                return {};
+            const column = row.data.column;
+            const mapTags = Object.entries(getPillManagerTag(column));
+            if (!mapTags.length)
+                return {};
+            return {
+                pill: {
+                    kind: "site",
+                    data: {
+                        id: "__external__",
+                        item: Object.fromEntries(mapTags),
+                    },
+                },
+            };
+        };
+    }, [getPillManagerTag]);
+    return (_jsx(TreeView, { items: items, rowSelectionEnabled: false, draggable: true, rowHeight: 30, rowSelectAllShow: false, getDragTags: getDragItems, defaultExpansion: true, onItemsReordered: (x) => {
             const columns = x.map((x) => provided.find((p) => p.id === x.column.id));
             onColumnsChange(columns);
         }, children: ({ row, leafs, toggle, dragProps, isOver, isBefore }) => {

package/dist/components/expressions-editor/create-completion-provider.d.ts

@@ -0,0 +1,10 @@
+import type { Token } from "../../expressions/lexer/types.js";
+import type { CompletionItem } from "./types.js";
+export type ContextEntry = {
+    value: unknown;
+    type: "string" | "number" | "array" | "object" | "function" | "boolean" | "date";
+    return?: "string" | "number" | "array" | "object" | "date";
+};
+type CompletionContext = Record<string, ContextEntry>;
+export declare function createCompletionProvider(context: CompletionContext): (tokens: Token[], cursorPosition: number) => CompletionItem[];
+export {};

package/dist/components/expressions-editor/create-completion-provider.js

@@ -0,0 +1,391 @@
+const STRING_METHODS = [
+    { label: "at", kind: "function" },
+    { label: "charAt", kind: "function" },
+    { label: "charCodeAt", kind: "function" },
+    { label: "endsWith", kind: "function" },
+    { label: "includes", kind: "function" },
+    { label: "indexOf", kind: "function" },
+    { label: "lastIndexOf", kind: "function" },
+    { label: "length", kind: "number" },
+    { label: "match", kind: "function" },
+    { label: "padEnd", kind: "function" },
+    { label: "padStart", kind: "function" },
+    { label: "repeat", kind: "function" },
+    { label: "replace", kind: "function" },
+    { label: "replaceAll", kind: "function" },
+    { label: "slice", kind: "function" },
+    { label: "split", kind: "function" },
+    { label: "startsWith", kind: "function" },
+    { label: "substring", kind: "function" },
+    { label: "toLowerCase", kind: "function" },
+    { label: "toUpperCase", kind: "function" },
+    { label: "trim", kind: "function" },
+    { label: "trimEnd", kind: "function" },
+    { label: "trimStart", kind: "function" },
+];
+const ARRAY_METHODS = [
+    { label: "at", kind: "function" },
+    { label: "concat", kind: "function" },
+    { label: "entries", kind: "function" },
+    { label: "every", kind: "function" },
+    { label: "filter", kind: "function" },
+    { label: "find", kind: "function" },
+    { label: "findIndex", kind: "function" },
+    { label: "flat", kind: "function" },
+    { label: "flatMap", kind: "function" },
+    { label: "forEach", kind: "function" },
+    { label: "includes", kind: "function" },
+    { label: "indexOf", kind: "function" },
+    { label: "join", kind: "function" },
+    { label: "keys", kind: "function" },
+    { label: "length", kind: "number" },
+    { label: "map", kind: "function" },
+    { label: "reduce", kind: "function" },
+    { label: "reduceRight", kind: "function" },
+    { label: "reverse", kind: "function" },
+    { label: "slice", kind: "function" },
+    { label: "some", kind: "function" },
+    { label: "sort", kind: "function" },
+    { label: "values", kind: "function" },
+];
+const DATE_METHODS = [
+    { label: "getTime", kind: "function" },
+    { label: "toISOString", kind: "function" },
+];
+const NUMBER_METHODS = [
+    { label: "toExponential", kind: "function" },
+    { label: "toFixed", kind: "function" },
+    { label: "toLocaleString", kind: "function" },
+    { label: "toPrecision", kind: "function" },
+    { label: "toString", kind: "function" },
+    { label: "valueOf", kind: "function" },
+];
+function isDot(token) {
+    return (token.type === "Punctuation" && token.value === ".") || token.type === "OptionalChain";
+}
+function isClosingBracket(token) {
+    return token.type === "Punctuation" && token.value === "]";
+}
+function isCompleteValue(token) {
+    return (token.type === "Identifier" ||
+        token.type === "QuotedIdentifier" ||
+        token.type === "Number" ||
+        token.type === "String" ||
+        token.type === "TemplateLiteral" ||
+        (token.type === "Punctuation" && (token.value === ")" || token.value === "]")));
+}
+function isStringLiteral(token) {
+    return token.type === "String" || token.type === "TemplateLiteral";
+}
+const BINARY_OPERATORS = [
+    { label: "+  Plus", kind: "operator", value: "+" },
+    { label: "-  Minus", kind: "operator", value: "-" },
+    { label: "*  Multiply", kind: "operator", value: "*" },
+    { label: "/  Divide", kind: "operator", value: "/" },
+    { label: "%  Modulus", kind: "operator", value: "%" },
+    { label: "** Exponentiation", kind: "operator", value: "**" },
+    { label: "== Equal To", kind: "operator", value: "==" },
+    { label: "!= Not Equal To", kind: "operator", value: "!=" },
+    { label: "<  Less Than", kind: "operator", value: "<" },
+    { label: "<= Less Than Or Equal To", kind: "operator", value: "<=" },
+    { label: ">  Greater Than", kind: "operator", value: ">" },
+    { label: ">= Greater Than Or Equal To", kind: "operator", value: ">=" },
+    { label: "&& AND", kind: "operator", value: "&&" },
+    { label: "|| OR", kind: "operator", value: "||" },
+    { label: "?? OR if Null", kind: "operator", value: "??" },
+    { label: "|> Pipe", kind: "operator", value: "|>" },
+];
+const STRING_METHOD_RETURNS = {
+    at: "string",
+    charAt: "string",
+    charCodeAt: "number",
+    endsWith: "unknown",
+    includes: "unknown",
+    indexOf: "number",
+    lastIndexOf: "number",
+    match: "array",
+    padEnd: "string",
+    padStart: "string",
+    repeat: "string",
+    replace: "string",
+    replaceAll: "string",
+    slice: "string",
+    split: "array",
+    startsWith: "unknown",
+    substring: "string",
+    toLowerCase: "string",
+    toUpperCase: "string",
+    trim: "string",
+    trimEnd: "string",
+    trimStart: "string",
+};
+const ARRAY_METHOD_RETURNS = {
+    at: "unknown",
+    concat: "array",
+    entries: "unknown",
+    every: "unknown",
+    filter: "array",
+    find: "unknown",
+    findIndex: "number",
+    flat: "array",
+    flatMap: "array",
+    forEach: "unknown",
+    includes: "unknown",
+    indexOf: "number",
+    join: "string",
+    keys: "unknown",
+    map: "array",
+    reduce: "unknown",
+    reduceRight: "unknown",
+    reverse: "array",
+    slice: "array",
+    some: "unknown",
+    sort: "array",
+    values: "unknown",
+};
+const DATE_METHOD_RETURNS = {
+    getTime: "number",
+    toISOString: "string",
+};
+function kindOf(value) {
+    if (typeof value === "function")
+        return "function";
+    if (Array.isArray(value))
+        return "array";
+    if (typeof value === "string")
+        return "string";
+    if (typeof value === "number")
+        return "number";
+    if (typeof value === "boolean")
+        return "boolean";
+    if (typeof value === "object" && value !== null)
+        return "object";
+    return "unknown";
+}
+function isContextEntry(v) {
+    return v != null && typeof v === "object" && "type" in v && "value" in v;
+}
+function resolveEntry(context, path) {
+    if (path.length === 0)
+        return undefined;
+    let entry = context[path[0]];
+    for (let i = 1; i < path.length; i++) {
+        if (!entry || entry.value == null || typeof entry.value !== "object")
+            return undefined;
+        const nested = entry.value[path[i]];
+        if (isContextEntry(nested)) {
+            entry = nested;
+        }
+        else if (nested !== undefined) {
+            entry = { value: nested, type: kindOf(nested) };
+        }
+        else {
+            return undefined;
+        }
+    }
+    return entry;
+}
+function findMatchingOpenParen(relevant, closeIndex) {
+    let depth = 1;
+    let i = closeIndex - 1;
+    while (i >= 0) {
+        if (relevant[i].type === "Punctuation") {
+            if (relevant[i].value === ")")
+                depth++;
+            else if (relevant[i].value === "(") {
+                if (--depth === 0)
+                    return i;
+            }
+        }
+        i--;
+    }
+    return -1;
+}
+function buildPathFromTokens(relevant, i) {
+    const tokenName = (t) => (t.type === "QuotedIdentifier" ? t.value.slice(2, -1) : t.value);
+    const token = relevant[i];
+    if (!token || (token.type !== "Identifier" && token.type !== "QuotedIdentifier"))
+        return null;
+    const path = [tokenName(token)];
+    let j = i - 1;
+    while (j >= 1 && isDot(relevant[j])) {
+        j--;
+        if (relevant[j].type !== "Identifier" && relevant[j].type !== "QuotedIdentifier")
+            break;
+        path.unshift(tokenName(relevant[j]));
+        j--;
+    }
+    return path;
+}
+function resolveTypeOf(relevant, i, context) {
+    const token = relevant[i];
+    if (!token)
+        return "unknown";
+    if (token.type === "DateLiteral")
+        return "date";
+    if (isStringLiteral(token))
+        return "string";
+    if (isClosingBracket(token))
+        return "array";
+    if (token.type === "Punctuation" && token.value === ")") {
+        const openIdx = findMatchingOpenParen(relevant, i);
+        if (openIdx < 1)
+            return "unknown";
+        const methodToken = relevant[openIdx - 1];
+        if (methodToken?.type !== "Identifier")
+            return "unknown";
+        const hasDot = openIdx >= 2 && isDot(relevant[openIdx - 2]);
+        if (!hasDot) {
+            // Top-level function call: fn(...)
+            const funcEntry = context[methodToken.value];
+            if (funcEntry?.type === "function" && funcEntry.return)
+                return funcEntry.return;
+            return "unknown";
+        }
+        // Method call: receiver.method(...)
+        // First try resolving the receiver as a context object to find a typed method entry
+        const receiverPath = buildPathFromTokens(relevant, openIdx - 3);
+        if (receiverPath) {
+            const receiverEntry = resolveEntry(context, receiverPath);
+            if (receiverEntry?.type === "object" && receiverEntry.value != null) {
+                const methodVal = receiverEntry.value[methodToken.value];
+                const methodEntry = isContextEntry(methodVal) ? methodVal : undefined;
+                if (methodEntry?.type === "function" && methodEntry.return)
+                    return methodEntry.return;
+            }
+        }
+        // Fall back to builtin method return-type maps (string/array prototype methods)
+        const receiverType = resolveTypeOf(relevant, openIdx - 3, context);
+        if (receiverType === "string")
+            return STRING_METHOD_RETURNS[methodToken.value] ?? "unknown";
+        if (receiverType === "array")
+            return ARRAY_METHOD_RETURNS[methodToken.value] ?? "unknown";
+        if (receiverType === "date")
+            return DATE_METHOD_RETURNS[methodToken.value] ?? "unknown";
+        return "unknown";
+    }
+    if (token.type === "Identifier" || token.type === "QuotedIdentifier") {
+        const path = buildPathFromTokens(relevant, i);
+        if (!path)
+            return "unknown";
+        const entry = resolveEntry(context, path);
+        const kind = entry?.type ?? "unknown";
+        if (kind === "string" || kind === "number" || kind === "array" || kind === "object")
+            return kind;
+        return "unknown";
+    }
+    return "unknown";
+}
+function analyzeTokens(tokens, cursorPosition, context) {
+    const relevant = tokens.filter((t) => t.end <= cursorPosition && t.type !== "EOF" && t.type !== "Whitespace");
+    if (relevant.length === 0)
+        return { kind: "top-level" };
+    let i = relevant.length - 1;
+    // Skip the partial word the user is currently typing (only if cursor is at its end)
+    if (relevant[i].type === "Identifier" && relevant[i].end === cursorPosition)
+        i--;
+    if (i < 0)
+        return { kind: "top-level" };
+    // If the token before the word isn't a dot, check if it's a complete value
+    if (!isDot(relevant[i])) {
+        if (isCompleteValue(relevant[i]))
+            return { kind: "after-value" };
+        return { kind: "top-level" };
+    }
+    // Step over the dot
+    i--;
+    if (i < 0)
+        return { kind: "none" };
+    const beforeDot = relevant[i];
+    // "hello". or `hello`. → string methods
+    if (isStringLiteral(beforeDot))
+        return { kind: "string-literal" };
+    // [1,2,3]. → array methods
+    if (isClosingBracket(beforeDot))
+        return { kind: "array-literal" };
+    // d"2023-02-11". → date methods
+    if (beforeDot.type === "DateLiteral")
+        return { kind: "date-value" };
+    // fn(). → resolve call return type recursively
+    if (beforeDot.type === "Punctuation" && beforeDot.value === ")") {
+        const resultType = resolveTypeOf(relevant, i, context);
+        if (resultType === "string")
+            return { kind: "string-literal" };
+        if (resultType === "number")
+            return { kind: "number-value" };
+        if (resultType === "array")
+            return { kind: "array-literal" };
+        if (resultType === "date")
+            return { kind: "date-value" };
+        return { kind: "none" };
+    }
+    // identifier chain: walk back through alternating Identifier / QuotedIdentifier / dot tokens
+    if (beforeDot.type === "Identifier" || beforeDot.type === "QuotedIdentifier") {
+        const tokenName = (t) => (t.type === "QuotedIdentifier" ? t.value.slice(2, -1) : t.value);
+        const path = [tokenName(beforeDot)];
+        i--;
+        while (i >= 1) {
+            if (!isDot(relevant[i]))
+                break;
+            i--;
+            if (relevant[i].type !== "Identifier" && relevant[i].type !== "QuotedIdentifier")
+                break;
+            path.unshift(tokenName(relevant[i]));
+            i--;
+        }
+        return { kind: "context-path", path };
+    }
+    return { kind: "none" };
+}
+const VALID_IDENTIFIER = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
+function objectCompletions(obj) {
+    return Object.entries(obj).map(([key, val]) => ({
+        label: key,
+        kind: isContextEntry(val) ? val.type : kindOf(val),
+        id: key,
+        value: VALID_IDENTIFIER.test(key) ? undefined : `@"${key}"`,
+    }));
+}
+function builtinCompletions(methods) {
+    return methods.map((m) => ({ label: m.label, kind: m.kind, id: m.label, value: m.value }));
+}
+function binaryOperatorCompletions() {
+    return builtinCompletions(BINARY_OPERATORS);
+}
+export function createCompletionProvider(context) {
+    return function completionProvider(tokens, cursorPosition) {
+        const analysis = analyzeTokens(tokens, cursorPosition, context);
+        switch (analysis.kind) {
+            case "top-level":
+                return objectCompletions(context);
+            case "string-literal":
+                return builtinCompletions(STRING_METHODS);
+            case "number-value":
+                return builtinCompletions(NUMBER_METHODS);
+            case "date-value":
+                return builtinCompletions(DATE_METHODS);
+            case "array-literal":
+                return builtinCompletions(ARRAY_METHODS);
+            case "context-path": {
+                const entry = resolveEntry(context, analysis.path);
+                if (!entry)
+                    return [];
+                if (entry.type === "string")
+                    return builtinCompletions(STRING_METHODS);
+                if (entry.type === "number")
+                    return builtinCompletions(NUMBER_METHODS);
+                if (entry.type === "array")
+                    return builtinCompletions(ARRAY_METHODS);
+                if (entry.type === "date")
+                    return builtinCompletions(DATE_METHODS);
+                if (entry.type === "object" && entry.value != null && typeof entry.value === "object")
+                    return objectCompletions(entry.value);
+                return [];
+            }
+            case "after-value":
+                return binaryOperatorCompletions();
+            case "none":
+                return [];
+        }
+    };
+}