@seekora-ai/ui-sdk-react 0.0.0-stage-20260517092419

package/dist/docsearch/components/Results.js

@@ -0,0 +1,141 @@
+import React, { useEffect, useRef } from 'react';
+import { Hit } from './Hit';
+function getTypeLevel(type) {
+    if (!type)
+        return 1;
+    const match = type.match(/^lvl(\d+)$/);
+    return match ? parseInt(match[1], 10) : 1;
+}
+function isChildType(type) {
+    return getTypeLevel(type) >= 2;
+}
+/** Build a stable grouping key from all hierarchy levels (lvl0 through lvl5). */
+function getHierarchyKey(hit) {
+    const h = hit.hierarchy ?? {};
+    const parts = [
+        h.lvl0 ?? '',
+        h.lvl1 ?? '',
+        h.lvl2 ?? '',
+        h.lvl3 ?? '',
+        h.lvl4 ?? '',
+        h.lvl5 ?? '',
+    ];
+    return parts.join('\0');
+}
+/** Build a display breadcrumb from hierarchy, skipping consecutive duplicates (e.g. lvl0 === lvl1). */
+function getHierarchyBreadcrumb(hit) {
+    const h = hit.hierarchy ?? {};
+    const parts = [h.lvl0, h.lvl1, h.lvl2, h.lvl3, h.lvl4, h.lvl5].filter((v) => typeof v === 'string' && v.length > 0);
+    const deduped = [];
+    for (const p of parts) {
+        if (deduped[deduped.length - 1] !== p)
+            deduped.push(p);
+    }
+    return deduped.join(' › ');
+}
+function groupHitsByHierarchy(hits) {
+    const hitToIndex = new Map();
+    hits.forEach((h, i) => hitToIndex.set(h, i));
+    const groups = new Map();
+    for (const hit of hits) {
+        const key = getHierarchyKey(hit);
+        if (!groups.has(key))
+            groups.set(key, []);
+        groups.get(key).push(hit);
+    }
+    const entries = Array.from(groups.entries());
+    entries.sort(([, aHits], [, bHits]) => {
+        const aMin = Math.min(...aHits.map(h => hitToIndex.get(h) ?? 0));
+        const bMin = Math.min(...bHits.map(h => hitToIndex.get(h) ?? 0));
+        return aMin - bMin;
+    });
+    const result = [];
+    for (const [, groupHits] of entries) {
+        const sortedHits = [...groupHits].sort((a, b) => {
+            const aType = a.type;
+            const bType = b.type;
+            return getTypeLevel(aType) - getTypeLevel(bType);
+        });
+        const markedHits = sortedHits.map((hit, index) => {
+            const suggestion = hit;
+            const isChild = isChildType(suggestion.type);
+            const nextHit = sortedHits[index + 1];
+            const isLastChild = isChild && (!nextHit || !isChildType(nextHit.type));
+            return { ...hit, isChild, isLastChild };
+        });
+        const category = getHierarchyBreadcrumb(groupHits[0]);
+        result.push({ category: category || null, hits: markedHits });
+    }
+    return result;
+}
+function getGlobalIndexMulti(groups, groupIndex, hitIndex) {
+    let index = 0;
+    for (let i = 0; i < groupIndex; i++)
+        index += groups[i].hits.length;
+    return index + hitIndex;
+}
+function getHitKey(hit, index) {
+    if ('objectID' in hit)
+        return hit.objectID;
+    return `suggestion-${hit.url}-${index}`;
+}
+export function Results({ hits, groupedHits, selectedIndex, onSelect, onHover, scrollSelectionIntoViewRef, query, isLoading, error, translations = {}, sources: _sources = [], }) {
+    void _sources;
+    const listRef = useRef(null);
+    useEffect(() => {
+        if (!listRef.current || hits.length === 0)
+            return;
+        // Only scroll when selection changed via keyboard (avoids scroll-to-selected on hover)
+        if (scrollSelectionIntoViewRef && !scrollSelectionIntoViewRef.current)
+            return;
+        // listRef's direct children are groups (li.seekora-docsearch-results-group), not hits.
+        // Find the actual hit element at flat selectedIndex.
+        const groupEls = listRef.current.querySelectorAll('.seekora-docsearch-results-group');
+        let idx = 0;
+        for (const groupEl of groupEls) {
+            const itemList = groupEl.querySelector('.seekora-docsearch-results-group-items');
+            if (!itemList)
+                continue;
+            const items = itemList.children;
+            for (let i = 0; i < items.length; i++) {
+                if (idx === selectedIndex) {
+                    items[i].scrollIntoView({ block: 'nearest' });
+                    if (scrollSelectionIntoViewRef)
+                        scrollSelectionIntoViewRef.current = false;
+                    return;
+                }
+                idx++;
+            }
+        }
+        if (scrollSelectionIntoViewRef)
+            scrollSelectionIntoViewRef.current = false;
+    }, [selectedIndex, hits.length, scrollSelectionIntoViewRef]);
+    if (!query) {
+        return (React.createElement("div", { className: "seekora-docsearch-empty" },
+            React.createElement("p", { className: "seekora-docsearch-empty-text" }, translations.searchPlaceholder || 'Type to start searching...')));
+    }
+    if (isLoading && hits.length === 0) {
+        return React.createElement("div", { className: "seekora-docsearch-empty" });
+    }
+    // When loading with previous hits, fall through and show them (no loading screen)
+    if (error) {
+        return (React.createElement("div", { className: "seekora-docsearch-error" },
+            React.createElement("p", { className: "seekora-docsearch-error-text" }, translations.errorText || error)));
+    }
+    if (hits.length === 0 && query) {
+        return (React.createElement("div", { className: "seekora-docsearch-no-results" },
+            React.createElement("p", { className: "seekora-docsearch-no-results-text" }, translations.noResultsText || `No results found for "${query}"`)));
+    }
+    const displayGroups = groupedHits && groupedHits.length > 0
+        ? groupedHits.map(g => ({ category: g.source.name, sourceId: g.source.id, openInNewTab: g.source.openInNewTab, hits: g.items }))
+        : groupHitsByHierarchy(hits).map(g => ({ category: g.category, sourceId: 'default', openInNewTab: false, hits: g.hits }));
+    return (React.createElement("div", { className: "seekora-docsearch-results" },
+        React.createElement("ul", { ref: listRef, id: "seekora-docsearch-results", className: "seekora-docsearch-results-list", role: "listbox" }, displayGroups.map((group, groupIndex) => (React.createElement("li", { key: group.sourceId + '-' + groupIndex, className: "seekora-docsearch-results-group" },
+            group.category && React.createElement("div", { className: "seekora-docsearch-results-group-header" }, group.category),
+            React.createElement("ul", { className: "seekora-docsearch-results-group-items" }, group.hits.map((hit, hitIndex) => {
+                const globalIndex = getGlobalIndexMulti(displayGroups, groupIndex, hitIndex);
+                const extHit = hit;
+                return (React.createElement("li", { key: getHitKey(hit, hitIndex) },
+                    React.createElement(Hit, { hit: hit, isSelected: globalIndex === selectedIndex, onClick: () => onSelect(hit), onMouseEnter: () => onHover(globalIndex), openInNewTab: group.openInNewTab, isChild: extHit.isChild, isLastChild: extHit.isLastChild, hierarchyType: hit.type })));
+            }))))))));
+}

