@envive-ai/react-hooks 0.2.10 → 0.2.11

package/src/atoms/search/chatSearch.ts

@@ -1,66 +1,55 @@
-import { UserEventCategory } from "@spiffy-ai/commerce-api-client";
-import { v4 as uuid } from "uuid";
-import { atom } from "jotai";
+import { UserEventCategory } from '@spiffy-ai/commerce-api-client';
+import { v4 as uuid } from 'uuid';
+import { atom } from 'jotai';
 import {
   Message,
   MessageRole,
   MessageType,
   ProductResponseAttributes,
-} from "src/application/models";
+} from 'src/application/models';
 import {
   messagesAtom,
   replyEventCategoryAtom,
   userHasRepliedAtom,
   userQueryAtom,
-} from "src/atoms/chat";
-import { queueUserEventAtom } from "../chat/messageQueue";
-import { newOrgConfigAtom } from "../org";
-import { ProductFilters } from "./productFilters";
-import { ProductSorter } from "./productSorter";
-import { ChatSearchStateType, ProductSorting } from "./types";
+} from 'src/atoms/chat';
+import { queueUserEventAtom } from '../chat/messageQueue';
+import { newOrgConfigAtom } from '../org';
+import { ProductFilters } from './productFilters';
+import { ProductSorter } from './productSorter';
+import { ChatSearchStateType, ProductSorting } from './types';
 
 // NOTE:
 // This is a legacy version of search that needs to be decoupled and removed.
 // the new search.ts file in this directory is likely what you're looking for.
 
-export const chatSearchStateAtom = atom<ChatSearchStateType>("entrypoint");
+export const chatSearchStateAtom = atom<ChatSearchStateType>('entrypoint');
 export const chatSearchHasProductsAtom = atom<boolean>(false);
-export const chatSearchProductSortingAtom = atom<ProductSorting>(
-  ProductSorting.FEATURED
-);
+export const chatSearchProductSortingAtom = atom<ProductSorting>(ProductSorting.FEATURED);
 
 const filterProductList = (message: Message) =>
   message.type === MessageType.Product && message.metadata.isForGrid === true;
-const filterFilterList = (message: Message) =>
-  message.type === MessageType.ProductSearchFilter;
+const filterFilterList = (message: Message) => message.type === MessageType.ProductSearchFilter;
 
 export type ChatSearchTurn = {
   id: string;
   generatedQuery?: string;
   productCount: number;
-  productList: ProductResponseAttributes["attributes"][];
+  productList: ProductResponseAttributes['attributes'][];
   filterList: string[];
   messages: Message[];
 };
 
 export const chatSearchIsLoadingAtom = atom(false);
 
