@envive-ai/react-hooks 0.2.10 → 0.3.0

package/dist/hooks/Search/useSearch.js

@@ -0,0 +1,231 @@
+import { SearchResultsState, getSearchResultsState } from "../utils.js";
+import { SpiffyWidgets } from "../../application/models/spiffyWidgets.js";
+import { orgShortNameAtom } from "../../atoms/envive/enviveConfig.js";
+import { SpiffyMetricsEventName, useAmplitude } from "../../contexts/amplitudeContext/amplitudeContext.js";
+import { isFilterOpenAtom } from "../../atoms/globalSearch/globalSearch.js";
+import { formatFilterDisplayName } from "../../atoms/search/utils.js";
+import { ProductSorting } from "../../atoms/search/types.js";
+import { addSearchFilterAtom, clearSearchFiltersAtom, createFilterOption, filteredSearchProductsAtom, performSearchAtom, removeSearchFilterAtom, searchAtom, searchFiltersAtom, searchParamsAtom, searchProductSortingAtom, searchSelectedFiltersAtom } from "../../atoms/search/searchAPI.js";
+import "../../atoms/search/index.js";
+import { useNewOrgConfig } from "../NewOrgConfig/useNewOrgConfig.js";
+import "../NewOrgConfig/index.js";
+import { useTrackComponentVisibleEvent } from "../TrackComponentVisibleEvent/useTrackComponentVisibleEvent.js";
+import "../TrackComponentVisibleEvent/index.js";
+import { useSearchInput } from "./useSearchInput.js";
+import { useRecommendedProducts } from "./useRecommendedProducts.js";
+import { useCallback, useEffect, useMemo, useRef } from "react";
+import { useAtom, useAtomValue, useSetAtom } from "jotai";
+
+//#region src/hooks/Search/useSearch.tsx
+const useSearch = ({ allowRedirect = false } = {}) => {
+	const config = useNewOrgConfig();
+	const orgShortName = useAtomValue(orgShortNameAtom);
+	const { data: searchData, loading: isLoadingSearch } = useAtomValue(searchAtom);
+	const productList = useAtomValue(filteredSearchProductsAtom);
+	const performSearch = useSetAtom(performSearchAtom);
+	const [{ query }] = useAtom(searchParamsAtom);
+	const [isFilterOpen, setIsFilterOpen] = useAtom(isFilterOpenAtom);
+	const [selectedFilterOptions] = useAtom(searchSelectedFiltersAtom);
+	const addFilter = useSetAtom(addSearchFilterAtom);
+	const removeFilter = useSetAtom(removeSearchFilterAtom);
+	const [productSorting, setProductSorting] = useAtom(searchProductSortingAtom);
+	const clearFilters = useSetAtom(clearSearchFiltersAtom);
+	const searchFilters = useAtomValue(searchFiltersAtom);
+	const recommendedProducts = useRecommendedProducts();
+	const searchResultsRef = useRef(null);
+	const scrollToTop = useCallback(() => {
+		const container = searchResultsRef.current;
+		if (container) container.scrollTo({
+			top: 0,
+			behavior: "smooth"
+		});
+		else window.scrollTo({
+			top: 0,
+			behavior: "smooth"
+		});
+	}, []);
+	const { searchText, focusedIndex, focusedOptionId, autocompleteResults, shouldShowAutocomplete, handleSearchInputChange, handleSearchInputFocus, handleSearchInputBlur, handleKeyDown, handleAutocompleteSelect, handleSubmitSearch, setSearchText, resetSearch } = useSearchInput({
+		initialSearchText: "",
+		searchOrigin: SpiffyWidgets.SearchResults,
+		onSearchSubmit: (searchQuery) => {
+			performSearch({ query: searchQuery }, allowRedirect);
+		}
+	});
+	const searchResultsState = getSearchResultsState(isLoadingSearch, searchData);
+	const dynamicFilters = searchData?.filters || [];
+	const safeProductCardConfig = config?.frontendConfig?.uiConfigs?.productCardConfig || {
+		variant: "minimal",
+		hoverVariant: "none",
+		layoutVariant: "square"
+	};
+	const safeMerchantShortName = orgShortName || "";
+	const searchConfig = config?.frontendConfig?.uiConfigs?.searchConfig;
+	const safeRecommendedProductsHeading = searchConfig?.recommendedProductsHeading || "Suggested Products";
+	const safeSearchOverlayHeading = searchConfig?.searchOverlayHeading ?? "What can I help you find?";
+	const availableDynamicFilters = useMemo(() => {
+		return dynamicFilters.filter((dynamicFilterName) => !selectedFilterOptions.some((option) => option.id === `dynamic:${dynamicFilterName}`)).map((dynamicFilterName) => ({
+			name: dynamicFilterName,
+			displayName: formatFilterDisplayName(dynamicFilterName)
+		}));
+	}, [dynamicFilters, selectedFilterOptions]);
+	const filters = useMemo(() => {
+		return [{
+			filterId: "sort",
+			displayName: "SORT",
+			items: [
+				{
+					filterItemId: String(ProductSorting.FEATURED),
+					displayName: "Relevance",
+					productCount: 0,
+					isSelected: productSorting === ProductSorting.FEATURED
+				},
+				{
+					filterItemId: String(ProductSorting.PRICE_ASC),
+					displayName: "Price: Low to High",
+					productCount: 0,
+					isSelected: productSorting === ProductSorting.PRICE_ASC
+				},
+				{
+					filterItemId: String(ProductSorting.PRICE_DESC),
+					displayName: "Price: High to Low",
+					productCount: 0,
+					isSelected: productSorting === ProductSorting.PRICE_DESC
+				}
+			]
+		}, ...searchFilters];
+	}, [productSorting, searchFilters]);
+	const filterButtonText = useMemo(() => {
+		const selectedCount = filters.reduce((acc, filter) => {
+			if (filter.filterId === "sort") return acc;
+			return acc + filter.items.filter((item) => item.isSelected).length;
+		}, 0);
+		if (selectedCount === 0) return "Filter & Sort";
+		return `Filter & Sort (${selectedCount})`;
+	}, [filters]);
+	const { trackEvent } = useAmplitude();
+	const handleToggleDynamicFilter = useCallback(({ filter, dynamicFilterDisplayName }) => {
+		trackEvent({
+			eventName: SpiffyMetricsEventName.SearchFilterClicked,
+			eventProps: {
+				filterType: "Dynamic",
+				filterValue: filter,
+				queryText: searchText
+			}
+		});
+		addFilter(createFilterOption("dynamic", filter, dynamicFilterDisplayName));
+		scrollToTop();
+	}, [
+		addFilter,
+		searchText,
+		scrollToTop
+	]);
+	const handleRemoveFilter = useCallback((filter) => {
+		removeFilter(filter.id);
+		scrollToTop();
+	}, [removeFilter, scrollToTop]);
+	const handleSelectFilterItem = useCallback(({ filterId, filterItemId, isSelected, displayName }) => {
+		if (filterId === "sort") {
+			const newSort = filterItemId;
+			trackEvent({
+				eventName: SpiffyMetricsEventName.SearchSortClicked,
+				eventProps: {
+					sortType: newSort,
+					queryText: searchText
+				}
+			});
+			setProductSorting(newSort);
+			scrollToTop();
+		} else if (!isSelected) {
+			removeFilter(`${filterId}:${filterItemId}`);
+			scrollToTop();
+		} else {
+			trackEvent({
+				eventName: SpiffyMetricsEventName.SearchFilterClicked,
+				eventProps: {
+					filterType: "Static",
+					filterCategory: filterId,
+					filterValue: filterItemId,
+					queryText: searchText
+				}
+			});
+			addFilter(createFilterOption(filterId, filterItemId, displayName));
+			scrollToTop();
+		}
+	}, [
+		addFilter,
+		removeFilter,
+		setProductSorting,
+		searchText,
+		scrollToTop
+	]);
+	const handleClearAllFilters = useCallback(() => {
+		setProductSorting(ProductSorting.FEATURED);
+		clearFilters();
+		scrollToTop();
+	}, [
+		setProductSorting,
+		clearFilters,
+		scrollToTop
+	]);
+	useTrackComponentVisibleEvent(SpiffyWidgets.SearchResults, searchResultsRef, {}, SpiffyMetricsEventName.SearchComponentVisible);
+	useEffect(() => {
+		if (searchResultsState === SearchResultsState.Results || searchResultsState === SearchResultsState.NoResults) trackEvent({
+			eventName: SpiffyMetricsEventName.SearchResultsViewed,
+			eventProps: {
+				queryText: searchText,
+				resultsCount: productList.length
+			}
+		});
+	}, [productList.length, searchResultsState]);
+	useEffect(() => {
+		if (query && query !== searchText) {
+			const esq = new URLSearchParams(window.location.search).get("esq");
+			setSearchText(query);
+			performSearch({ query: esq ?? query });
+		}
+	}, [
+		performSearch,
+		query,
+		setSearchText
+	]);
+	return {
+		searchData,
+		searchResponseId: searchData?.searchResponseId ?? "",
+		merchantShortName: safeMerchantShortName,
+		recommendedProductsHeading: safeRecommendedProductsHeading,
+		searchOverlayHeading: safeSearchOverlayHeading,
+		productCardConfig: safeProductCardConfig,
+		productList,
+		recommendedProducts,
+		autocompleteResults,
+		searchFilters: filters,
+		availableDynamicFilters,
+		selectedFilterOptions,
+		searchText,
+		query: query || "",
+		searchResultsState,
+		isLoadingSearch,
+		isFilterOpen,
+		shouldShowAutocomplete,
+		focusedIndex,
+		focusedOptionId,
+		filterButtonText,
+		onSearchInputChange: handleSearchInputChange,
+		onSubmitSearch: handleSubmitSearch,
+		onAutocompleteSelect: handleAutocompleteSelect,
+		onKeyDown: handleKeyDown,
+		onSearchInputFocus: handleSearchInputFocus,
+		onSearchInputBlur: handleSearchInputBlur,
+		onToggleDynamicFilter: handleToggleDynamicFilter,
+		onSelectFilterItem: handleSelectFilterItem,
+		onRemoveFilter: handleRemoveFilter,
+		onClearAllFilters: handleClearAllFilters,
+		setIsFilterOpen,
+		resetSearch,
+		searchResultsRef
+	};
+};
+
+//#endregion
+export { useSearch };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"useSearch.js","names":["handleSelectFilterItem: SelectFilterItem"],"sources":["../../../src/hooks/Search/useSearch.tsx"],"sourcesContent":["import { useAtom, useAtomValue, useSetAtom } from 'jotai';\nimport { useCallback, useEffect, useMemo, useRef } from 'react';\n\nimport {\n  SelectedFilterOption,\n  addSearchFilterAtom,\n  clearSearchFiltersAtom,\n  createFilterOption,\n  filteredSearchProductsAtom,\n  performSearchAtom,\n  removeSearchFilterAtom,\n  searchAtom,\n  searchFiltersAtom,\n  searchParamsAtom,\n  searchProductSortingAtom,\n  searchSelectedFiltersAtom,\n} from 'src/atoms/search';\nimport { isFilterOpenAtom } from 'src/atoms/globalSearch/globalSearch';\nimport { formatFilterDisplayName } from 'src/atoms/search/utils';\nimport { ProductSorting } from 'src/atoms/search/types';\nimport {\n  SpiffyMetricsEventName,\n  useAmplitude,\n} from 'src/contexts/amplitudeContext/amplitudeContext';\nimport { SpiffyWidgets } from 'src/application/models/spiffyWidgets';\nimport { ProductCardConfig } from 'src/contexts/types';\nimport { SearchResult } from 'src/application/models/api/search';\nimport { SearchResponseProduct } from '@spiffy-ai/commerce-api-client';\nimport { SearchFilterDatum, SelectFilterItem } from 'src/types/search-filter-types';\nimport { orgShortNameAtom } from 'src/atoms/envive/enviveConfig';\nimport { SearchResponseProductAttributes } from 'src/application/models';\nimport { SearchResultsState, getSearchResultsState } from '../utils';\nimport { useTrackComponentVisibleEvent } from '../TrackComponentVisibleEvent';\nimport { useSearchInput } from './useSearchInput';\nimport { useNewOrgConfig } from '../NewOrgConfig';\nimport { useRecommendedProducts } from './useRecommendedProducts';\n\nexport interface SearchResultsHocProps {\n  // Data\n  searchData: SearchResult | null;\n  searchResponseId: string;\n  merchantShortName: string;\n  productCardConfig: ProductCardConfig;\n  productList: SearchResponseProduct[];\n  autocompleteResults: string[];\n  searchFilters: SearchFilterDatum[];\n  availableDynamicFilters: { name: string; displayName: string }[];\n  selectedFilterOptions: SelectedFilterOption[];\n  recommendedProducts: SearchResponseProductAttributes['attributes'][];\n  recommendedProductsHeading: string;\n  searchOverlayHeading: string;\n\n  // State\n  searchText: string;\n  query: string;\n  searchResultsState: SearchResultsState;\n  isLoadingSearch: boolean;\n  isFilterOpen: boolean;\n  shouldShowAutocomplete: boolean;\n  focusedIndex: number;\n  focusedOptionId: string | undefined;\n\n  // UI\n  filterButtonText: string;\n\n  // Event Handlers\n  onSearchInputChange: (value: string) => void;\n  onSubmitSearch: () => void;\n  onAutocompleteSelect: (suggestion: string) => void;\n  onKeyDown: (event: React.KeyboardEvent<HTMLInputElement>) => void;\n  onSearchInputFocus: () => void;\n  onSearchInputBlur: () => void;\n  onToggleDynamicFilter: ({\n    filter,\n    dynamicFilterDisplayName,\n  }: {\n    filter: string;\n    dynamicFilterDisplayName: string;\n  }) => void;\n  onSelectFilterItem: SelectFilterItem;\n  onRemoveFilter: (filter: SelectedFilterOption) => void;\n  onClearAllFilters: () => void;\n  setIsFilterOpen: (isFilterOpen: boolean) => void;\n  resetSearch: () => void;\n  // Refs\n  searchResultsRef: React.RefObject<HTMLDivElement>;\n}\n\nexport const useSearch = ({\n  allowRedirect = false,\n}: { allowRedirect?: boolean } = {}): SearchResultsHocProps => {\n  // Atoms\n  const config = useNewOrgConfig();\n  const orgShortName = useAtomValue(orgShortNameAtom);\n  const { data: searchData, loading: isLoadingSearch } = useAtomValue(searchAtom);\n  const productList = useAtomValue(filteredSearchProductsAtom);\n  const performSearch = useSetAtom(performSearchAtom);\n  const [{ query }] = useAtom(searchParamsAtom);\n  const [isFilterOpen, setIsFilterOpen] = useAtom(isFilterOpenAtom);\n  const [selectedFilterOptions] = useAtom(searchSelectedFiltersAtom);\n  const addFilter = useSetAtom(addSearchFilterAtom);\n  const removeFilter = useSetAtom(removeSearchFilterAtom);\n  const [productSorting, setProductSorting] = useAtom(searchProductSortingAtom);\n  const clearFilters = useSetAtom(clearSearchFiltersAtom);\n  const searchFilters = useAtomValue(searchFiltersAtom);\n  const recommendedProducts = useRecommendedProducts();\n\n  // Refs\n  const searchResultsRef = useRef<HTMLDivElement>(null);\n\n  // Utilities\n  const scrollToTop = useCallback(() => {\n    const container = searchResultsRef.current;\n    if (container) {\n      container.scrollTo({ top: 0, behavior: 'smooth' });\n    } else {\n      window.scrollTo({ top: 0, behavior: 'smooth' });\n    }\n  }, []);\n\n  // Search Input Hook\n  const searchInput = useSearchInput({\n    initialSearchText: '',\n    searchOrigin: SpiffyWidgets.SearchResults,\n    onSearchSubmit: searchQuery => {\n      performSearch({ query: searchQuery }, allowRedirect);\n    },\n  });\n\n  const {\n    searchText,\n    focusedIndex,\n    focusedOptionId,\n    autocompleteResults,\n    shouldShowAutocomplete,\n    handleSearchInputChange,\n    handleSearchInputFocus,\n    handleSearchInputBlur,\n    handleKeyDown,\n    handleAutocompleteSelect,\n    handleSubmitSearch,\n    setSearchText,\n    resetSearch,\n  } = searchInput;\n  const searchResultsState = getSearchResultsState(isLoadingSearch, searchData);\n\n  const dynamicFilters = searchData?.filters || [];\n\n  // Provide fallback values when orgUIConfig is not yet available\n  const safeProductCardConfig = config?.frontendConfig?.uiConfigs?.productCardConfig || {\n    variant: 'minimal',\n    hoverVariant: 'none',\n    layoutVariant: 'square',\n  };\n  const safeMerchantShortName = orgShortName || '';\n  const searchConfig = config?.frontendConfig?.uiConfigs?.searchConfig;\n  const safeRecommendedProductsHeading =\n    searchConfig?.recommendedProductsHeading || 'Suggested Products';\n  const safeSearchOverlayHeading =\n    searchConfig?.searchOverlayHeading ?? 'What can I help you find?';\n  const availableDynamicFilters = useMemo(() => {\n    return dynamicFilters\n      .filter(\n        dynamicFilterName =>\n          !selectedFilterOptions.some(option => option.id === `dynamic:${dynamicFilterName}`),\n      )\n      .map(dynamicFilterName => ({\n        name: dynamicFilterName,\n        displayName: formatFilterDisplayName(dynamicFilterName),\n      }));\n  }, [dynamicFilters, selectedFilterOptions]);\n\n  const filters = useMemo(() => {\n    const sortOptions = [\n      {\n        filterItemId: String(ProductSorting.FEATURED),\n        displayName: 'Relevance',\n        productCount: 0,\n        isSelected: productSorting === ProductSorting.FEATURED,\n      },\n      {\n        filterItemId: String(ProductSorting.PRICE_ASC),\n        displayName: 'Price: Low to High',\n        productCount: 0,\n        isSelected: productSorting === ProductSorting.PRICE_ASC,\n      },\n      {\n        filterItemId: String(ProductSorting.PRICE_DESC),\n        displayName: 'Price: High to Low',\n        productCount: 0,\n        isSelected: productSorting === ProductSorting.PRICE_DESC,\n      },\n    ];\n\n    return [\n      { filterId: 'sort', displayName: 'SORT', items: sortOptions },\n      ...searchFilters,\n    ] as SearchFilterDatum[];\n  }, [productSorting, searchFilters]);\n\n  const filterButtonText = useMemo(() => {\n    const selectedCount = filters.reduce((acc: number, filter) => {\n      if (filter.filterId === 'sort') {\n        return acc;\n      }\n      return acc + filter.items.filter(item => item.isSelected).length;\n    }, 0);\n    if (selectedCount === 0) {\n      return 'Filter & Sort';\n    }\n    return `Filter & Sort (${selectedCount})`;\n  }, [filters]);\n\n  // Callbacks\n  const { trackEvent } = useAmplitude();\n\n  const handleToggleDynamicFilter = useCallback(\n    ({\n      filter,\n      dynamicFilterDisplayName,\n    }: {\n      filter: string;\n      dynamicFilterDisplayName: string;\n    }) => {\n      trackEvent({\n        eventName: SpiffyMetricsEventName.SearchFilterClicked,\n        eventProps: {\n          filterType: 'Dynamic',\n          filterValue: filter,\n          queryText: searchText,\n        },\n      });\n      addFilter(createFilterOption('dynamic', filter, dynamicFilterDisplayName));\n      scrollToTop();\n    },\n    [addFilter, searchText, scrollToTop],\n  );\n\n  const handleRemoveFilter = useCallback(\n    (filter: SelectedFilterOption) => {\n      removeFilter(filter.id);\n      scrollToTop();\n    },\n    [removeFilter, scrollToTop],\n  );\n\n  const handleSelectFilterItem: SelectFilterItem = useCallback(\n    ({\n      filterId,\n      filterItemId,\n      isSelected,\n      displayName,\n    }: {\n      filterId: string;\n      filterItemId: string;\n      isSelected: boolean;\n      displayName: string;\n    }) => {\n      if (filterId === 'sort') {\n        const newSort = filterItemId as ProductSorting;\n        trackEvent({\n          eventName: SpiffyMetricsEventName.SearchSortClicked,\n          eventProps: {\n            sortType: newSort,\n            queryText: searchText,\n          },\n        });\n        setProductSorting(newSort);\n        scrollToTop();\n      } else if (!isSelected) {\n        removeFilter(`${filterId}:${filterItemId}`);\n        scrollToTop();\n      } else {\n        trackEvent({\n          eventName: SpiffyMetricsEventName.SearchFilterClicked,\n          eventProps: {\n            filterType: 'Static',\n            filterCategory: filterId,\n            filterValue: filterItemId,\n            queryText: searchText,\n          },\n        });\n        addFilter(createFilterOption(filterId, filterItemId, displayName));\n        scrollToTop();\n      }\n    },\n    [addFilter, removeFilter, setProductSorting, searchText, scrollToTop],\n  );\n\n  const handleClearAllFilters = useCallback(() => {\n    setProductSorting(ProductSorting.FEATURED);\n    clearFilters();\n    scrollToTop();\n  }, [setProductSorting, clearFilters, scrollToTop]);\n\n  // Side Effects\n  useTrackComponentVisibleEvent(\n    SpiffyWidgets.SearchResults,\n    searchResultsRef,\n    {},\n    SpiffyMetricsEventName.SearchComponentVisible,\n  );\n\n  useEffect(() => {\n    if (\n      searchResultsState === SearchResultsState.Results ||\n      searchResultsState === SearchResultsState.NoResults\n    ) {\n      trackEvent({\n        eventName: SpiffyMetricsEventName.SearchResultsViewed,\n        eventProps: {\n          queryText: searchText,\n          resultsCount: productList.length,\n        },\n      });\n    }\n  }, [productList.length, searchResultsState]);\n\n  // This is the single source of truth for the search text triggering a search\n  useEffect(() => {\n    if (query && query !== searchText) {\n      const esq = new URLSearchParams(window.location.search).get('esq');\n      setSearchText(query);\n      performSearch({ query: esq ?? query });\n    }\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [performSearch, query, setSearchText]);\n\n  return {\n    searchData,\n    searchResponseId: searchData?.searchResponseId ?? '',\n    merchantShortName: safeMerchantShortName,\n    recommendedProductsHeading: safeRecommendedProductsHeading,\n    searchOverlayHeading: safeSearchOverlayHeading,\n    productCardConfig: safeProductCardConfig,\n    productList,\n    recommendedProducts,\n    autocompleteResults,\n    searchFilters: filters,\n    availableDynamicFilters,\n    selectedFilterOptions,\n    searchText,\n    query: query || '',\n    searchResultsState,\n    isLoadingSearch,\n    isFilterOpen,\n    shouldShowAutocomplete,\n    focusedIndex,\n    focusedOptionId,\n    filterButtonText,\n    onSearchInputChange: handleSearchInputChange,\n    onSubmitSearch: handleSubmitSearch,\n    onAutocompleteSelect: handleAutocompleteSelect,\n    onKeyDown: handleKeyDown,\n    onSearchInputFocus: handleSearchInputFocus,\n    onSearchInputBlur: handleSearchInputBlur,\n    onToggleDynamicFilter: handleToggleDynamicFilter,\n    onSelectFilterItem: handleSelectFilterItem,\n    onRemoveFilter: handleRemoveFilter,\n    onClearAllFilters: handleClearAllFilters,\n    setIsFilterOpen,\n    resetSearch,\n    searchResultsRef,\n  };\n};\n"],"mappings":"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"}