package/dist/docsearch/components/SearchBox.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+interface SearchBoxProps {
+    value: string;
+    onChange: (value: string) => void;
+    onKeyDown?: (event: React.KeyboardEvent) => void;
+    placeholder?: string;
+    onClear?: () => void;
+}
+export declare function SearchBox({ value, onChange, onKeyDown, placeholder, onClear, }: SearchBoxProps): React.JSX.Element;
+export {};
+//# sourceMappingURL=SearchBox.d.ts.map

package/dist/docsearch/components/SearchBox.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SearchBox.d.ts","sourceRoot":"","sources":["../../../src/docsearch/components/SearchBox.tsx"],"names":[],"mappings":"AAAA,OAAO,KAA4B,MAAM,OAAO,CAAC;AAEjD,UAAU,cAAc;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IAClC,SAAS,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,aAAa,KAAK,IAAI,CAAC;IACjD,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;CACtB;AAED,wBAAgB,SAAS,CAAC,EACxB,KAAK,EACL,QAAQ,EACR,SAAS,EACT,WAAuC,EACvC,OAAO,GACR,EAAE,cAAc,qBAuChB"}

package/dist/docsearch/components/SearchBox.js

@@ -0,0 +1,16 @@
+import React, { useEffect, useRef } from 'react';
+export function SearchBox({ value, onChange, onKeyDown, placeholder = 'Search documentation...', onClear, }) {
+    const inputRef = useRef(null);
+    useEffect(() => { if (inputRef.current)
+        inputRef.current.focus(); }, []);
+    const handleChange = (event) => onChange(event.target.value);
+    const handleClear = () => { onChange(''); onClear?.(); inputRef.current?.focus(); };
+    return (React.createElement("div", { className: "seekora-docsearch-searchbox" },
+        React.createElement("label", { className: "seekora-docsearch-searchbox-icon", htmlFor: "seekora-docsearch-input" },
+            React.createElement("svg", { width: "20", height: "20", viewBox: "0 0 20 20", fill: "none", xmlns: "http://www.w3.org/2000/svg", "aria-hidden": "true" },
+                React.createElement("path", { d: "M9 3.5a5.5 5.5 0 100 11 5.5 5.5 0 000-11zM2 9a7 7 0 1112.452 4.391l3.328 3.329a.75.75 0 11-1.06 1.06l-3.329-3.328A7 7 0 012 9z", fill: "currentColor" }))),
+        React.createElement("input", { ref: inputRef, id: "seekora-docsearch-input", className: "seekora-docsearch-input", type: "text", value: value, onChange: handleChange, onKeyDown: onKeyDown, placeholder: placeholder, autoComplete: "off", autoCorrect: "off", autoCapitalize: "off", spellCheck: false, "aria-autocomplete": "list", "aria-controls": "seekora-docsearch-results" }),
+        value && (React.createElement("button", { type: "button", className: "seekora-docsearch-clear", onClick: handleClear, "aria-label": "Clear search" },
+            React.createElement("svg", { width: "16", height: "16", viewBox: "0 0 16 16", fill: "none", xmlns: "http://www.w3.org/2000/svg", "aria-hidden": "true" },
+                React.createElement("path", { d: "M4.28 3.22a.75.75 0 00-1.06 1.06L6.94 8l-3.72 3.72a.75.75 0 101.06 1.06L8 9.06l3.72 3.72a.75.75 0 101.06-1.06L9.06 8l3.72-3.72a.75.75 0 00-1.06-1.06L8 6.94 4.28 3.22z", fill: "currentColor" }))))));
+}

