@seekora-ai/ui-sdk-react 0.1.1

package/dist/hooks/useNaturalLanguageFilters.js

@@ -0,0 +1,221 @@
+/**
+ * useNaturalLanguageFilters Hook
+ *
+ * Convert natural language queries to structured filters
+ * Examples:
+ * - "red shirts under $50" → color: red, category: shirts, price: <= 50
+ * - "size large blue jeans" → size: L, color: blue, category: jeans
+ */
+import { useMemo, useCallback } from 'react';
+import { useSearchState } from './useSearchState';
+// Default patterns for parsing natural language
+const DEFAULT_PATTERNS = {
+    // Price patterns
+    price: [
+        { pattern: /under\s*\$?(\d+(?:\.\d{2})?)/i, operator: '<=', field: 'price' },
+        { pattern: /less than\s*\$?(\d+(?:\.\d{2})?)/i, operator: '<', field: 'price' },
+        { pattern: /over\s*\$?(\d+(?:\.\d{2})?)/i, operator: '>=', field: 'price' },
+        { pattern: /more than\s*\$?(\d+(?:\.\d{2})?)/i, operator: '>', field: 'price' },
+        { pattern: /\$(\d+(?:\.\d{2})?)\s*-\s*\$?(\d+(?:\.\d{2})?)/i, operator: 'range', field: 'price' },
+        { pattern: /between\s*\$?(\d+(?:\.\d{2})?)\s*and\s*\$?(\d+(?:\.\d{2})?)/i, operator: 'range', field: 'price' },
+        { pattern: /\$(\d+(?:\.\d{2})?)/i, operator: '<=', field: 'price' },
+    ],
+    // Color patterns
+    colors: ['red', 'blue', 'green', 'black', 'white', 'pink', 'purple', 'yellow', 'orange', 'brown', 'gray', 'grey', 'navy', 'beige', 'gold', 'silver'],
+    // Size patterns
+    sizes: {
+        'extra small': 'XS',
+        'xs': 'XS',
+        'small': 'S',
+        's': 'S',
+        'medium': 'M',
+        'm': 'M',
+        'large': 'L',
+        'l': 'L',
+        'extra large': 'XL',
+        'xl': 'XL',
+        'xxl': 'XXL',
+        '2xl': 'XXL',
+        'xxxl': 'XXXL',
+        '3xl': 'XXXL',
+    },
+    // Brand patterns (common examples)
+    brandIndicators: ['by', 'from', 'brand'],
+    // Rating patterns
+    ratings: [
+        { pattern: /(\d+)\s*\+?\s*stars?/i, field: 'rating', operator: '>=' },
+        { pattern: /rated\s*(\d+)/i, field: 'rating', operator: '>=' },
+        { pattern: /top\s*rated/i, field: 'rating', value: '4', operator: '>=' },
+    ],
+    // Availability patterns
+    availability: [
+        { pattern: /in\s*stock/i, field: 'inStock', value: 'true' },
+        { pattern: /available/i, field: 'inStock', value: 'true' },
+        { pattern: /on\s*sale/i, field: 'onSale', value: 'true' },
+    ],
+};
+export function useNaturalLanguageFilters(options = {}) {
+    const { fieldMappings = {}, valueMappings = {}, autoApply = false, currencySymbol = '$', } = options;
+    const { addRefinement, removeRefinement, clearRefinements, setQuery } = useSearchState();
+    // Merge default patterns with custom mappings
+    const patterns = useMemo(() => ({
+        ...DEFAULT_PATTERNS,
+        colors: [...DEFAULT_PATTERNS.colors, ...(valueMappings.color ? Object.keys(valueMappings.color) : [])],
+        sizes: { ...DEFAULT_PATTERNS.sizes, ...(valueMappings.size || {}) },
+    }), [valueMappings]);
+    const parse = useCallback((query) => {
+        const filters = [];
+        let cleanedQuery = query;
+        // Parse price filters
+        for (const pricePattern of patterns.price) {
+            const match = query.match(pricePattern.pattern);
+            if (match) {
+                if (pricePattern.operator === 'range' && match[2]) {
+                    // Handle price range
+                    filters.push({
+                        field: fieldMappings.price || 'price',
+                        value: `>=${match[1]}`,
+                        operator: '>=',
+                        confidence: 0.95,
+                        matchedText: match[0],
+                    });
+                    filters.push({
+                        field: fieldMappings.price || 'price',
+                        value: `<=${match[2]}`,
+                        operator: '<=',
+                        confidence: 0.95,
+                        matchedText: match[0],
+                    });
+                }
+                else if (match[1]) {
+                    filters.push({
+                        field: fieldMappings.price || 'price',
+                        value: `${pricePattern.operator}${match[1]}`,
+                        operator: pricePattern.operator,
+                        confidence: 0.95,
+                        matchedText: match[0],
+                    });
+                }
+                cleanedQuery = cleanedQuery.replace(match[0], ' ');
+                break; // Only match first price pattern
+            }
+        }
+        // Parse colors
+        const colorRegex = new RegExp(`\\b(${patterns.colors.join('|')})\\b`, 'gi');
+        const colorMatches = query.match(colorRegex);
+        if (colorMatches) {
+            colorMatches.forEach(color => {
+                const normalizedColor = valueMappings.color?.[color.toLowerCase()] || color.toLowerCase();
+                filters.push({
+                    field: fieldMappings.color || 'color',
+                    value: normalizedColor,
+                    operator: '=',
+                    confidence: 0.9,
+                    matchedText: color,
+                });
+                cleanedQuery = cleanedQuery.replace(new RegExp(`\\b${color}\\b`, 'gi'), ' ');
+            });
+        }
+        // Parse sizes
+        const sizeEntries = Object.entries(patterns.sizes);
+        for (const [sizeText, sizeValue] of sizeEntries) {
+            const sizeRegex = new RegExp(`\\b${sizeText}\\b`, 'gi');
+            if (sizeRegex.test(query)) {
+                filters.push({
+                    field: fieldMappings.size || 'size',
+                    value: sizeValue,
+                    operator: '=',
+                    confidence: 0.85,
+                    matchedText: sizeText,
+                });
+                cleanedQuery = cleanedQuery.replace(sizeRegex, ' ');
+                break; // Only match first size
+            }
+        }
+        // Parse ratings
+        for (const ratingPattern of patterns.ratings) {
+            if ('value' in ratingPattern) {
+                if (ratingPattern.pattern.test(query)) {
+                    filters.push({
+                        field: fieldMappings.rating || ratingPattern.field,
+                        value: `${ratingPattern.operator}${ratingPattern.value}`,
+                        operator: ratingPattern.operator,
+                        confidence: 0.8,
+                        matchedText: query.match(ratingPattern.pattern)?.[0] || '',
+                    });
+                    cleanedQuery = cleanedQuery.replace(ratingPattern.pattern, ' ');
+                }
+            }
+            else {
+                const match = query.match(ratingPattern.pattern);
+                if (match && match[1]) {
+                    filters.push({
+                        field: fieldMappings.rating || ratingPattern.field,
+                        value: `${ratingPattern.operator}${match[1]}`,
+                        operator: ratingPattern.operator,
+                        confidence: 0.85,
+                        matchedText: match[0],
+                    });
+                    cleanedQuery = cleanedQuery.replace(match[0], ' ');
+                }
+            }
+        }
+        // Parse availability
+        for (const availPattern of patterns.availability) {
+            if (availPattern.pattern.test(query)) {
+                filters.push({
+                    field: fieldMappings[availPattern.field] || availPattern.field,
+                    value: availPattern.value,
+                    operator: '=',
+                    confidence: 0.9,
+                    matchedText: query.match(availPattern.pattern)?.[0] || '',
+                });
+                cleanedQuery = cleanedQuery.replace(availPattern.pattern, ' ');
+            }
+        }
+        // Clean up the query
+        cleanedQuery = cleanedQuery
+            .replace(/\s+/g, ' ')
+            .trim();
+        return {
+            cleanedQuery,
+            filters,
+            originalQuery: query,
+            hasFilters: filters.length > 0,
+        };
+    }, [patterns, fieldMappings, valueMappings]);
+    const applyFilters = useCallback((filters) => {
+        filters.forEach(filter => {
+            addRefinement(filter.field, filter.value, false);
+        });
+        // Trigger search after all filters are added
+        if (filters.length > 0) {
+            // The last addRefinement with triggerSearch=true would be called
+            // But we add them all with false and rely on the query change to trigger
+        }
+    }, [addRefinement]);
+    const parseAndApply = useCallback((query) => {
+        const result = parse(query);
+        if (result.hasFilters) {
+            applyFilters(result.filters);
+            // Update the query to the cleaned version
+            if (result.cleanedQuery !== query) {
+                setQuery(result.cleanedQuery, true);
+            }
+        }
+        return result;
+    }, [parse, applyFilters, setQuery]);
+    return {
+        parse,
+        applyFilters,
+        parseAndApply,
+    };
+}
+/**
+ * Utility to format parsed filters for display
+ */
+export function formatParsedFilters(filters) {
+    return filters
+        .map(f => `${f.field}: ${f.value}`)
+        .join(', ');
+}