package/dist/hooks/Search/useSearchInput.cjs

@@ -0,0 +1,173 @@
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+const require_amplitudeContext = require('../../contexts/amplitudeContext/amplitudeContext.cjs');
+const require_amplitudeTrackEventAtom = require('../../atoms/amplitude/amplitudeTrackEventAtom.cjs');
+const require_globalSearch = require('../../atoms/globalSearch/globalSearch.cjs');
+require('../../atoms/globalSearch/index.cjs');
+require('../../contexts/amplitudeContext/index.cjs');
+let react = require("react");
+let jotai = require("jotai");
+let fuse_js = require("fuse.js");
+fuse_js = require_rolldown_runtime.__toESM(fuse_js);
+
+//#region src/hooks/Search/useSearchInput.ts
+const useSearchInput = ({ initialSearchText = "", searchOrigin, onSearchSubmit }) => {
+	const track = (0, jotai.useAtomValue)(require_amplitudeTrackEventAtom.amplitudeTrackEventAtom);
+	const [searchText, setSearchText] = (0, react.useState)(initialSearchText);
+	const [hasText, setHasText] = (0, react.useState)(initialSearchText.trim().length > 0);
+	const [isFocused, setIsFocused] = (0, react.useState)(false);
+	const [focusedIndex, setFocusedIndex] = (0, react.useState)(-1);
+	const [focusedOptionId, setFocusedOptionId] = (0, react.useState)(void 0);
+	const globalAutocompleteResults = (0, jotai.useAtomValue)(require_globalSearch.autocompleteStateAtom).results;
+	const isAutocompleteEnabled = globalAutocompleteResults.length > 0;
+	const isSelectingAutocomplete = (0, react.useRef)(false);
+	const shouldShowAutocomplete = hasText && isFocused && isAutocompleteEnabled;
+	const autocompleteResultsLimit = 5;
+	const fuseOptions = (0, react.useMemo)(() => ({
+		includeScore: true,
+		includeMatches: true,
+		threshold: .3,
+		location: 0,
+		distance: 4,
+		minMatchCharLength: 1,
+		keys: [],
+		useExtendedSearch: false,
+		ignoreLocation: false
+	}), []);
+	const fuse = (0, react.useMemo)(() => {
+		if (!globalAutocompleteResults.length) return null;
+		return new fuse_js.default(globalAutocompleteResults, fuseOptions);
+	}, [globalAutocompleteResults, fuseOptions]);
+	const autocompleteResults = (0, react.useMemo)(() => {
+		if (!isAutocompleteEnabled || !fuse) return [];
+		if (!searchText.trim()) return [];
+		return fuse.search(searchText).slice(0, autocompleteResultsLimit).map((result) => result.item);
+	}, [
+		isAutocompleteEnabled,
+		fuse,
+		searchText,
+		autocompleteResultsLimit
+	]);
+	const handleSearchInputChange = (0, react.useCallback)((newValue) => {
+		if (newValue !== searchText) setIsFocused(true);
+		if (newValue.length === 1) track?.({
+			eventName: require_amplitudeContext.SpiffyMetricsEventName.SearchInputStarted,
+			eventProps: { searchOrigin }
+		});
+		setSearchText(newValue);
+		setHasText(newValue.trim().length > 0);
+		setFocusedIndex(-1);
+		setFocusedOptionId(void 0);
+	}, [
+		searchOrigin,
+		searchText,
+		track
+	]);
+	const handleSearchInputFocus = (0, react.useCallback)(() => {
+		setIsFocused(true);
+	}, []);
+	const handleSearchInputBlur = (0, react.useCallback)(() => {
+		setTimeout(() => {
+			if (!isSelectingAutocomplete.current) {
+				setIsFocused(false);
+				setFocusedIndex(-1);
+				setFocusedOptionId(void 0);
+			}
+		}, 150);
+	}, []);
+	const handleSubmitSearch = (0, react.useCallback)(() => {
+		setIsFocused(false);
+		if (searchText.trim() && onSearchSubmit) {
+			track?.({
+				eventName: require_amplitudeContext.SpiffyMetricsEventName.SearchQuerySubmitted,
+				eventProps: {
+					searchOrigin,
+					queryText: searchText.trim()
+				},
+				alsoSendToGoogleAnalytics: true
+			});
+			onSearchSubmit(searchText.trim());
+		}
+	}, [
+		searchText,
+		onSearchSubmit,
+		searchOrigin,
+		track
+	]);
+	const handleAutocompleteSelect = (0, react.useCallback)((suggestion, rankPosition) => {
+		isSelectingAutocomplete.current = true;
+		setSearchText(suggestion);
+		setHasText(suggestion.trim().length > 0);
+		setIsFocused(false);
+		track?.({
+			eventName: require_amplitudeContext.SpiffyMetricsEventName.SearchInputStarted,
+			eventProps: { searchOrigin }
+		});
+		if (onSearchSubmit) onSearchSubmit(suggestion.trim());
+		setTimeout(() => {
+			isSelectingAutocomplete.current = false;
+		}, 100);
+	}, [
+		onSearchSubmit,
+		searchOrigin,
+		track
+	]);
+	return {
+		searchText,
+		hasText,
+		isFocused,
+		focusedIndex,
+		focusedOptionId,
+		autocompleteResults,
+		shouldShowAutocomplete,
+		handleSearchInputChange,
+		handleSearchInputFocus,
+		handleSearchInputBlur,
+		handleKeyDown: (0, react.useCallback)((event) => {
+			if (event.key === "ArrowDown") {
+				event.preventDefault();
+				const newIndex = (focusedIndex + 1) % autocompleteResults.length;
+				setFocusedIndex(newIndex);
+				setFocusedOptionId(`option-${newIndex}`);
+			} else if (event.key === "ArrowUp") {
+				event.preventDefault();
+				const newIndex = (focusedIndex - 1 + autocompleteResults.length) % autocompleteResults.length;
+				setFocusedIndex(newIndex);
+				setFocusedOptionId(`option-${newIndex}`);
+			} else if (event.key === "Enter") if (focusedIndex === -1) {
+				event.preventDefault();
+				handleSubmitSearch();
+			} else {
+				event.preventDefault();
+				const suggestionText = autocompleteResults[focusedIndex];
+				handleAutocompleteSelect(suggestionText, focusedIndex);
+			}
+			else if (event.key === "Escape") {
+				event.preventDefault();
+				setFocusedIndex(-1);
+				setFocusedOptionId(void 0);
+			}
+		}, [
+			autocompleteResults,
+			focusedIndex,
+			handleAutocompleteSelect,
+			handleSubmitSearch
+		]),
+		handleAutocompleteSelect,
+		handleSubmitSearch,
+		setSearchText: (0, react.useCallback)((text) => {
+			setSearchText(text);
+			setHasText(text.trim().length > 0);
+		}, []),
+		resetSearch: (0, react.useCallback)(() => {
+			setSearchText("");
+			setHasText(false);
+			setIsFocused(false);
+			setFocusedIndex(-1);
+			setFocusedOptionId(void 0);
+		}, [])
+	};
+};
+
+//#endregion
+exports.useSearchInput = useSearchInput;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"useSearchInput.cjs","names":["amplitudeTrackEventAtom","autocompleteStateAtom","Fuse","SpiffyMetricsEventName"],"sources":["../../../src/hooks/Search/useSearchInput.ts"],"sourcesContent":["import { useState, useCallback, useRef, useMemo } from 'react';\nimport { useAtomValue } from 'jotai';\nimport Fuse from 'fuse.js';\n\nimport { autocompleteStateAtom } from 'src/atoms/globalSearch';\nimport { amplitudeTrackEventAtom } from 'src/atoms/amplitude/amplitudeTrackEventAtom';\nimport { SpiffyMetricsEventName } from 'src/contexts/amplitudeContext';\nimport { SpiffyWidgets } from 'src/application/models/spiffyWidgets';\n\nexport interface UseSearchInputProps {\n  initialSearchText?: string;\n  searchOrigin: SpiffyWidgets;\n  onSearchSubmit?: (query: string) => void;\n}\n\nexport interface UseSearchInputReturn {\n  // State\n  searchText: string;\n  hasText: boolean;\n  isFocused: boolean;\n  focusedIndex: number;\n  focusedOptionId: string | undefined;\n  autocompleteResults: string[];\n  shouldShowAutocomplete: boolean;\n\n  // Handlers\n  handleSearchInputChange: (value: string) => void;\n  handleSearchInputFocus: () => void;\n  handleSearchInputBlur: () => void;\n  handleKeyDown: (event: React.KeyboardEvent<HTMLInputElement>) => void;\n  handleAutocompleteSelect: (suggestion: string, rankPosition?: number) => void;\n  handleSubmitSearch: () => void;\n\n  // Utilities\n  setSearchText: (text: string) => void;\n  resetSearch: () => void;\n}\n\nexport const useSearchInput = ({\n  initialSearchText = '',\n  searchOrigin,\n  onSearchSubmit,\n}: UseSearchInputProps): UseSearchInputReturn => {\n  const track = useAtomValue(amplitudeTrackEventAtom);\n\n  // State\n  const [searchText, setSearchText] = useState(initialSearchText);\n  const [hasText, setHasText] = useState(initialSearchText.trim().length > 0);\n  const [isFocused, setIsFocused] = useState(false);\n  const [focusedIndex, setFocusedIndex] = useState(-1);\n  const [focusedOptionId, setFocusedOptionId] = useState<string | undefined>(undefined);\n  const autocompleteState = useAtomValue(autocompleteStateAtom);\n  const globalAutocompleteResults = autocompleteState.results;\n  const isAutocompleteEnabled = globalAutocompleteResults.length > 0;\n\n  // Refs\n  const isSelectingAutocomplete = useRef(false);\n\n  // Computed\n  const shouldShowAutocomplete = hasText && isFocused && isAutocompleteEnabled;\n\n  const autocompleteResultsLimit = 5;\n\n  // Configure Fuse.js for fuzzy search with custom scoring\n  const fuseOptions = useMemo(\n    () => ({\n      includeScore: true,\n      includeMatches: true,\n      // Fuzzy matching threshold (0.0 = perfect match, 1.0 = match anything)\n      threshold: 0.3,\n      // Location where match is expected (0 = beginning)\n      location: 0,\n      // Distance from location where match can be found - smaller for prefix preference\n      distance: 4,\n      // Minimum character length before fuzzy matching starts\n      minMatchCharLength: 1,\n      // Keys to search (we're searching strings directly, so no keys needed)\n      keys: [],\n      // Use extended search for exact matches and prefix matching\n      useExtendedSearch: false,\n      // Don't ignore location - this helps prioritize matches at the beginning\n      ignoreLocation: false,\n    }),\n    [],\n  );\n\n  const fuse = useMemo(() => {\n    if (!globalAutocompleteResults.length) return null;\n    return new Fuse(globalAutocompleteResults, fuseOptions);\n  }, [globalAutocompleteResults, fuseOptions]);\n\n  // Autocomplete fuzzy search using Fuse.js\n  const autocompleteResults = useMemo(() => {\n    if (!isAutocompleteEnabled || !fuse) {\n      return [];\n    }\n\n    if (!searchText.trim()) {\n      return [];\n    }\n\n    const fuseResults = fuse.search(searchText);\n\n    // Use only Fuse.js scoring (results are already sorted by relevance)\n    return fuseResults.slice(0, autocompleteResultsLimit).map(result => result.item);\n  }, [isAutocompleteEnabled, fuse, searchText, autocompleteResultsLimit]);\n\n  // Handlers\n  const handleSearchInputChange = useCallback(\n    (newValue: string) => {\n      // If the user is changing text, they must be interacting with the input\n      // So we can safely assume they're focused\n      if (newValue !== searchText) {\n        setIsFocused(true);\n      }\n\n      if (newValue.length === 1) {\n        track?.({\n          eventName: SpiffyMetricsEventName.SearchInputStarted,\n          eventProps: {\n            searchOrigin,\n          },\n        });\n      }\n      setSearchText(newValue);\n      setHasText(newValue.trim().length > 0);\n      setFocusedIndex(-1);\n      setFocusedOptionId(undefined);\n    },\n    [searchOrigin, searchText, track],\n  );\n\n  const handleSearchInputFocus = useCallback(() => {\n    setIsFocused(true);\n  }, []);\n\n  const handleSearchInputBlur = useCallback(() => {\n    setTimeout(() => {\n      if (!isSelectingAutocomplete.current) {\n        setIsFocused(false);\n        setFocusedIndex(-1);\n        setFocusedOptionId(undefined);\n      }\n    }, 150);\n  }, []);\n\n  const handleSubmitSearch = useCallback(() => {\n    setIsFocused(false);\n    if (searchText.trim() && onSearchSubmit) {\n      track?.({\n        eventName: SpiffyMetricsEventName.SearchQuerySubmitted,\n        eventProps: {\n          searchOrigin,\n          queryText: searchText.trim(),\n        },\n        alsoSendToGoogleAnalytics: true,\n      });\n      onSearchSubmit(searchText.trim());\n    }\n  }, [searchText, onSearchSubmit, searchOrigin, track]);\n\n  const handleAutocompleteSelect = useCallback(\n    (suggestion: string, rankPosition?: number) => {\n      isSelectingAutocomplete.current = true;\n      setSearchText(suggestion);\n      setHasText(suggestion.trim().length > 0);\n      setIsFocused(false);\n\n      track?.({\n        eventName: SpiffyMetricsEventName.SearchInputStarted,\n        eventProps: {\n          searchOrigin,\n        },\n      });\n\n      if (onSearchSubmit) {\n        onSearchSubmit(suggestion.trim());\n      }\n\n      setTimeout(() => {\n        isSelectingAutocomplete.current = false;\n      }, 100);\n    },\n    [onSearchSubmit, searchOrigin, track],\n  );\n\n  const handleKeyDown = useCallback(\n    (event: React.KeyboardEvent<HTMLInputElement>) => {\n      if (event.key === 'ArrowDown') {\n        event.preventDefault();\n        const newIndex = (focusedIndex + 1) % autocompleteResults.length;\n        setFocusedIndex(newIndex);\n        setFocusedOptionId(`option-${newIndex}`);\n      } else if (event.key === 'ArrowUp') {\n        event.preventDefault();\n        const newIndex =\n          (focusedIndex - 1 + autocompleteResults.length) % autocompleteResults.length;\n        setFocusedIndex(newIndex);\n        setFocusedOptionId(`option-${newIndex}`);\n      } else if (event.key === 'Enter') {\n        if (focusedIndex === -1) {\n          event.preventDefault();\n          handleSubmitSearch();\n        } else {\n          event.preventDefault();\n          const suggestionText = autocompleteResults[focusedIndex];\n          handleAutocompleteSelect(suggestionText, focusedIndex);\n        }\n      } else if (event.key === 'Escape') {\n        event.preventDefault();\n        setFocusedIndex(-1);\n        setFocusedOptionId(undefined);\n      }\n    },\n    [autocompleteResults, focusedIndex, handleAutocompleteSelect, handleSubmitSearch],\n  );\n\n  const setSearchTextUtility = useCallback((text: string) => {\n    setSearchText(text);\n    setHasText(text.trim().length > 0);\n  }, []);\n\n  const resetSearch = useCallback(() => {\n    setSearchText('');\n    setHasText(false);\n    setIsFocused(false);\n    setFocusedIndex(-1);\n    setFocusedOptionId(undefined);\n  }, []);\n\n  return {\n    // State\n    searchText,\n    hasText,\n    isFocused,\n    focusedIndex,\n    focusedOptionId,\n    autocompleteResults,\n    shouldShowAutocomplete,\n\n    // Handlers\n    handleSearchInputChange,\n    handleSearchInputFocus,\n    handleSearchInputBlur,\n    handleKeyDown,\n    handleAutocompleteSelect,\n    handleSubmitSearch,\n\n    // Utilities\n    setSearchText: setSearchTextUtility,\n    resetSearch,\n  };\n};\n"],"mappings":"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"}