package/dist/docsearch/hooks/useDocSearch.d.ts

@@ -0,0 +1,33 @@
+import type { DocSearchHit, DocSearchSuggestion, SearchSource } from '../types';
+interface UseDocSearchOptions {
+    apiEndpoint?: string;
+    apiKey?: string;
+    sources?: SearchSource[];
+    maxResults?: number;
+    debounceMs?: number;
+    processGroupedResults?: (sourceId: string, items: DocSearchSuggestion[]) => DocSearchSuggestion[];
+}
+export declare function useDocSearch(options: UseDocSearchOptions): {
+    sources: SearchSource[];
+    setQuery: (query: string) => void;
+    search: (q: string) => Promise<void>;
+    fetchSuggestions: (query: string) => Promise<void>;
+    selectNext: () => void;
+    selectPrev: () => void;
+    setSelectedIndex: (index: number) => void;
+    reset: () => void;
+    getSelectedItem: () => DocSearchHit | DocSearchSuggestion | null;
+    groupedSuggestions: {
+        source: SearchSource;
+        items: DocSearchSuggestion[];
+    }[];
+    query: string;
+    results: DocSearchHit[];
+    suggestions: DocSearchSuggestion[];
+    isLoading: boolean;
+    error: string | null;
+    selectedIndex: number;
+    mode: "suggestions" | "results";
+};
+export {};
+//# sourceMappingURL=useDocSearch.d.ts.map