package/dist/hooks/useQuerySuggestions.d.ts

@@ -0,0 +1,21 @@
+/**
+ * useQuerySuggestions Hook
+ *
+ * Hook for fetching query suggestions with debouncing
+ */
+import type { SeekoraClient } from '@seekora-ai/search-sdk';
+import type { SuggestionItem } from '../types';
+export interface UseQuerySuggestionsOptions {
+    client: SeekoraClient;
+    query: string;
+    enabled?: boolean;
+    debounceMs?: number;
+    maxSuggestions?: number;
+}
+export interface UseQuerySuggestionsReturn {
+    suggestions: SuggestionItem[];
+    loading: boolean;
+    error: Error | null;
+}
+export declare const useQuerySuggestions: ({ client, query, enabled, debounceMs, maxSuggestions, }: UseQuerySuggestionsOptions) => UseQuerySuggestionsReturn;
+//# sourceMappingURL=useQuerySuggestions.d.ts.map

package/dist/hooks/useQuerySuggestions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useQuerySuggestions.d.ts","sourceRoot":"","sources":["../../src/hooks/useQuerySuggestions.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAE5D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAE/C,MAAM,WAAW,0BAA0B;IACzC,MAAM,EAAE,aAAa,CAAC;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,yBAAyB;IACxC,WAAW,EAAE,cAAc,EAAE,CAAC;IAC9B,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;CACrB;AAED,eAAO,MAAM,mBAAmB,GAAI,yDAMjC,0BAA0B,KAAG,yBAqE/B,CAAC"}

