@envive-ai/react-hooks 0.2.10 → 0.3.0

package/dist/hooks/Search/useRecommendedProducts.js

@@ -0,0 +1,40 @@
+import { FeatureGates } from "../../application/models/featureGates.js";
+import "../../application/models/index.js";
+import { useFeatureFlagService } from "../../contexts/featureFlagServiceContext/featureFlagServiceContext.js";
+import { useNewOrgConfig } from "../NewOrgConfig/useNewOrgConfig.js";
+import "../NewOrgConfig/index.js";
+import { performProductRetrievalAtom, productRetrievalAtom, retrievedProductsAtom } from "../../atoms/search/productRetrievalAPI.js";
+import { useEffect } from "react";
+import { useAtomValue, useSetAtom } from "jotai";
+
+//#region src/hooks/Search/useRecommendedProducts.ts
+/**
+* A hook to get recommended products.
+* It checks the `IsRecommendedProductsEnabled` feature gate and triggers fetching if needed.
+* If the gate is enabled, it returns the list of recommended products.
+* If the gate is disabled, it returns an empty array.
+*
+* @returns The list of recommended products or an empty array.
+*/
+const useRecommendedProducts = () => {
+	const { featureFlagService } = useFeatureFlagService();
+	const isEnabled = featureFlagService?.isFeatureGateEnabled(FeatureGates.IsRecommendedProductsEnabled);
+	const recommendedProducts = useAtomValue(retrievedProductsAtom);
+	const performProductRetrieval = useSetAtom(performProductRetrievalAtom);
+	const { lastProductIds } = useAtomValue(productRetrievalAtom);
+	const orgUIConfig = useNewOrgConfig();
+	useEffect(() => {
+		const recommendedProductIds = orgUIConfig.frontendConfig?.uiConfigs?.searchConfig ? orgUIConfig.frontendConfig?.uiConfigs?.searchConfig.recommendedProducts : [];
+		if (isEnabled && recommendedProductIds && recommendedProductIds.length > 0 && !lastProductIds) performProductRetrieval({ productIds: recommendedProductIds });
+	}, [
+		isEnabled,
+		performProductRetrieval,
+		lastProductIds,
+		orgUIConfig
+	]);
+	return isEnabled ? recommendedProducts : [];
+};
+
+//#endregion
+export { useRecommendedProducts };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/hooks/Search/useSearch.cjs