-const buildChatSearchTurn = (
-  messages: Message[]
-): [string, ChatSearchTurn] | null => {
-  const queryMessage = messages.find(
-    (message) => message.type === MessageType.ProductSearch
-  );
+const buildChatSearchTurn = (messages: Message[]): [string, ChatSearchTurn] | null => {
+  const queryMessage = messages.find(message => message.type === MessageType.ProductSearch);
   if (!queryMessage) {
     return null;
   }
   const { generatedQuery, productCount } = queryMessage.metadata ?? {};
-  const productList = messages
-    .filter(filterProductList)
-    .map((message) => (message as any).metadata);
-  const filterList = messages
-    .filter(filterFilterList)
-    .map((message) => message.metadata.filterName);
+  const productList = messages.filter(filterProductList).map(message => (message as any).metadata);
+  const filterList = messages.filter(filterFilterList).map(message => message.metadata.filterName);
   return [
     queryMessage.id,
     {
@@ -74,19 +63,14 @@ const buildChatSearchTurn = (
   ];
 };
 
-const chatSearchFilterConfigAtom = atom((get) => {
+const chatSearchFilterConfigAtom = atom(get => {
   const newOrgConfig = get(newOrgConfigAtom);
-  return (
-    newOrgConfig?.frontendConfig?.uiConfigs?.searchConfig?.searchFilterConfig ||
-    []
-  );
+  return newOrgConfig?.frontendConfig?.uiConfigs?.searchConfig?.searchFilterConfig || [];
 });
 
-const searchMapAtom = atom((get) => {
+const searchMapAtom = atom(get => {
   const messages = get(messagesAtom);
-  return Object.fromEntries(
-    messages.map(buildChatSearchTurn).filter((v) => v !== null)
-  );
+  return Object.fromEntries(messages.map(buildChatSearchTurn).filter(v => v !== null));
 });
 
 const internalChatSearchParamsAtom = atom<{
@@ -105,22 +89,17 @@ export type SelectedChatSearchFilterOption = {
   filterItemId: string; // Filter value
 };
 
-export const selectedFilterOptionsAtom = atom<SelectedChatSearchFilterOption[]>(
-  []
-);
+export const selectedFilterOptionsAtom = atom<SelectedChatSearchFilterOption[]>([]);
 
-export const additiveDynamicFiltersAtom = atom((get) => {
+export const additiveDynamicFiltersAtom = atom(get => {
   const newOrgConfig = get(newOrgConfigAtom);
-  return (
-    newOrgConfig?.frontendConfig?.uiConfigs?.searchConfig
-      ?.additiveDynamicFilters ?? false
-  );
+  return newOrgConfig?.frontendConfig?.uiConfigs?.searchConfig?.additiveDynamicFilters ?? false;
 });
 
 export const createChatSearchFilterOption = (
   filterId: string,
   filterItemId: string,
-  displayName: string
+  displayName: string,
 ): SelectedChatSearchFilterOption => ({
   id: `${filterId}:${filterItemId}`,
   displayName,
@@ -153,29 +132,29 @@ const handleSearchAtom = atom(null, (get, set, message: Message) => {
 
 // This internal atom is used to store the search params
 export const chatSearchParamsAtom = atom(
-  (get) => get(internalChatSearchParamsAtom),
+  get => get(internalChatSearchParamsAtom),
   (_, set, value: { id: string | null; query: string | null }) => {
     set(internalChatSearchParamsAtom, value);
-  }
+  },
 );
 
 export const chatSearchQueryAtom = atom(
-  (get) => get(chatSearchParamsAtom)?.query ?? null,
+  get => get(chatSearchParamsAtom)?.query ?? null,
   (get, set, value: string | null) => {
     const searchParams = get(chatSearchParamsAtom);
     set(chatSearchParamsAtom, { id: searchParams.id, query: value });
-  }
+  },
 );
 
 export const chatSearchIdAtom = atom(
-  (get) => get(chatSearchParamsAtom)?.id ?? null,
+  get => get(chatSearchParamsAtom)?.id ?? null,
   (get, set, value: string | null) => {
     const searchParams = get(chatSearchParamsAtom);
     set(chatSearchParamsAtom, { id: value, query: searchParams.query });
-  }
+  },
 );
 
-export const ChatSearchTurnAtom = atom((get) => {
+export const ChatSearchTurnAtom = atom(get => {
   const searchFilterConfig = get(chatSearchFilterConfigAtom);
   const searchMap = get(searchMapAtom);
   const chatSearchId = get(chatSearchIdAtom);
@@ -193,13 +172,10 @@ export const ChatSearchTurnAtom = atom((get) => {
     ChatSearchTurn.productList,
     searchFilterConfig,
     selectedFilterOptions,
-    additiveDynamicFilters
+    additiveDynamicFilters,
   );
 
-  const filteredAndSortedProducts = ProductSorter.sort(
-    filteredProducts,
-    productSorting
-  );
+  const filteredAndSortedProducts = ProductSorter.sort(filteredProducts, productSorting);
 
   return {
     ...searchMap[chatSearchId],
@@ -209,12 +185,12 @@ export const ChatSearchTurnAtom = atom((get) => {
 });
 
 // TODO: Work on deprecating this atom in favor of using ChatSearchTurnAtom directly
-export const chatSearchProducts = atom((get) => {
+export const chatSearchProducts = atom(get => {
   const ChatSearchTurn = get(ChatSearchTurnAtom);
   return ChatSearchTurn?.productList ?? [];
 });
 
-export const chatSearchFiltersAtom = atom((get) => {
+export const chatSearchFiltersAtom = atom(get => {
   const searchFilterConfig = get(chatSearchFilterConfigAtom);
   const searchMap = get(searchMapAtom);
   const chatSearchId = get(chatSearchIdAtom);
@@ -225,7 +201,7 @@ export const chatSearchFiltersAtom = atom((get) => {
     return ProductFilters.getFiltersForProducts(
       products,
       searchFilterConfig,
-      selectedFilterOptions
+      selectedFilterOptions,
     );
   }
   return [];
@@ -238,16 +214,16 @@ export const chatSearchFiltersAtom = atom((get) => {
 
 export const setSearchParams = (query: string) => {
   const url = new URL(window.location.href);
-  url.searchParams.set("es", "true");
-  url.searchParams.set("esq", query);
-  window.history.pushState({}, "", url);
+  url.searchParams.set('es', 'true');
+  url.searchParams.set('esq', query);
+  window.history.pushState({}, '', url);
 };
 
 export const getSearchParamsAtom = atom(() => {
   const params = new URLSearchParams(window.location.search);
   return {
-    es: params.get("es"),
-    esq: params.get("esq"),
+    es: params.get('es'),
+    esq: params.get('esq'),
   };
 });
 
@@ -255,13 +231,13 @@ export const initiateChatSearchAtom = atom(null, (_, set, query: string) => {
   set(chatSearchIsLoadingAtom, true);
   // Update URL and manually trigger state change (since pushState doesn't trigger popstate)
   const url = new URL(window.location.href);
-  url.searchParams.set("es", "true");
-  url.searchParams.set("esq", query);
-  window.history.pushState({}, "", url);
+  url.searchParams.set('es', 'true');
+  url.searchParams.set('esq', query);
+  window.history.pushState({}, '', url);
 
   // Manually trigger page variant re-evaluation by dispatching a popstate event
   // This ensures the page variant system detects the URL change and mounts search results
-  window.dispatchEvent(new PopStateEvent("popstate", { state: {} }));
+  window.dispatchEvent(new PopStateEvent('popstate', { state: {} }));
 
   set(chatSearchParamsAtom, { id: null, query });
   set(handleSearchAtom, {
@@ -277,41 +253,38 @@ export const initiateChatSearchAtom = atom(null, (_, set, query: string) => {
   });
 });
 
-export const handleSearchResultsAtom = atom(
-  null,
-  (get, set, message: Message | undefined) => {
-    if (!message || message.type !== MessageType.ProductSearch) {
-      return;
-    }
+export const handleSearchResultsAtom = atom(null, (get, set, message: Message | undefined) => {
+  if (!message || message.type !== MessageType.ProductSearch) {
+    return;
+  }
 
-    const { productCount, generatedQuery } = message.metadata;
-    if (productCount !== 0) {
-      // Clear the filter options when we get new products
-      set(selectedFilterOptionsAtom, []);
-      // TODO: Should we still do any of these things?
-      set(chatSearchStateAtom, "product-page");
-      const currentSearchParams = get(chatSearchParamsAtom);
-      const url = new URL(window.location.href);
-      url.searchParams.set("es", "true");
-      url.searchParams.set("esq", generatedQuery);
-      url.searchParams.set("esi", message.id);
-      window.history.pushState({}, "", url);
-      if (currentSearchParams.id === null) {
-        // If the id is null, we need to replace the state
-        window.history.replaceState(null, "", url);
-      } else {
-        // If the query is different, we need to push a new state
-        window.history.pushState(null, "", url);
-      }
-      set(chatSearchParamsAtom, { id: message.id, query: generatedQuery });
+  const { productCount, generatedQuery } = message.metadata;
+  if (productCount !== 0) {
+    // Clear the filter options when we get new products
+    set(selectedFilterOptionsAtom, []);
+    // TODO: Should we still do any of these things?
+    set(chatSearchStateAtom, 'product-page');
+    const currentSearchParams = get(chatSearchParamsAtom);
+    const url = new URL(window.location.href);
+    url.searchParams.set('es', 'true');
+    url.searchParams.set('esq', generatedQuery);
+    url.searchParams.set('esi', message.id);
+    window.history.pushState({}, '', url);
+    if (currentSearchParams.id === null) {
+      // If the id is null, we need to replace the state
+      window.history.replaceState(null, '', url);
+    } else {
+      // If the query is different, we need to push a new state
+      window.history.pushState(null, '', url);
     }
+    set(chatSearchParamsAtom, { id: message.id, query: generatedQuery });
   }
-);
+});
 
 export const setChatSearchParamsAtom = atom(null, (_, set, query: string) => {
   const url = new URL(window.location.href);
-  url.searchParams.set("es", "true");
-  url.searchParams.set("esq", query);
-  window.history.pushState({}, "", url);
+  url.searchParams.set('es', 'true');
+  url.searchParams.set('esq', query);
+  window.history.pushState({}, '', url);
   set(chatSearchParamsAtom, { id: null, query });
 });

package/src/atoms/search/productFilters.ts

@@ -13,7 +13,7 @@ const isStringArray = (value: unknown): value is string[] => {
   if (!Array.isArray(value)) {
     return false;
   }
-  return value.every((item) => typeof item === 'string');
+  return value.every(item => typeof item === 'string');
 };
 
 type FilterSortFunction = (a: ChatSearchFilterItem, b: ChatSearchFilterItem) => number;
@@ -66,7 +66,7 @@ export class ProductFilters {
       return [];
     }
 
-    const filters = filterConfigs.map((filterConfig) =>
+    const filters = filterConfigs.map(filterConfig =>
       products.reduce(
         (acc, product) => {
           // Price has special handling for the filters
@@ -88,7 +88,7 @@ export class ProductFilters {
           const attributeValues =
             (product.filters && product.filters?.[filterConfig.attribute]) ?? [];
           if (isStringArray(attributeValues)) {
-            attributeValues.forEach((val) => {
+            attributeValues.forEach(val => {
               const normalizedVal = val.toLowerCase();
               const current = acc.map[normalizedVal] ?? {
                 filterItemId: normalizedVal,
@@ -112,13 +112,13 @@ export class ProductFilters {
       filterId: filterConfig.filterId,
       displayName: filterConfig.displayName,
       items: Object.values(map)
-        .map((filter) => ({
+        .map(filter => ({
           filterItemId: filter.filterItemId,
           displayName: filter.displayName,
           productCount: filter.productCount,
           isSelected:
             selectedFilterOptions.some(
-              (option) => option.id === `${filterConfig.filterId}:${filter.filterItemId}`,
+              option => option.id === `${filterConfig.filterId}:${filter.filterItemId}`,
             ) ?? false,
         }))
         .sort(sortFilter(filterConfig)),
@@ -134,16 +134,16 @@ export class ProductFilters {
     additiveDynamicFilters = false, // Set this to true to restore the original behavior where stacking filters has OR logic.
   ) {
     const selectedFilters = filterConfigs
-      .map((filterConfig) => ({
+      .map(filterConfig => ({
         filterConfig,
         hasSelectedOptions: selectedFilterOptions.some(
-          (option) => option.filterId === filterConfig.filterId,
+          option => option.filterId === filterConfig.filterId,
         ),
       }))
       .filter(({ hasSelectedOptions }) => hasSelectedOptions);
     return selectedFilterOptions.length === 0
       ? products
-      : products.filter((product) =>
+      : products.filter(product =>
           selectedFilters.reduce((acc, selectedFilter) => {
             // Finding one false removes the product
             if (!acc) {
@@ -156,7 +156,7 @@ export class ProductFilters {
                 selectedFilter.filterConfig.bucketSize,
               );
               const matchesPriceFilter = selectedFilterOptions.some(
-                (option) => option.id === `price:${priceBucket}`,
+                option => option.id === `price:${priceBucket}`,
               );
               if (!matchesPriceFilter) {
                 return false;
@@ -178,11 +178,11 @@ export class ProductFilters {
               if (isSubtractiveLogic) {
                 // AND logic for subtractive dynamic filters and between static filter categories
                 const selectedOptionsForThisFilter = selectedFilterOptions
-                  .filter((option) => option.filterId === filterId)
-                  .map((option) => option.filterItemId.toLowerCase());
+                  .filter(option => option.filterId === filterId)
+                  .map(option => option.filterItemId.toLowerCase());
 
-                const hasAllSelectedValues = selectedOptionsForThisFilter.every((selectedValue) =>
-                  attributeValues.some((val) => val.toLowerCase() === selectedValue),
+                const hasAllSelectedValues = selectedOptionsForThisFilter.every(selectedValue =>
+                  attributeValues.some(val => val.toLowerCase() === selectedValue),
                 );
 
                 if (!hasAllSelectedValues) {
@@ -190,9 +190,9 @@ export class ProductFilters {
                 }
               } else {
                 // OR logic for static filters in the sidebar within a category.
-                const matches = attributeValues.some((val) =>
+                const matches = attributeValues.some(val =>
                   selectedFilterOptions.some(
-                    (option) => option.id === `${filterId}:${val.toLowerCase()}`,
+                    option => option.id === `${filterId}:${val.toLowerCase()}`,
                   ),
                 );
                 if (!matches) {

package/src/atoms/search/productRetrievalAPI.ts

@@ -1,7 +1,6 @@
-
-import { atom } from "jotai";
-import { getProductRetrievalFunction } from "./productRetrievalAdapter";
-import { ProductRetrievalParams, ProductRetrievalResult } from "./types";
+import { atom } from 'jotai';
+import { getProductRetrievalFunction } from './productRetrievalAdapter';
+import { ProductRetrievalParams, ProductRetrievalResult } from './types';
 
 interface ProductRetrievalState {
   data: ProductRetrievalResult | null;
@@ -43,8 +42,7 @@ export const performProductRetrievalAtom = atom(
         lastProductIds: params.productIds,
       });
     } catch (error: unknown) {
-      const errorMessage =
-        error instanceof Error ? error.message : "An unknown error occurred";
+      const errorMessage = error instanceof Error ? error.message : 'An unknown error occurred';
       set(productRetrievalAtom, {
         data: null,
         loading: false,
@@ -52,19 +50,19 @@ export const performProductRetrievalAtom = atom(
         lastProductIds: params.productIds,
       });
     }
-  }
+  },
 );
 
 // Get just the products array (already normalized by service)
-export const retrievedProductsAtom = atom((get) => {
+export const retrievedProductsAtom = atom(get => {
   const retrievalData = get(productRetrievalAtom).data;
   return retrievalData?.products || [];
 });
 
-export const productRetrievalLoadingAtom = atom((get) => {
+export const productRetrievalLoadingAtom = atom(get => {
   return get(productRetrievalAtom).loading;
 });
 
-export const productRetrievalErrorAtom = atom((get) => {
+export const productRetrievalErrorAtom = atom(get => {
   return get(productRetrievalAtom).error;
-});
+});

package/src/atoms/search/productRetrievalAdapter.ts

@@ -1,4 +1,4 @@
-import { ProductRetrievalParams, ProductRetrievalResult } from "./types";
+import { ProductRetrievalParams, ProductRetrievalResult } from './types';
 
 // This will be set by the ProductRetrievalProvider when it initializes
 let productRetrievalFunction:
@@ -6,7 +6,7 @@ let productRetrievalFunction:
   | null = null;
 
 export const setProductRetrievalFunction = (
-  fn: (params: ProductRetrievalParams) => Promise<ProductRetrievalResult>
+  fn: (params: ProductRetrievalParams) => Promise<ProductRetrievalResult>,
 ) => {
   productRetrievalFunction = fn;
 };
@@ -14,7 +14,7 @@ export const setProductRetrievalFunction = (
 export const getProductRetrievalFunction = () => {
   if (!productRetrievalFunction) {
     throw new Error(
-      "Product retrieval function not initialized. Make sure ProductRetrievalProvider is mounted."
+      'Product retrieval function not initialized. Make sure ProductRetrievalProvider is mounted.',
     );
   }
   return productRetrievalFunction;
@@ -22,4 +22,4 @@ export const getProductRetrievalFunction = () => {
 
 export const clearProductRetrievalFunction = () => {
   productRetrievalFunction = null;
-};
+};