@shipfox/react-ui 0.29.0 → 0.31.0

package/dist/components/code-block/code-content.js

@@ -18,10 +18,13 @@ export function CodeContent({ code, highlightedCode, isLoading, syntaxHighlighti
         ...props,
         children: /*#__PURE__*/ _jsx("code", {
             className: cn('w-full overflow-x-auto bg-transparent font-code text-xs leading-20 text-foreground-neutral-base', 'grid', lineNumbers && '[counter-reset:line] [counter-increment:line_0] [&_.line]:before:content-[counter(line)] [&_.line]:before:inline-block [&_.line]:before:[counter-increment:line] [&_.line]:before:w-16 [&_.line]:before:mr-16 [&_.line]:before:text-xs [&_.line]:before:text-right [&_.line]:before:text-foreground-neutral-subtle [&_.line]:before:font-code [&_.line]:before:select-none'),
-            children: lines.map((line, index)=>/*#__PURE__*/ _jsx("span", {
+            children: lines.map((line, index)=>{
+                const key = `${index}-${line}`;
+                return /*#__PURE__*/ _jsx("span", {
                     className: "line px-12 w-full relative font-code text-xs leading-20",
                     children: line
-                }, `${index}-${line}`))
+                }, key);
+            })
         })
     });
 }

package/dist/components/dashboard/components/kpi-card.js

@@ -48,12 +48,12 @@ export function KpiCardsGroup({ cards, className, ...props }) {
         ...props,
         children: /*#__PURE__*/ _jsx("div", {
             className: "flex gap-16 pl-0 w-full",
-            children: cards.map((card, index)=>{
+            children: cards.map((card)=>{
                 const { key: _key, ...cardProps } = card;
                 return /*#__PURE__*/ _jsx(KpiCard, {
                     ...cardProps,
                     className: cn('shrink-0 w-[calc((100vw-56px)/2)] snap-start md:flex-1 md:w-0', card.className)
-                }, `${card.label}-${index}`);
+                }, card.label);
             })
         })
     });

package/dist/components/shipql-editor/index.d.ts

@@ -1,3 +1,3 @@
 export type { LeafAstNode } from './lexical/shipql-leaf-node';
-export * from './shipql-editor';
+export { type FacetDef, type LeafChangePayload, type RangeFacetConfig, ShipQLEditor, type ShipQLEditorProps, } from './shipql-editor';
 //# sourceMappingURL=index.d.ts.map

package/dist/components/shipql-editor/index.js

@@ -1,3 +1,3 @@
-export * from './shipql-editor.js';
+export { ShipQLEditor } from './shipql-editor.js';
 
 //# sourceMappingURL=index.js.map

package/dist/components/shipql-editor/lexical/leaf-close-overlay.js

@@ -1,8 +1,8 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext';
+import { Button } from '../../../components/button/index.js';
 import { useCallback, useEffect, useRef, useState } from 'react';
 import { cn } from '../../../utils/cn.js';
-import { Button } from '../../button/button.js';
 import { REMOVE_LEAF_COMMAND } from './shipql-plugin.js';
 const LEAF_ACTIVE_CLASSES = 'ring-1 ring-border-highlights-interactive rounded-r-none';
 export function LeafCloseOverlay() {
@@ -14,6 +14,7 @@ export function LeafCloseOverlay() {
         left: 0
     });
     const activeLeafElRef = useRef(null);