package/dist/docsearch/hooks/useDocSearch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDocSearch.d.ts","sourceRoot":"","sources":["../../../src/docsearch/hooks/useDocSearch.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAGV,YAAY,EACZ,mBAAmB,EACnB,YAAY,EACb,MAAM,UAAU,CAAC;AA0DlB,UAAU,mBAAmB;IAC3B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,YAAY,EAAE,CAAC;IACzB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,qBAAqB,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,mBAAmB,EAAE,KAAK,mBAAmB,EAAE,CAAC;CACnG;AAED,wBAAgB,YAAY,CAAC,OAAO,EAAE,mBAAmB;;sBAoJ7C,MAAM;gBAHe,MAAM;8BAlCrB,MAAM;;;8BA+CuB,MAAM;;2BASX,YAAY,GAAG,mBAAmB,GAAG,IAAI;wBAvO7D;QAAE,MAAM,EAAE,YAAY,CAAC;QAAC,KAAK,EAAE,mBAAmB,EAAE,CAAA;KAAE,EAAE;;;;;;;;EAgQ7E"}

package/dist/docsearch/hooks/useDocSearch.js

@@ -0,0 +1,224 @@
+import { useCallback, useEffect, useReducer, useRef } from 'react';
+const initialState = {
+    query: '',
+    results: [],
+    suggestions: [],
+    groupedSuggestions: [],
+    isLoading: false,
+    error: null,
+    selectedIndex: 0,
+    mode: 'suggestions',
+};
+function reducer(state, action) {
+    switch (action.type) {
+        case 'SET_QUERY':
+            return { ...state, query: action.payload, selectedIndex: 0 };
+        case 'SET_RESULTS':
+            return { ...state, results: action.payload, mode: 'results' };
+        case 'SET_SUGGESTIONS':
+            return { ...state, suggestions: action.payload, mode: 'suggestions' };
+        case 'SET_GROUPED_SUGGESTIONS': {
+            const flatSuggestions = action.payload.flatMap(group => group.items.map(item => ({ ...item, _source: group.source.id })));
+            return { ...state, groupedSuggestions: action.payload, suggestions: flatSuggestions, mode: 'suggestions' };
+        }
+        case 'SET_LOADING':
+            return { ...state, isLoading: action.payload };
+        case 'SET_ERROR':
+            return { ...state, error: action.payload };
+        case 'SET_SELECTED_INDEX':
+            return { ...state, selectedIndex: action.payload };
+        case 'SELECT_NEXT': {
+            const items = state.mode === 'results' ? state.results : state.suggestions;
+            const maxIndex = items.length - 1;
+            return { ...state, selectedIndex: state.selectedIndex >= maxIndex ? 0 : state.selectedIndex + 1 };
+        }
+        case 'SELECT_PREV': {
+            const items = state.mode === 'results' ? state.results : state.suggestions;
+            const maxIndex = items.length - 1;
+            return { ...state, selectedIndex: state.selectedIndex <= 0 ? maxIndex : state.selectedIndex - 1 };
+        }
+        case 'SET_MODE':
+            return { ...state, mode: action.payload, selectedIndex: 0 };
+        case 'RESET':
+            return initialState;
+        default:
+            return state;
+    }
+}
+export function useDocSearch(options) {
+    const { apiEndpoint, apiKey, sources, maxResults = 10, debounceMs = 200, processGroupedResults } = options;
+    const searchSources = sources || (apiEndpoint ? [{
+            id: 'default',
+            name: 'Results',
+            endpoint: apiEndpoint,
+            apiKey,
+            maxResults,
+        }] : []);
+    const [state, dispatch] = useReducer(reducer, initialState);
+    const abortControllersRef = useRef(new Map());
+    const debounceTimerRef = useRef(null);
+    const defaultTransform = (data, sourceId) => {
+        const items = data.data?.suggestions || data.data?.results || data.data?.hits || data.suggestions || data.results || data.hits || [];
+        return items.map((item) => {
+            const doc = item.document || item;
+            // Build hierarchy from nested object or flat dot-notation keys
+            const hierarchy = doc.hierarchy || {
+                lvl0: doc['hierarchy.lvl0'],
+                lvl1: doc['hierarchy.lvl1'],
+                lvl2: doc['hierarchy.lvl2'],
+                lvl3: doc['hierarchy.lvl3'],
+                lvl4: doc['hierarchy.lvl4'],
+                lvl5: doc['hierarchy.lvl5'],
+            };
+            return {
+                url: doc.url || doc.route || item.url || '',
+                title: (doc.title || '').replace?.(/<\/?mark>/g, '') || '',
+                content: (doc.content || doc.description || '').replace?.(/<\/?mark>/g, '')?.substring?.(0, 100) || '',
+                description: doc.description || doc.content?.substring?.(0, 100) || '',
+                category: doc.category || hierarchy?.lvl0 || '',
+                hierarchy,
+                route: doc.route,
+                parentTitle: doc.parent_title || doc.parentTitle,
+                anchor: doc.anchor || item.anchor,
+                _source: sourceId,
+            };
+        });
+    };
+    const transformPublicSearchResults = useCallback((data, sourceId) => {
+        const results = data?.data?.results || [];
+        return results.map((item) => {
+            const doc = item.document || item;
+            return {
+                url: doc.url || doc.route || '',
+                title: (doc.title || doc.name || '').replace?.(/<\/?mark>/g, '') || '',
+                content: (doc.content || doc.description || '').replace?.(/<\/?mark>/g, '')?.substring?.(0, 100) || '',
+                description: doc.description || doc.content?.substring?.(0, 100) || '',
+                category: doc.category || doc.hierarchy?.lvl0 || '',
+                hierarchy: doc.hierarchy,
+                route: doc.route,
+                parentTitle: doc.parent_title || doc.parentTitle,
+                _source: sourceId,
+            };
+        });
+    }, []);
+    const fetchFromSource = useCallback(async (source, query, signal) => {
+        const minLength = source.minQueryLength ?? 1;
+        if (query.length < minLength)
+            return [];
+        try {
+            if (source.storeId) {
+                const baseUrl = source.endpoint.replace(/\/$/, '');
+                const searchUrl = `${baseUrl}/api/v1/search`;
+                const headers = {
+                    'Content-Type': 'application/json',
+                    'x-storeid': source.storeId,
+                    ...(source.storeSecret && { 'x-storesecret': source.storeSecret }),
+                };
+                const response = await fetch(searchUrl, {
+                    method: 'POST',
+                    headers,
+                    body: JSON.stringify({ q: query.trim() || '*', per_page: source.maxResults || 8 }),
+                    signal,
+                });
+                if (!response.ok)
+                    return [];
+                const data = await response.json();
+                if (source.transformResults) {
+                    return source.transformResults(data).map((item) => ({ ...item, _source: source.id }));
+                }
+                return transformPublicSearchResults(data, source.id);
+            }
+            const url = new URL(source.endpoint);
+            url.searchParams.set('query', query);
+            url.searchParams.set('limit', String(source.maxResults || 8));
+            const headers = { 'Content-Type': 'application/json' };
+            if (source.apiKey)
+                headers['X-Docs-API-Key'] = source.apiKey;
+            const response = await fetch(url.toString(), { method: 'GET', headers, signal });
+            if (!response.ok)
+                return [];
+            const data = await response.json();
+            if (source.transformResults) {
+                return source.transformResults(data).map((item) => ({ ...item, _source: source.id }));
+            }
+            return defaultTransform(data, source.id);
+        }
+        catch (error) {
+            if (error instanceof Error && error.name === 'AbortError')
+                throw error;
+            return [];
+        }
+    }, [transformPublicSearchResults]);
+    const fetchSuggestions = useCallback(async (query) => {
+        if (!query.trim()) {
+            dispatch({ type: 'SET_GROUPED_SUGGESTIONS', payload: [] });
+            return;
+        }
+        abortControllersRef.current.forEach(c => c.abort());
+        abortControllersRef.current.clear();
+        dispatch({ type: 'SET_LOADING', payload: true });
+        dispatch({ type: 'SET_ERROR', payload: null });
+        try {
+            const results = await Promise.all(searchSources.map(async (source) => {
+                const controller = new AbortController();
+                abortControllersRef.current.set(source.id, controller);
+                let items = await fetchFromSource(source, query, controller.signal);
+                if (processGroupedResults) {
+                    items = processGroupedResults(source.id, items);
+                }
+                return { source, items };
+            }));
+            const groupedResults = results.filter(r => r.items.length > 0);
+            dispatch({ type: 'SET_GROUPED_SUGGESTIONS', payload: groupedResults });
+        }
+        catch (error) {
+            if (error instanceof Error && error.name === 'AbortError')
+                return;
+            dispatch({ type: 'SET_ERROR', payload: error instanceof Error ? error.message : 'Search failed' });
+        }
+        finally {
+            dispatch({ type: 'SET_LOADING', payload: false });
+        }
+    }, [searchSources, fetchFromSource, processGroupedResults]);
+    const search = useCallback((q) => fetchSuggestions(q), [fetchSuggestions]);
+    const setQuery = useCallback((query) => {
+        dispatch({ type: 'SET_QUERY', payload: query });
+        if (debounceTimerRef.current)
+            clearTimeout(debounceTimerRef.current);
+        debounceTimerRef.current = setTimeout(() => fetchSuggestions(query), debounceMs);
+    }, [fetchSuggestions, debounceMs]);
+    const selectNext = useCallback(() => dispatch({ type: 'SELECT_NEXT' }), []);
+    const selectPrev = useCallback(() => dispatch({ type: 'SELECT_PREV' }), []);
+    const setSelectedIndex = useCallback((index) => dispatch({ type: 'SET_SELECTED_INDEX', payload: index }), []);
+    const reset = useCallback(() => {
+        abortControllersRef.current.forEach(c => c.abort());
+        abortControllersRef.current.clear();
+        if (debounceTimerRef.current)
+            clearTimeout(debounceTimerRef.current);
+        dispatch({ type: 'RESET' });
+    }, []);
+    const getSelectedItem = useCallback(() => {
+        const items = state.mode === 'results' ? state.results : state.suggestions;
+        return items[state.selectedIndex] || null;
+    }, [state.mode, state.results, state.suggestions, state.selectedIndex]);
+    useEffect(() => {
+        return () => {
+            abortControllersRef.current.forEach(c => c.abort());
+            abortControllersRef.current.clear();
+            if (debounceTimerRef.current)
+                clearTimeout(debounceTimerRef.current);
+        };
+    }, []);
+    return {
+        ...state,
+        sources: searchSources,
+        setQuery,
+        search,
+        fetchSuggestions,
+        selectNext,
+        selectPrev,
+        setSelectedIndex,
+        reset,
+        getSelectedItem,
+    };
+}

