@envive-ai/react-hooks 0.2.6 → 0.2.7-arthur-1

package/src/hooks/Search/useSearchInput.ts

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

package/src/types/FilterAttribute.ts

@@ -0,0 +1,35 @@
+// TODO: These are duplicated types. Right now, since this uses discriminated unions, they don't export from the types
+// library properly. Can be fixed by refactoring the current approach use the right method is decided upon.
+
+interface AlphabeticFilterSorting {
+  type: "alphabetic";
+}
+interface ProductCountFilterSorting {
+  type: "productCount";
+}
+interface CustomFilterSorting {
+  type: "custom";
+  map: Record<string, number>;
+}
+
+type FilterSorting =
+  | AlphabeticFilterSorting
+  | ProductCountFilterSorting
+  | CustomFilterSorting;
+
+interface BaseFilterConfig {
+  filterId: string;
+  displayName: string;
+}
+
+interface PriceFilterConfig extends BaseFilterConfig {
+  type: "price";
+  bucketSize: number;
+}
+interface DynamicFilterConfig extends BaseFilterConfig {
+  type: "dynamic";
+  attribute: string;
+  sorting: FilterSorting;
+}
+
+export type FilterAttribute = DynamicFilterConfig | PriceFilterConfig;

package/dist/graphql-OkhsP4ir.js

@@ -1,36 +0,0 @@
-import { getQueryParam } from "./urlsParser-DLCzibqU.js";
-
-//#region src/types/config-versions.ts
-const configVersion = () => getQueryParam("spiffy_config_version") || getQueryParam("envive_config_version") || "deployed";
-
-//#endregion
-//#region src/application/models/graphql/queries/getMerchantFrontendConfigQuery.ts
-const getMerchantFrontendConfigQuery = () => `
-  query ($version: "${configVersion()}") {
-    me {
-      getProductsConfigByVersion(version: $version) {
-        frontend {
-          values
-        }
-      }
-    }
-  }
-`;
-
-//#endregion
-//#region src/application/models/graphql/queries/getMerchantColorsQuery.ts
-const getMerchantColorsQuery = () => `
-  query ($version: "${configVersion()}") {
-    me {
-      getProductsConfigByVersion(version: $version) {
-        colors {
-          values
-        }
-      }
-    }
-  }
-`;
-
-//#endregion
-export { configVersion, getMerchantColorsQuery, getMerchantFrontendConfigQuery };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/graphql-l4dQrsA6.cjs

@@ -1,53 +0,0 @@
-const require_urlsParser = require('./urlsParser-DhcEZLc_.cjs');
-
-//#region src/types/config-versions.ts
-const configVersion = () => require_urlsParser.getQueryParam("spiffy_config_version") || require_urlsParser.getQueryParam("envive_config_version") || "deployed";
-
-//#endregion
-//#region src/application/models/graphql/queries/getMerchantFrontendConfigQuery.ts
-const getMerchantFrontendConfigQuery = () => `
-  query ($version: "${configVersion()}") {
-    me {
-      getProductsConfigByVersion(version: $version) {
-        frontend {
-          values
-        }
-      }
-    }
-  }
-`;
-
-//#endregion
-//#region src/application/models/graphql/queries/getMerchantColorsQuery.ts
-const getMerchantColorsQuery = () => `
-  query ($version: "${configVersion()}") {
-    me {
-      getProductsConfigByVersion(version: $version) {
-        colors {
-          values
-        }
-      }
-    }
-  }
-`;
-
-//#endregion
-Object.defineProperty(exports, 'configVersion', {
-  enumerable: true,
-  get: function () {
-    return configVersion;
-  }
-});
-Object.defineProperty(exports, 'getMerchantColorsQuery', {
-  enumerable: true,
-  get: function () {
-    return getMerchantColorsQuery;
-  }
-});
-Object.defineProperty(exports, 'getMerchantFrontendConfigQuery', {
-  enumerable: true,
-  get: function () {
-    return getMerchantFrontendConfigQuery;
-  }
-});
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/index-Bmub8e38.d.cts

@@ -1,98 +0,0 @@
-//#region src/application/models/graphql/queries/getMerchantFrontendConfigQuery.d.ts
-declare const getMerchantFrontendConfigQuery: () => string;
-type MountingConfigQueryData = {
-  mounting_config_id?: string;
-  container_id?: string;
-  check_id?: string;
-  parent_insertion_point?: {
-    selector?: string;
-    selection_index?: number;
-    insertion_type?: string;
-  };
-  insertion_point?: {
-    selector?: string;
-    selection_index?: number;
-    insertion_type?: string;
-  };
-  grid_insertion_type?: string;
-  wrapping_element?: {
-    class_name?: string;
-    element?: string;
-    insertion_type?: string;
-  };
-  div_check_selector?: string;
-  suppression_selector?: string;
-  style?: Record<string, string | number>;
-  class_name?: string;
-  data_attributes?: Record<string, string>;
-};
-type WidgetConfigQueryData = {
-  widget_config_id: string;
-  type: string;
-  content_id?: string;
-  [key: string]: unknown;
-};
-type PageVariantCheckQueryData = {
-  check_type: string;
-  [key: string]: unknown;
-};
-type WidgetMountingQueryData = {
-  mounting_config_id: string;
-  widget_config_id?: string;
-  mounting_point_widgets?: Array<{
-    checks: PageVariantCheckQueryData[];
-    widget_config_id: string;
-  }>;
-};
-type PageVariantQueryData = {
-  variant_id: string;
-  variant_type: string;
-  variant_checks: PageVariantCheckQueryData[];
-  widget_mounting: WidgetMountingQueryData[];
-  plp_id_extractor?: string;
-  product_id_extractor?: string;
-  parent_product_id_extractor?: string;
-};
-type UIConfigQueryData = {
-  shortName: string;
-  [key: string]: unknown;
-};
-interface GetMerchantFrontendConfigQueryData {
-  merchant_override_css?: string;
-  page_variants?: PageVariantQueryData[];
-  mounting_configs?: {
-    key: string;
-    config: MountingConfigQueryData;
-  }[];
-  widget_configs?: {
-    key: string;
-    config: WidgetConfigQueryData;
-  }[];
-  ui_configs?: UIConfigQueryData;
-}
-//#endregion
-//#region src/application/models/graphql/queries/getMerchantColorsQuery.d.ts
-declare const getMerchantColorsQuery: () => string;
-interface GetMerchantColorsQueryData {
-  accent_primary: string;
-  accent_secondary: string;
-  background_dark: string;
-  background_light: string;
-  background_primary: string;
-  background_saturated: string;
-  background_secondary: string;
-  background_secondary_dark: string;
-  background_tertiary: string;
-  border_dark: string;
-  border_light: string;
-  border_medium: string;
-  border_outline: string;
-  text_accent: string;
-  text_light: string;
-  text_link: string;
-  text_primary: string;
-  text_secondary: string;
-}
-//#endregion
-export { type GetMerchantColorsQueryData, type GetMerchantFrontendConfigQueryData, type MountingConfigQueryData, type PageVariantCheckQueryData, type PageVariantQueryData, type UIConfigQueryData, type WidgetConfigQueryData, type WidgetMountingQueryData, getMerchantColorsQuery, getMerchantFrontendConfigQuery };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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