package/dist/hooks/useQuerySuggestions.js

@@ -0,0 +1,68 @@
+/**
+ * useQuerySuggestions Hook
+ *
+ * Hook for fetching query suggestions with debouncing
+ */
+import { useState, useEffect, useRef } from 'react';
+import { log } from '@seekora-ai/ui-sdk-core';
+export const useQuerySuggestions = ({ client, query, enabled = true, debounceMs = 300, maxSuggestions = 10, }) => {
+    const [suggestions, setSuggestions] = useState([]);
+    const [loading, setLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const debounceTimerRef = useRef(null);
+    useEffect(() => {
+        // Clear previous timer
+        if (debounceTimerRef.current) {
+            clearTimeout(debounceTimerRef.current);
+        }
+        if (!enabled || !query.trim()) {
+            setSuggestions([]);
+            setLoading(false);
+            setError(null);
+            return;
+        }
+        setLoading(true);
+        setError(null);
+        debounceTimerRef.current = setTimeout(async () => {
+            try {
+                const response = await client.getSuggestions?.(query, maxSuggestions);
+                // Transform suggestions to SuggestionItem format
+                // getSuggestions returns an array of suggestion objects with structure:
+                // { query: string, popularity: number, objectID: string, ... }
+                const rawSuggestions = Array.isArray(response) ? response : [];
+                const suggestionItems = rawSuggestions.map((suggestion) => {
+                    // Extract query - it should be in suggestion.query
+                    const suggestionQuery = suggestion.query || suggestion.text || suggestion;
+                    // Extract count/popularity
+                    const count = suggestion.popularity !== undefined ? suggestion.popularity : (suggestion.count !== undefined ? suggestion.count : undefined);
+                    const item = {
+                        query: typeof suggestionQuery === 'string' ? suggestionQuery : String(suggestionQuery),
+                        count: typeof count === 'number' ? count : undefined,
+                        metadata: suggestion,
+                    };
+                    return item;
+                });
+                setSuggestions(suggestionItems);
+            }
+            catch (err) {
+                const error = err instanceof Error ? err : new Error(String(err));
+                log.error('Error in useQuerySuggestions:', error);
+                setError(error);
+                setSuggestions([]);
+            }
+            finally {
+                setLoading(false);
+            }
+        }, debounceMs);
+        return () => {
+            if (debounceTimerRef.current) {
+                clearTimeout(debounceTimerRef.current);
+            }
+        };
+    }, [client, query, enabled, debounceMs, maxSuggestions]);
+    return {
+        suggestions,
+        loading,
+        error,
+    };
+};

package/dist/hooks/useQuerySuggestionsEnhanced.d.ts

@@ -0,0 +1,114 @@
+/**
+ * Enhanced Query Suggestions Hook
+ *
+ * Provides full support for query suggestions API including:
+ * - Basic suggestions
+ * - Dropdown recommendations (trending, top searches, related)
+ * - Filtered tabs with products
+ * - Recent searches (local storage)
+ * - Analytics tracking
+ */
+import type { SeekoraClient } from '@seekora-ai/search-sdk';
+import type { SuggestionItem, ProductItem, FilteredTab, DropdownRecommendations, RecentSearch, QuerySuggestionsResponse, TrendingSearch, TopSearch, RelatedSearch, PopularBrand, SuggestionCategory } from '@seekora-ai/ui-sdk-types';
+export interface UseQuerySuggestionsEnhancedOptions {
+    /** Seekora client instance */
+    client: SeekoraClient;
+    /** Current search query */
+    query: string;
+    /** Enable/disable the hook */
+    enabled?: boolean;
+    /** Debounce delay in ms */
+    debounceMs?: number;
+    /** Max suggestions to fetch */
+    maxSuggestions?: number;
+    /** Minimum query length to trigger search */
+    minQueryLength?: number;
+    /** Include dropdown recommendations (trending, products, etc.) */
+    includeDropdownRecommendations?: boolean;
+    /** Include categories in suggestions */
+    includeCategories?: boolean;
+    /** Include facets in suggestions */
+    includeFacets?: boolean;
+    /** Max categories per suggestion */
+    maxCategories?: number;
+    /** Max facets per suggestion */
+    maxFacets?: number;
+    /** Filtered tabs configuration */
+    filteredTabs?: Array<{
+        id?: string;
+        label: string;
+        filter: string;
+    }>;
+    /** Minimum popularity threshold */
+    minPopularity?: number;
+    /** Time range for analytics data */
+    timeRange?: '7d' | '30d' | '90d';
+    /** Disable typo tolerance */
+    disableTypoTolerance?: boolean;
+    /** Analytics tags */
+    analyticsTags?: string[];
+    /** Enable recent searches from localStorage */
+    enableRecentSearches?: boolean;
+    /** Max recent searches to store */
+    maxRecentSearches?: number;
+    /** Local storage key for recent searches */
+    recentSearchesKey?: string;
+    /** Callback when suggestions are loaded */
+    onSuggestionsLoaded?: (response: QuerySuggestionsResponse) => void;
+    /** Callback on error */
+    onError?: (error: Error) => void;
+}
+export interface UseQuerySuggestionsEnhancedReturn {
+    /** Basic suggestion items */
+    suggestions: SuggestionItem[];
+    /** Loading state */
+    loading: boolean;
+    /** Error state */
+    error: Error | null;
+    /** Dropdown recommendations */
+    dropdownRecommendations: DropdownRecommendations | null;
+    /** Trending searches */
+    trendingSearches: TrendingSearch[];
+    /** Top searches */
+    topSearches: TopSearch[];
+    /** Related searches */
+    relatedSearches: RelatedSearch[];
+    /** Popular brands */
+    popularBrands: PopularBrand[];
+    /** Filtered tabs with products */
+    filteredTabs: FilteredTab[];
+    /** Trending products */
+    trendingProducts: ProductItem[];
+    /** Recent searches (from localStorage) */
+    recentSearches: RecentSearch[];
+    /** Processing time in ms */
+    processingTimeMs: number | null;
+    /** Total hits count */
+    totalHits: number;
+    /** Current page */
+    currentPage: number;
+    /** Total pages */
+    totalPages: number;
+    /** Original query */
+    originalQuery: string;
+    /** Add a search to recent searches */
+    addRecentSearch: (query: string, resultsCount?: number) => void;
+    /** Remove a search from recent searches */
+    removeRecentSearch: (query: string) => void;
+    /** Clear all recent searches */
+    clearRecentSearches: () => void;
+    /** Manually refetch suggestions */
+    refetch: () => Promise<void>;
+    /** Check if dropdown has any content to show */
+    hasContent: boolean;
+    /** Get all items for keyboard navigation (flattened) */
+    getAllNavigableItems: () => NavigableItem[];
+}
+export interface NavigableItem {
+    type: 'suggestion' | 'recent' | 'trending' | 'product' | 'category' | 'brand' | 'tab';
+    index: number;
+    data: SuggestionItem | RecentSearch | TrendingSearch | ProductItem | SuggestionCategory | PopularBrand | FilteredTab;
+}
+export declare function useQuerySuggestionsEnhanced(options: UseQuerySuggestionsEnhancedOptions): UseQuerySuggestionsEnhancedReturn;
+export default useQuerySuggestionsEnhanced;
+//# sourceMappingURL=useQuerySuggestionsEnhanced.d.ts.map

package/dist/hooks/useQuerySuggestionsEnhanced.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useQuerySuggestionsEnhanced.d.ts","sourceRoot":"","sources":["../../src/hooks/useQuerySuggestionsEnhanced.ts"],"names":[],"mappings":"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"}