package/dist/docsearch/hooks/useKeyboard.d.ts

@@ -0,0 +1,17 @@
+import React from 'react';
+interface UseKeyboardOptions {
+    isOpen: boolean;
+    onOpen: () => void;
+    onClose: () => void;
+    onSelectNext: () => void;
+    onSelectPrev: () => void;
+    onEnter: () => void;
+    disableShortcut?: boolean;
+    shortcutKey?: string;
+}
+export declare function useKeyboard(options: UseKeyboardOptions): {
+    handleModalKeyDown: (event: KeyboardEvent | React.KeyboardEvent) => void;
+};
+export declare function getShortcutText(key?: string): string;
+export {};
+//# sourceMappingURL=useKeyboard.d.ts.map

package/dist/docsearch/hooks/useKeyboard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useKeyboard.d.ts","sourceRoot":"","sources":["../../../src/docsearch/hooks/useKeyboard.ts"],"names":[],"mappings":"AAAA,OAAO,KAAiC,MAAM,OAAO,CAAC;AAEtD,UAAU,kBAAkB;IAC1B,MAAM,EAAE,OAAO,CAAC;IAChB,MAAM,EAAE,MAAM,IAAI,CAAC;IACnB,OAAO,EAAE,MAAM,IAAI,CAAC;IACpB,YAAY,EAAE,MAAM,IAAI,CAAC;IACzB,YAAY,EAAE,MAAM,IAAI,CAAC;IACzB,OAAO,EAAE,MAAM,IAAI,CAAC;IACpB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,wBAAgB,WAAW,CAAC,OAAO,EAAE,kBAAkB;gCAyC3C,aAAa,GAAG,KAAK,CAAC,aAAa;EAyC9C;AAED,wBAAgB,eAAe,CAAC,GAAG,GAAE,MAAY,GAAG,MAAM,CAMzD"}