@@ -0,0 +1,232 @@
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+const require_hooks_utils = require('../utils.cjs');
+const require_spiffyWidgets = require('../../application/models/spiffyWidgets.cjs');
+const require_enviveConfig = require('../../atoms/envive/enviveConfig.cjs');
+const require_amplitudeContext = require('../../contexts/amplitudeContext/amplitudeContext.cjs');
+const require_globalSearch = require('../../atoms/globalSearch/globalSearch.cjs');
+const require_atoms_search_utils = require('../../atoms/search/utils.cjs');
+const require_atoms_search_types = require('../../atoms/search/types.cjs');
+const require_searchAPI = require('../../atoms/search/searchAPI.cjs');
+require('../../atoms/search/index.cjs');
+const require_useNewOrgConfig = require('../NewOrgConfig/useNewOrgConfig.cjs');
+require('../NewOrgConfig/index.cjs');
+const require_useTrackComponentVisibleEvent = require('../TrackComponentVisibleEvent/useTrackComponentVisibleEvent.cjs');
+require('../TrackComponentVisibleEvent/index.cjs');
+const require_useSearchInput = require('./useSearchInput.cjs');
+const require_useRecommendedProducts = require('./useRecommendedProducts.cjs');
+let react = require("react");
+let jotai = require("jotai");
+
+//#region src/hooks/Search/useSearch.tsx
+const useSearch = ({ allowRedirect = false } = {}) => {
+	const config = require_useNewOrgConfig.useNewOrgConfig();
+	const orgShortName = (0, jotai.useAtomValue)(require_enviveConfig.orgShortNameAtom);
+	const { data: searchData, loading: isLoadingSearch } = (0, jotai.useAtomValue)(require_searchAPI.searchAtom);
+	const productList = (0, jotai.useAtomValue)(require_searchAPI.filteredSearchProductsAtom);
+	const performSearch = (0, jotai.useSetAtom)(require_searchAPI.performSearchAtom);
+	const [{ query }] = (0, jotai.useAtom)(require_searchAPI.searchParamsAtom);
+	const [isFilterOpen, setIsFilterOpen] = (0, jotai.useAtom)(require_globalSearch.isFilterOpenAtom);
+	const [selectedFilterOptions] = (0, jotai.useAtom)(require_searchAPI.searchSelectedFiltersAtom);
+	const addFilter = (0, jotai.useSetAtom)(require_searchAPI.addSearchFilterAtom);
+	const removeFilter = (0, jotai.useSetAtom)(require_searchAPI.removeSearchFilterAtom);
+	const [productSorting, setProductSorting] = (0, jotai.useAtom)(require_searchAPI.searchProductSortingAtom);
+	const clearFilters = (0, jotai.useSetAtom)(require_searchAPI.clearSearchFiltersAtom);
+	const searchFilters = (0, jotai.useAtomValue)(require_searchAPI.searchFiltersAtom);
+	const recommendedProducts = require_useRecommendedProducts.useRecommendedProducts();
+	const searchResultsRef = (0, react.useRef)(null);
+	const scrollToTop = (0, react.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 } = require_useSearchInput.useSearchInput({
+		initialSearchText: "",
+		searchOrigin: require_spiffyWidgets.SpiffyWidgets.SearchResults,
+		onSearchSubmit: (searchQuery) => {
+			performSearch({ query: searchQuery }, allowRedirect);
+		}
+	});
+	const searchResultsState = require_hooks_utils.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 = (0, react.useMemo)(() => {
+		return dynamicFilters.filter((dynamicFilterName) => !selectedFilterOptions.some((option) => option.id === `dynamic:${dynamicFilterName}`)).map((dynamicFilterName) => ({
+			name: dynamicFilterName,
+			displayName: require_atoms_search_utils.formatFilterDisplayName(dynamicFilterName)
+		}));
+	}, [dynamicFilters, selectedFilterOptions]);
+	const filters = (0, react.useMemo)(() => {
+		return [{
+			filterId: "sort",
+			displayName: "SORT",
+			items: [
+				{
+					filterItemId: String(require_atoms_search_types.ProductSorting.FEATURED),
+					displayName: "Relevance",
+					productCount: 0,
+					isSelected: productSorting === require_atoms_search_types.ProductSorting.FEATURED
+				},
+				{
+					filterItemId: String(require_atoms_search_types.ProductSorting.PRICE_ASC),
+					displayName: "Price: Low to High",
+					productCount: 0,
+					isSelected: productSorting === require_atoms_search_types.ProductSorting.PRICE_ASC
+				},
+				{
+					filterItemId: String(require_atoms_search_types.ProductSorting.PRICE_DESC),
+					displayName: "Price: High to Low",
+					productCount: 0,
+					isSelected: productSorting === require_atoms_search_types.ProductSorting.PRICE_DESC
+				}
+			]
+		}, ...searchFilters];
+	}, [productSorting, searchFilters]);
+	const filterButtonText = (0, react.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 } = require_amplitudeContext.useAmplitude();
+	const handleToggleDynamicFilter = (0, react.useCallback)(({ filter, dynamicFilterDisplayName }) => {
+		trackEvent({
+			eventName: require_amplitudeContext.SpiffyMetricsEventName.SearchFilterClicked,
+			eventProps: {
+				filterType: "Dynamic",
+				filterValue: filter,
+				queryText: searchText
+			}
+		});
+		addFilter(require_searchAPI.createFilterOption("dynamic", filter, dynamicFilterDisplayName));
+		scrollToTop();
+	}, [
+		addFilter,
+		searchText,
+		scrollToTop
+	]);
+	const handleRemoveFilter = (0, react.useCallback)((filter) => {
+		removeFilter(filter.id);
+		scrollToTop();
+	}, [removeFilter, scrollToTop]);
+	const handleSelectFilterItem = (0, react.useCallback)(({ filterId, filterItemId, isSelected, displayName }) => {
+		if (filterId === "sort") {
+			const newSort = filterItemId;
+			trackEvent({
+				eventName: require_amplitudeContext.SpiffyMetricsEventName.SearchSortClicked,
+				eventProps: {
+					sortType: newSort,
+					queryText: searchText
+				}
+			});
+			setProductSorting(newSort);
+			scrollToTop();
+		} else if (!isSelected) {
+			removeFilter(`${filterId}:${filterItemId}`);
+			scrollToTop();
+		} else {
+			trackEvent({
+				eventName: require_amplitudeContext.SpiffyMetricsEventName.SearchFilterClicked,
+				eventProps: {
+					filterType: "Static",
+					filterCategory: filterId,
+					filterValue: filterItemId,
+					queryText: searchText
+				}
+			});
+			addFilter(require_searchAPI.createFilterOption(filterId, filterItemId, displayName));
+			scrollToTop();
+		}
+	}, [
+		addFilter,
+		removeFilter,
+		setProductSorting,
+		searchText,
+		scrollToTop
+	]);
+	const handleClearAllFilters = (0, react.useCallback)(() => {
+		setProductSorting(require_atoms_search_types.ProductSorting.FEATURED);
+		clearFilters();
+		scrollToTop();
+	}, [
+		setProductSorting,
+		clearFilters,
+		scrollToTop
+	]);
+	require_useTrackComponentVisibleEvent.useTrackComponentVisibleEvent(require_spiffyWidgets.SpiffyWidgets.SearchResults, searchResultsRef, {}, require_amplitudeContext.SpiffyMetricsEventName.SearchComponentVisible);
+	(0, react.useEffect)(() => {
+		if (searchResultsState === require_hooks_utils.SearchResultsState.Results || searchResultsState === require_hooks_utils.SearchResultsState.NoResults) trackEvent({
+			eventName: require_amplitudeContext.SpiffyMetricsEventName.SearchResultsViewed,
+			eventProps: {
+				queryText: searchText,
+				resultsCount: productList.length
+			}
+		});
+	}, [productList.length, searchResultsState]);
+	(0, react.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
+exports.useSearch = useSearch;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"useSearch.cjs","names":["useNewOrgConfig","orgShortNameAtom","searchAtom","filteredSearchProductsAtom","performSearchAtom","searchParamsAtom","isFilterOpenAtom","searchSelectedFiltersAtom","addSearchFilterAtom","removeSearchFilterAtom","searchProductSortingAtom","clearSearchFiltersAtom","searchFiltersAtom","useRecommendedProducts","useSearchInput","SpiffyWidgets","getSearchResultsState","formatFilterDisplayName","ProductSorting","useAmplitude","SpiffyMetricsEventName","createFilterOption","handleSelectFilterItem: SelectFilterItem","SearchResultsState"],"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/useSearch.d.cts

@@ -0,0 +1,62 @@
+import { SearchResponseProductAttributes } from "../../application/models/api/response.cjs";
+import { ProductCardConfig } from "../../contexts/types.cjs";
+import { SearchResult } from "../../application/models/api/search.cjs";
+import { SelectedFilterOption } from "../../atoms/search/searchAPI.cjs";
+import { SearchFilterDatum, SelectFilterItem } from "../../types/search-filter-types.cjs";
+import { SearchResultsState } from "../utils.cjs";
+import { SearchResponseProduct } from "@spiffy-ai/commerce-api-client";
+
+//#region src/hooks/Search/useSearch.d.ts
+interface SearchResultsHocProps {
+  searchData: SearchResult | null;
+  searchResponseId: string;
+  merchantShortName: string;
+  productCardConfig: ProductCardConfig;
+  productList: SearchResponseProduct[];
+  autocompleteResults: string[];
+  searchFilters: SearchFilterDatum[];
+  availableDynamicFilters: {
+    name: string;
+    displayName: string;
+  }[];
+  selectedFilterOptions: SelectedFilterOption[];
+  recommendedProducts: SearchResponseProductAttributes['attributes'][];
+  recommendedProductsHeading: string;
+  searchOverlayHeading: string;
+  searchText: string;
+  query: string;
+  searchResultsState: SearchResultsState;
+  isLoadingSearch: boolean;
+  isFilterOpen: boolean;
+  shouldShowAutocomplete: boolean;
+  focusedIndex: number;
+  focusedOptionId: string | undefined;
+  filterButtonText: string;
+  onSearchInputChange: (value: string) => void;
+  onSubmitSearch: () => void;
+  onAutocompleteSelect: (suggestion: string) => void;
+  onKeyDown: (event: React.KeyboardEvent<HTMLInputElement>) => void;
+  onSearchInputFocus: () => void;
+  onSearchInputBlur: () => void;
+  onToggleDynamicFilter: ({
+    filter,
+    dynamicFilterDisplayName
+  }: {
+    filter: string;
+    dynamicFilterDisplayName: string;
+  }) => void;
+  onSelectFilterItem: SelectFilterItem;
+  onRemoveFilter: (filter: SelectedFilterOption) => void;
+  onClearAllFilters: () => void;
+  setIsFilterOpen: (isFilterOpen: boolean) => void;
+  resetSearch: () => void;
+  searchResultsRef: React.RefObject<HTMLDivElement>;
+}
+declare const useSearch: ({
+  allowRedirect
+}?: {
+  allowRedirect?: boolean;
+}) => SearchResultsHocProps;
+//#endregion
+export { SearchResultsHocProps, useSearch };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/hooks/Search/useSearch.d.ts

@@ -0,0 +1,62 @@
+import { SearchResponseProductAttributes } from "../../application/models/api/response.js";
+import { ProductCardConfig } from "../../contexts/types.js";
+import { SearchResult } from "../../application/models/api/search.js";
+import { SelectedFilterOption } from "../../atoms/search/searchAPI.js";
+import { SearchFilterDatum, SelectFilterItem } from "../../types/search-filter-types.js";
+import { SearchResultsState } from "../utils.js";
+import { SearchResponseProduct } from "@spiffy-ai/commerce-api-client";
+
+//#region src/hooks/Search/useSearch.d.ts
+interface SearchResultsHocProps {
+  searchData: SearchResult | null;
+  searchResponseId: string;
+  merchantShortName: string;
+  productCardConfig: ProductCardConfig;
+  productList: SearchResponseProduct[];
+  autocompleteResults: string[];
+  searchFilters: SearchFilterDatum[];
+  availableDynamicFilters: {
+    name: string;
+    displayName: string;
+  }[];
+  selectedFilterOptions: SelectedFilterOption[];
+  recommendedProducts: SearchResponseProductAttributes['attributes'][];
+  recommendedProductsHeading: string;
+  searchOverlayHeading: string;
+  searchText: string;
+  query: string;
+  searchResultsState: SearchResultsState;
+  isLoadingSearch: boolean;
+  isFilterOpen: boolean;
+  shouldShowAutocomplete: boolean;
+  focusedIndex: number;
+  focusedOptionId: string | undefined;
+  filterButtonText: string;
+  onSearchInputChange: (value: string) => void;
+  onSubmitSearch: () => void;
+  onAutocompleteSelect: (suggestion: string) => void;
+  onKeyDown: (event: React.KeyboardEvent<HTMLInputElement>) => void;
+  onSearchInputFocus: () => void;
+  onSearchInputBlur: () => void;
+  onToggleDynamicFilter: ({
+    filter,
+    dynamicFilterDisplayName
+  }: {
+    filter: string;
+    dynamicFilterDisplayName: string;
+  }) => void;
+  onSelectFilterItem: SelectFilterItem;
+  onRemoveFilter: (filter: SelectedFilterOption) => void;
+  onClearAllFilters: () => void;
+  setIsFilterOpen: (isFilterOpen: boolean) => void;
+  resetSearch: () => void;
+  searchResultsRef: React.RefObject<HTMLDivElement>;
+}
+declare const useSearch: ({
+  allowRedirect
+}?: {
+  allowRedirect?: boolean;
+}) => SearchResultsHocProps;
+//#endregion
+export { SearchResultsHocProps, useSearch };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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