+    const keyboardNavigatingRef = useRef(false);
     const activateLeaf = useCallback((el)=>{
         if (activeLeafElRef.current && activeLeafElRef.current !== el) {
             for (const cls of LEAF_ACTIVE_CLASSES.split(' ')){
@@ -38,6 +39,7 @@ export function LeafCloseOverlay() {
     }, []);
     const handleMouseOver = useCallback((e)=>{
         if (containerRef.current?.contains(e.target)) return;
+        if (keyboardNavigatingRef.current) return;
         const target = e.target.closest('[data-shipql-leaf]');
         if (target) {
             const key = target.getAttribute('data-shipql-key');
@@ -71,16 +73,77 @@ export function LeafCloseOverlay() {
         if (!rootElement) return;
         const container = rootElement.closest('[data-shipql-editor]');
         const target = container ?? rootElement;
+        const NAV_KEYS = new Set([
+            'ArrowUp',
+            'ArrowDown',
+            'ArrowLeft',
+            'ArrowRight',
+            'Home',
+            'End'
+        ]);
+        const setLeafPointerEvents = (enabled)=>{
+            const leaves = Array.from(target.querySelectorAll('[data-shipql-leaf]'));
+            for (const leaf of leaves){
+                leaf.style.pointerEvents = enabled ? '' : 'none';
+            }
+        };
+        const handleKeyDown = (e)=>{
+            if (NAV_KEYS.has(e.key)) {
+                keyboardNavigatingRef.current = true;
+                activateLeaf(null);
+                setHovered(null);
+                setLeafPointerEvents(false);
+            }
+        };
+        const handleMouseMove = ()=>{
+            if (!keyboardNavigatingRef.current) return;
+            keyboardNavigatingRef.current = false;
+            setLeafPointerEvents(true);
+        };
         target.addEventListener('mouseover', handleMouseOver);
         target.addEventListener('mouseleave', handleMouseLeave);
+        target.addEventListener('keydown', handleKeyDown);
+        target.addEventListener('mousemove', handleMouseMove);
         return ()=>{
             target.removeEventListener('mouseover', handleMouseOver);
             target.removeEventListener('mouseleave', handleMouseLeave);
+            target.removeEventListener('keydown', handleKeyDown);
+            target.removeEventListener('mousemove', handleMouseMove);
         };
     }, [
         editor,
         handleMouseOver,
-        handleMouseLeave
+        handleMouseLeave,
+        activateLeaf
+    ]);
+    // Recompute button position on every editor update so it tracks the leaf's
+    // right edge even when characters are added/removed (changing its width).
+    // Deferred to rAF so we read layout after the browser has painted the new DOM.
+    useEffect(()=>{
+        let rafId = 0;
+        const unregister = editor.registerUpdateListener(()=>{
+            if (keyboardNavigatingRef.current) return;
+            cancelAnimationFrame(rafId);
+            rafId = requestAnimationFrame(()=>{
+                const el = activeLeafElRef.current;
+                if (!el) return;
+                const pos = resolvePosition(el.getBoundingClientRect());
+                if (!pos) return;
+                lastPosRef.current = pos;
+                const key = el.getAttribute('data-shipql-key');
+                if (key) setHovered({
+                    key,
+                    ...pos
+                });
+            });
+        });
+        return ()=>{
+            cancelAnimationFrame(rafId);
+            unregister();
+        };
+    }, [
+        editor,
+        resolvePosition
     ]);
     const { top, left } = hovered ?? lastPosRef.current;
     return /*#__PURE__*/ _jsx("div", {

package/dist/components/shipql-editor/lexical/shipql-plugin.js

@@ -117,11 +117,20 @@ export function ShipQLPlugin({ onLeafFocus }) {
             editor.update(()=>{
                 const para = $getRoot().getFirstChild();
                 if (!para) return;
-                // Find the leaf node's source text from its key.
+                // Find the leaf node's source text from its key. When a plain
+                // TextNode sits immediately after the leaf (no leading space) the
+                // parser treats them as one token — e.g. [Leaf("status:"), Text("s")]
+                // parses as "status:s". Include that trailing fragment so
+                // removeBySource can match the full AST source.
                 let targetSource = null;
                 for (const child of para.getChildren()){
                     if ($isShipQLLeafNode(child) && child.getKey() === nodeKey) {
                         targetSource = child.getTextContent();
+                        const next = child.getNextSibling();
+                        if (next && $isTextNode(next) && !$isShipQLLeafNode(next)) {
+                            const trailing = next.getTextContent().split(' ')[0];
+                            if (trailing) targetSource += trailing;
+                        }
                         break;
                     }
                 }

package/dist/components/shipql-editor/shipql-editor-inner.d.ts

@@ -1,3 +1,3 @@
 import type { ShipQLEditorInnerProps } from './shipql-editor';
-export default function ShipQLEditorInner({ onChange, onLeafFocus, placeholder, className, disabled, mode, text, editorKey, isError, onTextChange, onClear, onToggleMode, }: ShipQLEditorInnerProps): import("react/jsx-runtime").JSX.Element;
+export default function ShipQLEditorInner({ onChange, onLeafFocus, placeholder, className, disabled, mode, text, editorKey, isError, onTextChange, onClear, onToggleMode, facets, currentFacet, setCurrentFacet, valueSuggestions, isLoadingValueSuggestions, onLeafChange, }: ShipQLEditorInnerProps): import("react/jsx-runtime").JSX.Element;
 //# sourceMappingURL=shipql-editor-inner.d.ts.map

package/dist/components/shipql-editor/shipql-editor-inner.js

@@ -5,7 +5,9 @@ import { LexicalErrorBoundary } from '@lexical/react/LexicalErrorBoundary';
 import { HistoryPlugin } from '@lexical/react/LexicalHistoryPlugin';
 import { PlainTextPlugin } from '@lexical/react/LexicalPlainTextPlugin';
 import { Input } from '../../components/input/index.js';
+import { Popover, PopoverAnchor } from '../../components/popover/index.js';
 import { $createParagraphNode, $createTextNode, $getRoot } from 'lexical';
+import { useCallback, useRef, useState } from 'react';
 import { cn } from '../../utils/cn.js';
 import { Icon } from '../icon/icon.js';
 import { LeafCloseOverlay } from './lexical/leaf-close-overlay.js';
@@ -13,61 +15,166 @@ import { OnBlurPlugin } from './lexical/on-blur-plugin.js';
 import { OnTextChangePlugin } from './lexical/on-text-change-plugin.js';
 import { ShipQLLeafNode } from './lexical/shipql-leaf-node.js';
 import { ShipQLPlugin } from './lexical/shipql-plugin.js';
-const INPUT_CLASSES = 'block w-full rounded-6 bg-background-field-base py-2 pl-7 pr-58 sm:pr-64 text-md text-foreground-neutral-base caret-foreground-neutral-base outline-none focus:border-border-highlights-interactive shadow-button-neutral';
+import { detectFacetContext, normalizeFacets, tryParse } from './suggestions/generate-suggestions.js';
+import { ShipQLSuggestionsDropdown } from './suggestions/shipql-suggestions-dropdown.js';
+import { ShipQLSuggestionsPlugin } from './suggestions/shipql-suggestions-plugin.js';
+const INPUT_CLASSES = 'block w-full rounded-6 bg-background-field-base py-2 pl-32 pr-58 sm:pr-64 text-md text-foreground-neutral-base caret-foreground-neutral-base outline-none focus:border-border-highlights-interactive shadow-button-neutral';
 const INPUT_ERROR_CLASSES = 'shadow-border-error';
 const BUTTON_CLASSES = 'shrink-0 text-foreground-neutral-subtle hover:text-foreground-neutral-base transition-all duration-150 flex justify-center items-center cursor-pointer w-28 sm:w-32 h-full';
-export default function ShipQLEditorInner({ onChange, onLeafFocus, placeholder, className, disabled, mode, text, editorKey, isError, onTextChange, onClear, onToggleMode }) {
+export default function ShipQLEditorInner({ onChange, onLeafFocus, placeholder, className, disabled, mode, text, editorKey, isError, onTextChange, onClear, onToggleMode, facets, currentFacet, setCurrentFacet, valueSuggestions, isLoadingValueSuggestions, onLeafChange }) {
+    const [suggestionsOpen, setSuggestionsOpen] = useState(false);
+    const [selectedIndex, setSelectedIndex] = useState(-1);
+    const [items, setItems] = useState([]);
+    const [focusedLeafNode, setFocusedLeafNode] = useState(null);
+    const [isNegated, setIsNegated] = useState(false);
+    const [showSyntaxHelp, setShowSyntaxHelp] = useState(false);
+    const isSelectingRef = useRef(false);
+    const applyRef = useRef(null);
+    const negationPrefixRef = useRef('');
+    const hasSuggestions = Boolean(facets && facets.length > 0);
+    const showValueActions = Boolean(currentFacet);
+    const isRangeContext = items.length === 1 && items[0]?.type === 'range-slider';
+    const syntaxHintMode = isRangeContext ? 'range' : 'value';
+    const handleToggleNegate = useCallback((negated)=>{
+        setIsNegated(negated);
+        negationPrefixRef.current = negated ? '-' : '';
+    }, []);
+    const handleSetCurrentFacet = useCallback((facet)=>{
+        setCurrentFacet?.(facet);
+    }, [
+        setCurrentFacet
+    ]);
+    const handleLeafFocus = useCallback((node)=>{
+        setFocusedLeafNode(node);
+        onLeafFocus?.(node);
+    }, [
+        onLeafFocus
+    ]);
+    const handleSelect = useCallback((value)=>{
+        applyRef.current?.(value);
+    }, []);
+    const handleToggleSyntaxHelp = useCallback(()=>{
+        setShowSyntaxHelp((prev)=>!prev);
+    }, []);
     return /*#__PURE__*/ _jsxs("div", {
         "data-shipql-editor": true,
         className: cn('relative', className),
         children: [
-            mode === 'editor' ? /*#__PURE__*/ _jsxs(LexicalComposer, {
-                initialConfig: {
-                    namespace: 'ShipQLEditor',
-                    nodes: [
-                        ShipQLLeafNode
-                    ],
-                    onError: (error)=>{
-                        throw error;
-                    },
-                    editorState: text ? ()=>{
-                        const para = $createParagraphNode();
-                        para.append($createTextNode(text));
-                        $getRoot().append(para);
-                    } : undefined
-                },
+            mode === 'editor' ? /*#__PURE__*/ _jsxs(Popover, {
+                open: hasSuggestions && suggestionsOpen,
                 children: [
-                    /*#__PURE__*/ _jsx(PlainTextPlugin, {
-                        contentEditable: /*#__PURE__*/ _jsx(ContentEditable, {
-                            id: "shipql-editor",
-                            "aria-label": "ShipQL query editor",
-                            className: cn(INPUT_CLASSES, isError && INPUT_ERROR_CLASSES, disabled && 'pointer-events-none opacity-50')
-                        }),
-                        placeholder: placeholder ? /*#__PURE__*/ _jsx("div", {
-                            className: "pointer-events-none absolute left-0 top-0 select-none px-7 py-2 text-md text-foreground-neutral-muted",
-                            children: placeholder
-                        }) : null,
-                        ErrorBoundary: LexicalErrorBoundary
-                    }),
-                    /*#__PURE__*/ _jsx(ShipQLPlugin, {
-                        onLeafFocus: onLeafFocus
-                    }),
-                    /*#__PURE__*/ _jsx(OnBlurPlugin, {
-                        onChange: onChange
+                    /*#__PURE__*/ _jsx(PopoverAnchor, {
+                        className: "w-full",
+                        children: /*#__PURE__*/ _jsxs(LexicalComposer, {
+                            initialConfig: {
+                                namespace: 'ShipQLEditor',
+                                nodes: [
+                                    ShipQLLeafNode
+                                ],
+                                onError: (error)=>{
+                                    throw error;
+                                },
+                                editorState: text ? ()=>{
+                                    const para = $createParagraphNode();
+                                    para.append($createTextNode(text));
+                                    $getRoot().append(para);
+                                } : undefined
+                            },
+                            children: [
+                                /*#__PURE__*/ _jsx(PlainTextPlugin, {
+                                    contentEditable: /*#__PURE__*/ _jsxs("div", {
+                                        className: "relative",
+                                        children: [
+                                            /*#__PURE__*/ _jsx("div", {
+                                                className: "absolute left-0 top-4 select-none px-8 py-2 text-md text-foreground-neutral-muted",
+                                                children: /*#__PURE__*/ _jsx(Icon, {
+                                                    name: isLoadingValueSuggestions ? 'spinner' : 'searchLine',
+                                                    size: 16,
+                                                    className: "shrink-0 text-foreground-neutral-muted"
+                                                })
+                                            }),
+                                            /*#__PURE__*/ _jsx(ContentEditable, {
+                                                id: "shipql-editor",
+                                                "aria-label": "ShipQL query editor",
+                                                className: cn(INPUT_CLASSES, isError && INPUT_ERROR_CLASSES, disabled && 'pointer-events-none opacity-50')
+                                            })
+                                        ]
+                                    }),
+                                    placeholder: placeholder ? /*#__PURE__*/ _jsx("div", {
+                                        className: "pointer-events-none absolute left-0 top-0 select-none pl-32 pr-8 py-2 text-md text-foreground-neutral-muted",
+                                        children: placeholder
+                                    }) : null,
+                                    ErrorBoundary: LexicalErrorBoundary
+                                }),
+                                /*#__PURE__*/ _jsx(ShipQLPlugin, {
+                                    onLeafFocus: handleLeafFocus
+                                }),
+                                /*#__PURE__*/ _jsx(OnBlurPlugin, {
+                                    onChange: onChange
+                                }),
+                                /*#__PURE__*/ _jsx(OnTextChangePlugin, {
+                                    onTextChange: onTextChange
+                                }),
+                                /*#__PURE__*/ _jsx(HistoryPlugin, {}),
+                                !disabled && /*#__PURE__*/ _jsx(LeafCloseOverlay, {}),
+                                hasSuggestions && /*#__PURE__*/ _jsx(ShipQLSuggestionsPlugin, {
+                                    facets: facets ?? [],
+                                    currentFacet: currentFacet ?? null,
+                                    setCurrentFacet: handleSetCurrentFacet,
+                                    valueSuggestions: valueSuggestions ?? [],
+                                    isLoadingValueSuggestions: isLoadingValueSuggestions ?? false,
+                                    open: suggestionsOpen,
+                                    setOpen: setSuggestionsOpen,
+                                    selectedIndex: selectedIndex,
+                                    setSelectedIndex: setSelectedIndex,
+                                    items: items,
+                                    setItems: setItems,
+                                    isSelectingRef: isSelectingRef,
+                                    applyRef: applyRef,
+                                    negationPrefixRef: negationPrefixRef,
+                                    focusedLeafNode: focusedLeafNode,
+                                    onLeafChange: onLeafChange
+                                })
+                            ]
+                        }, editorKey)
                     }),
-                    /*#__PURE__*/ _jsx(OnTextChangePlugin, {
-                        onTextChange: onTextChange
-                    }),
-                    /*#__PURE__*/ _jsx(HistoryPlugin, {}),
-                    !disabled && /*#__PURE__*/ _jsx(LeafCloseOverlay, {})
+                    hasSuggestions && /*#__PURE__*/ _jsx(ShipQLSuggestionsDropdown, {
+                        items: items,
+                        selectedIndex: selectedIndex,
+                        isSelectingRef: isSelectingRef,
+                        onSelect: handleSelect,
+                        isLoading: isLoadingValueSuggestions,
+                        isNegated: isNegated,
+                        onToggleNegate: handleToggleNegate,
+                        showValueActions: showValueActions,
+                        showSyntaxHelp: showSyntaxHelp,
+                        onToggleSyntaxHelp: handleToggleSyntaxHelp,
+                        isError: isError,
+                        syntaxHintMode: syntaxHintMode
+                    })
                 ]
-            }, editorKey) : /*#__PURE__*/ _jsx(Input, {
+            }) : /*#__PURE__*/ _jsx(Input, {
                 ref: (el)=>el?.focus(),
                 "aria-label": "ShipQL query editor",
+                iconLeft: /*#__PURE__*/ _jsx(Icon, {
+                    name: "searchLine",
+                    size: 16,
+                    className: "shrink-0 text-foreground-neutral-muted"
+                }),
                 className: cn(INPUT_CLASSES, disabled && 'pointer-events-none opacity-50'),
                 "aria-invalid": isError,
                 value: text,
-                onChange: (e)=>onTextChange(e.target.value),
+                onChange: (e)=>{
+                    const newText = e.target.value;
+                    onTextChange(newText);
+                    const facetNames = facets ? normalizeFacets(facets) : [];
+                    const facetCtx = detectFacetContext(newText, facetNames);
+                    setCurrentFacet?.(facetCtx?.facet ?? null);
+                    onLeafChange?.({
+                        partialValue: facetCtx?.partialValue ?? '',
+                        ast: tryParse(newText)
+                    });
+                },
                 placeholder: placeholder,
                 disabled: disabled
             }),

package/dist/components/shipql-editor/shipql-editor.d.ts

@@ -1,5 +1,11 @@
 import type { AstNode } from '@shipfox/shipql-parser';
 import type { LeafAstNode } from './lexical/shipql-leaf-node';
+import type { FacetDef } from './suggestions/types';
+export type { FacetDef, RangeFacetConfig } from './suggestions/types';
+export type LeafChangePayload = {
+    partialValue: string;
+    ast: AstNode | null;
+};
 export interface ShipQLEditorProps {
     defaultValue?: string;
     onChange?: (ast: AstNode) => void;
@@ -7,6 +13,12 @@ export interface ShipQLEditorProps {
     placeholder?: string;
     className?: string;
     disabled?: boolean;
+    facets?: FacetDef[];
+    currentFacet?: string | null;
+    setCurrentFacet?: (facet: string | null) => void;
+    valueSuggestions?: string[];
+    isLoadingValueSuggestions?: boolean;
+    onLeafChange?: (payload: LeafChangePayload) => void;
 }
 export interface ShipQLEditorInnerProps extends ShipQLEditorProps {
     mode: 'editor' | 'text';

package/dist/components/shipql-editor/shipql-editor.js

@@ -47,7 +47,7 @@ export function ShipQLEditor({ disabled, className, ...props }) {
     }, []);
     return /*#__PURE__*/ _jsx(Suspense, {
         fallback: /*#__PURE__*/ _jsx("div", {
-            className: cn('h-8 w-full animate-pulse rounded-6 bg-background-components-base', className)
+            className: cn('h-28 w-full animate-pulse rounded-6 bg-background-components-base', className)
         }),
         children: /*#__PURE__*/ _jsx(ShipQLEditorInner, {
             ...props,

package/dist/components/shipql-editor/suggestions/generate-suggestions.d.ts

@@ -0,0 +1,22 @@
+import { type AstNode } from '@shipfox/shipql-parser';
+import type { LeafAstNode } from '../lexical/shipql-leaf-node';
+import type { FacetDef, RangeFacetConfig, SuggestionItem } from './types';
+export declare function tryParse(text: string): AstNode | null;
+export declare function normalizeFacets(facets: FacetDef[]): string[];
+export declare function getFacetConfig(facets: FacetDef[], name: string): RangeFacetConfig | undefined;
+export declare function extractFacetFromLeaf(leaf: LeafAstNode): string | undefined;
+/** Extracts the negation prefix used in a `not` node's source (either 'NOT ' or '-'). */
+export declare function negationPrefixFromSource(source: string): string;
+/** Strips a leading NOT or - negation prefix from activeText and returns it. */
+export declare function stripNegationPrefix(activeText: string): {
+    prefix: string;
+    stripped: string;
+};
+export interface FacetContext {
+    facet: string;
+    partialValue: string;
+    negationPrefix: string;
+}
+export declare function detectFacetContext(activeText: string, facets: string[]): FacetContext | null;
+export declare function buildSuggestionItems(facets: FacetDef[], valueSuggestions: string[], activeText: string, focusedLeaf: LeafAstNode | null): SuggestionItem[];
+//# sourceMappingURL=generate-suggestions.d.ts.map

package/dist/components/shipql-editor/suggestions/generate-suggestions.js

@@ -0,0 +1,170 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { parse } from '@shipfox/shipql-parser';
+import { Icon } from '../../../components/icon/index.js';
+// ─── Parse helper ─────────────────────────────────────────────────────────────
+export function tryParse(text) {
+    try {
+        return parse(text);
+    } catch  {
+        return null;
+    }
+}
+// ─── Facet normalization ───────────────────────────────────────────────────────
+export function normalizeFacets(facets) {
+    return facets.map((f)=>typeof f === 'string' ? f : f.name);
+}
+export function getFacetConfig(facets, name) {
+    for (const f of facets){
+        if (typeof f !== 'string' && f.name.toLowerCase() === name.toLowerCase()) return f.config;
+    }
+    return undefined;
+}
+// ─── Leaf helpers ─────────────────────────────────────────────────────────────
+export function extractFacetFromLeaf(leaf) {
+    if (leaf.type === 'match') return leaf.facet;
+    if (leaf.type === 'range') return leaf.facet;
+    if (leaf.type === 'not') {
+        const inner = leaf.expr;
+        if (inner.type === 'match' || inner.type === 'range') return inner.facet;
+    }
+    return undefined;
+}
+function extractValueFromLeaf(leaf) {
+    if (leaf.type === 'match') return leaf.value;
+    if (leaf.type === 'not' && leaf.expr.type === 'match') return leaf.expr.value;
+    return undefined;
+}
+// ─── Negation prefix detection ────────────────────────────────────────────────
+const NOT_PREFIX_RE = /^(NOT\s+)(.*)/i;
+/** Extracts the negation prefix used in a `not` node's source (either 'NOT ' or '-'). */ export function negationPrefixFromSource(source) {
+    return source.trimStart().startsWith('-') ? '-' : 'NOT ';
+}
+/** Strips a leading NOT or - negation prefix from activeText and returns it. */ export function stripNegationPrefix(activeText) {
+    const notMatch = NOT_PREFIX_RE.exec(activeText);
+    if (notMatch) return {
+        prefix: 'NOT ',
+        stripped: notMatch[2] ?? ''
+    };
+    if (activeText.startsWith('-')) return {
+        prefix: '-',
+        stripped: activeText.slice(1)
+    };
+    return {
+        prefix: '',
+        stripped: activeText
+    };
+}
+export function detectFacetContext(activeText, facets) {
+    const { prefix, stripped } = stripNegationPrefix(activeText);
+    const colonIdx = stripped.indexOf(':');
+    if (colonIdx <= 0) return null;
+    const candidate = stripped.slice(0, colonIdx).trim().toLowerCase();
+    const facet = facets.find((f)=>f.toLowerCase() === candidate);
+    if (!facet) return null;
+    return {
+        facet,
+        partialValue: stripped.slice(colonIdx + 1),
+        negationPrefix: prefix
+    };
+}
+// ─── Suggestion builder ───────────────────────────────────────────────────────
+export function buildSuggestionItems(facets, valueSuggestions, activeText, focusedLeaf) {
+    const facetNames = normalizeFacets(facets);
+    const header = (label)=>({
+            value: `__header__${label}`,
+            label,
+            icon: null,
+            selected: false,
+            type: 'section-header'
+        });
+    // Focused leaf — show values with current value marked selected.
+    // Text-type leaves (bare words) are not facet:value matches, so fall through
+    // to facet filtering using the leaf's text as the partial query.
+    if (focusedLeaf && focusedLeaf.type !== 'text') {
+        const facetName = extractFacetFromLeaf(focusedLeaf) ?? '';
+        const rangeCfg = getFacetConfig(facets, facetName);
+        if (rangeCfg) {
+            return [
+                {
+                    value: `__range__${facetName}`,
+                    label: facetName,
+                    icon: null,
+                    selected: false,
+                    type: 'range-slider',
+                    rangeFacetConfig: rangeCfg,
+                    facetName
+                }
+            ];
+        }
+        const currentValue = extractValueFromLeaf(focusedLeaf);
+        if (valueSuggestions.length === 0) return [];
+        return [
+            header(facetName.toUpperCase()),
+            ...valueSuggestions.map((v)=>{
+                const selected = v === currentValue;
+                return {
+                    value: v,
+                    label: v,
+                    icon: /*#__PURE__*/ _jsx(Icon, {
+                        name: selected ? 'checkLine' : 'arrowRightLongFill',
+                        className: selected ? 'size-16 text-foreground-neutral-base' : 'size-16 text-foreground-neutral-subtle'
+                    }),
+                    selected
+                };
+            })
+        ];
+    }
+    const facetCtx = detectFacetContext(activeText, facetNames);
+    // Typing field:value — check for range-type facet first
+    if (facetCtx) {
+        const rangeCfg = getFacetConfig(facets, facetCtx.facet);
+        if (rangeCfg) {
+            return [
+                {
+                    value: `__range__${facetCtx.facet}`,
+                    label: facetCtx.facet,
+                    icon: null,
+                    selected: false,
+                    type: 'range-slider',
+                    rangeFacetConfig: rangeCfg,
+                    facetName: facetCtx.facet
+                }
+            ];
+        }
+        // Regular facet — show value suggestions (parent is responsible for filtering)
+        if (valueSuggestions.length === 0) return [];
+        return [
+            header(facetCtx.facet.toUpperCase()),
+            ...valueSuggestions.map((v)=>({
+                    value: v,
+                    label: v,
+                    icon: /*#__PURE__*/ _jsx(Icon, {
+                        name: "arrowRightLongFill",
+                        className: "size-16 text-foreground-neutral-subtle"
+                    }),
+                    selected: false
+                }))
+        ];
+    }
+    // Otherwise show filtered facets. When cursor is inside a bare-word text
+    // leaf chip, use that leaf's value as the filter term. Strip any NOT/- prefix
+    // before matching so "NOT sta" still suggests "status", "-sta" suggests "status", etc.
+    const rawPartial = focusedLeaf?.type === 'text' ? focusedLeaf.value : activeText;
+    const partial = stripNegationPrefix(rawPartial.trim()).stripped.toLowerCase();
+    const filtered = partial ? facetNames.filter((f)=>f.toLowerCase().includes(partial)) : facetNames;
+    if (filtered.length === 0) return [];
+    return [
+        header('TYPE'),
+        ...filtered.slice(0, 8).map((f)=>({
+                value: f,
+                label: f,
+                icon: /*#__PURE__*/ _jsx(Icon, {
+                    name: "searchLine",
+                    className: "size-16 text-foreground-neutral-subtle"
+                }),
+                selected: false
+            }))
+    ];
+}
+
+//# sourceMappingURL=generate-suggestions.js.map

package/dist/components/shipql-editor/suggestions/shipql-range-facet-panel.d.ts

@@ -0,0 +1,9 @@
+import type { RangeFacetConfig } from './types';
+export interface ShipQLRangeFacetPanelProps {
+    facetName: string;
+    config: RangeFacetConfig;
+    onApply: (value: string) => void;
+    isSelectingRef: React.RefObject<boolean>;
+}
+export declare function ShipQLRangeFacetPanel({ facetName, config, onApply, isSelectingRef, }: ShipQLRangeFacetPanelProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=shipql-range-facet-panel.d.ts.map