package/dist/docsearch/hooks/useKeyboard.js

@@ -0,0 +1,71 @@
+import { useCallback, useEffect } from 'react';
+export function useKeyboard(options) {
+    const { isOpen, onOpen, onClose, onSelectNext, onSelectPrev, onEnter, disableShortcut = false, shortcutKey = 'k', } = options;
+    const handleGlobalKeyDown = useCallback((event) => {
+        if (!disableShortcut && (event.metaKey || event.ctrlKey) && event.key.toLowerCase() === shortcutKey) {
+            event.preventDefault();
+            if (isOpen) {
+                onClose();
+            }
+            else {
+                onOpen();
+            }
+            return;
+        }
+        if (!disableShortcut && event.key === '/' && !isOpen) {
+            const target = event.target;
+            const isInput = target.tagName === 'INPUT' ||
+                target.tagName === 'TEXTAREA' ||
+                target.isContentEditable;
+            if (!isInput) {
+                event.preventDefault();
+                onOpen();
+            }
+        }
+    }, [isOpen, onOpen, onClose, disableShortcut, shortcutKey]);
+    const handleModalKeyDown = useCallback((event) => {
+        switch (event.key) {
+            case 'Escape':
+                event.preventDefault();
+                onClose();
+                break;
+            case 'ArrowDown':
+                event.preventDefault();
+                onSelectNext();
+                break;
+            case 'ArrowUp':
+                event.preventDefault();
+                onSelectPrev();
+                break;
+            case 'Enter':
+                event.preventDefault();
+                onEnter();
+                break;
+            case 'Tab':
+                if (event.shiftKey) {
+                    onSelectPrev();
+                }
+                else {
+                    onSelectNext();
+                }
+                event.preventDefault();
+                break;
+        }
+    }, [onClose, onSelectNext, onSelectPrev, onEnter]);
+    useEffect(() => {
+        document.addEventListener('keydown', handleGlobalKeyDown);
+        return () => {
+            document.removeEventListener('keydown', handleGlobalKeyDown);
+        };
+    }, [handleGlobalKeyDown]);
+    return {
+        handleModalKeyDown,
+    };
+}
+export function getShortcutText(key = 'K') {
+    if (typeof navigator === 'undefined') {
+        return `⌘${key}`;
+    }
+    const isMac = navigator.platform.toLowerCase().includes('mac');
+    return isMac ? `⌘${key}` : `Ctrl+${key}`;
+}

package/dist/docsearch/hooks/useSeekoraSearch.d.ts

@@ -0,0 +1,27 @@
+import type { DocSearchSuggestion } from '../types';
+export interface UseSeekoraSearchOptions {
+    storeId: string;
+    storeSecret?: string;
+    apiEndpoint?: string;
+    maxResults?: number;
+    debounceMs?: number;
+    analyticsTags?: string[];
+    groupField?: string;
+    groupSize?: number;
+}
+export interface UseSeekoraSearchResult {
+    query: string;
+    suggestions: DocSearchSuggestion[];
+    isLoading: boolean;
+    error: string | null;
+    selectedIndex: number;
+    setQuery: (query: string) => void;
+    selectNext: () => void;
+    selectPrev: () => void;
+    setSelectedIndex: (index: number) => void;
+    reset: () => void;
+    getSelectedItem: () => DocSearchSuggestion | null;
+    trackDocClick: (hit: DocSearchSuggestion, position: number) => void | Promise<void>;
+}
+export declare function useSeekoraSearch(options: UseSeekoraSearchOptions): UseSeekoraSearchResult;
+//# sourceMappingURL=useSeekoraSearch.d.ts.map

package/dist/docsearch/hooks/useSeekoraSearch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSeekoraSearch.d.ts","sourceRoot":"","sources":["../../../src/docsearch/hooks/useSeekoraSearch.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAEpD,MAAM,WAAW,uBAAuB;IACtC,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IACzB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,sBAAsB;IACrC,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,mBAAmB,EAAE,CAAC;IACnC,SAAS,EAAE,OAAO,CAAC;IACnB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IAClC,UAAU,EAAE,MAAM,IAAI,CAAC;IACvB,UAAU,EAAE,MAAM,IAAI,CAAC;IACvB,gBAAgB,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IAC1C,KAAK,EAAE,MAAM,IAAI,CAAC;IAClB,eAAe,EAAE,MAAM,mBAAmB,GAAG,IAAI,CAAC;IAClD,aAAa,EAAE,CAAC,GAAG,EAAE,mBAAmB,EAAE,QAAQ,EAAE,MAAM,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACrF;AA0DD,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,uBAAuB,GAAG,sBAAsB,CAiLzF"}