@envive-ai/react-hooks 0.1.0 → 0.1.2

package/src/atoms/org/orgUIConfig.ts

@@ -1,11 +1,11 @@
-import { atom } from 'jotai';
-import { FeatureGates, getOrgInfo } from 'src/application/models';
-import { findCustomerServiceImpl } from 'src/application/service/customerService';
-import { CustomerServiceIntegrationMode } from 'src/application/service/customerService/types';
-import { featureFlagServiceAtom, orgShortNameAtom } from 'src/atoms/org/org';
-import { OrgUIConfig } from 'src/contexts/types';
-import { getAtomStore } from 'src/atoms/atomStore';
-import Logger from 'src/application/logging/logger';
+import { atom } from "jotai";
+import { FeatureGates, getOrgInfo } from "src/application/models";
+import { findCustomerServiceImpl } from "src/application/service/customerService";
+import { CustomerServiceIntegrationMode } from "src/application/service/customerService/types";
+import { featureFlagServiceAtom, orgShortNameAtom } from "src/atoms/org/org";
+import { OrgUIConfig } from "src/contexts/types";
+import { getAtomStore } from "src/atoms/atomStore/atomStore";
+import Logger from "src/application/logging/logger";
 
 const getCustomerServiceIntegrationMode = ({
   integrationMode,
@@ -18,7 +18,9 @@ const getCustomerServiceIntegrationMode = ({
     return integrationMode;
   }
   // Only allow CustomerServiceIntegrationMode.full if `isNewFeatureEnabled` is also true
-  return isNewFeatureEnabled ? integrationMode : CustomerServiceIntegrationMode.simple;
+  return isNewFeatureEnabled
+    ? integrationMode
+    : CustomerServiceIntegrationMode.simple;
 };
 
 const internalOrgUIConfigAtom = atom<OrgUIConfig | undefined>(undefined);
@@ -30,16 +32,16 @@ export const orgUIConfigAtom = atom(
       return orgUIConfig;
     }
 
-    throw new Error('OrgUIConfig is referenced before it is set');
+    throw new Error("OrgUIConfig is referenced before it is set");
   },
   (_, set, value: OrgUIConfig) => {
     set(internalOrgUIConfigAtom, value);
-  },
+  }
 );
 
 export const getOrgUIConfig = async (
-  graphqlOrgUIConfig?: Omit<OrgUIConfig, 'merchantOverrideCss'>,
-  graphqlMerchantOverrideCss?: string,
+  graphqlOrgUIConfig?: Omit<OrgUIConfig, "merchantOverrideCss">,
+  graphqlMerchantOverrideCss?: string
 ) => {
   const atomStore = getAtomStore();
   const orgShortName = atomStore.get(orgShortNameAtom);
@@ -47,18 +49,21 @@ export const getOrgUIConfig = async (
   const localOrgUIConfig = orgInfo.orgUIConfig() ?? {};
   const featureFlagService = atomStore.get(featureFlagServiceAtom);
   const isNewFeatureEnabled = featureFlagService.isFeatureGateEnabled(
-    FeatureGates.IsNewFeatureEnabled,
+    FeatureGates.IsNewFeatureEnabled
+  );
+  const enableWatermark = featureFlagService.isFeatureGateEnabled(
+    FeatureGates.IsWatermarkEnabled
   );
-  const enableWatermark = featureFlagService.isFeatureGateEnabled(FeatureGates.IsWatermarkEnabled);
   const userQueryAwaysEnabled = featureFlagService.isFeatureGateEnabled(
-    FeatureGates.IsUserQueryAlwaysEnabled,
+    FeatureGates.IsUserQueryAlwaysEnabled
   );
   const isGraphQLUIConfigsEnabled = featureFlagService.isFeatureGateEnabled(
-    FeatureGates.IsGraphQLUIConfigsEnabled,
-  );
-  const isGraphQLComponentConfigsEnabled = featureFlagService.isFeatureGateEnabled(
-    FeatureGates.IsGraphQLComponentConfigsEnabled,
+    FeatureGates.IsGraphQLUIConfigsEnabled
   );
+  const isGraphQLComponentConfigsEnabled =
+    featureFlagService.isFeatureGateEnabled(
+      FeatureGates.IsGraphQLComponentConfigsEnabled
+    );
 
   let orgUIConfig: Partial<OrgUIConfig> = { ...localOrgUIConfig };
 
@@ -76,7 +81,7 @@ export const getOrgUIConfig = async (
     };
   }
 
-  Logger.logInfo('[spiffy-ai] Feature gate enableWatermark check', {
+  Logger.logInfo("[spiffy-ai] Feature gate enableWatermark check", {
     enableWatermark,
     floatingChatConfig: orgUIConfig.floatingChatConfig,
   });
@@ -103,9 +108,11 @@ export const getOrgUIConfig = async (
       // Only enable the watermark if it is enabled in config and through featureFlag.
       // This enables a quick "off-switch" in case a merchant tells us to turn it off
       // quickly. This can be removed once the config is moved to the backend
-      enableWatermark: orgUIConfig.floatingChatConfig?.enableWatermark && enableWatermark,
+      enableWatermark:
+        orgUIConfig.floatingChatConfig?.enableWatermark && enableWatermark,
       userQueryInputEnabled:
-        orgUIConfig.floatingChatConfig?.userQueryInputEnabled || userQueryAwaysEnabled,
+        orgUIConfig.floatingChatConfig?.userQueryInputEnabled ||
+        userQueryAwaysEnabled,
     },
   } as OrgUIConfig;
 
@@ -113,7 +120,7 @@ export const getOrgUIConfig = async (
 };
 
 export const orgCustomerServiceConfig = atom(
-  (get) => get(orgUIConfigAtom).customerServiceIntegration,
+  (get) => get(orgUIConfigAtom).customerServiceIntegration
 );
 
 export const orgCustomerServiceService = atom((get) => {

package/src/contexts/chatContext.tsx

@@ -1,20 +1,30 @@
-import { UserEventCategory } from '@spiffy-ai/commerce-api-client';
-import { useAtom, useAtomValue, useSetAtom } from 'jotai';
-import { createContext, useEffect, useState, ReactNode, useCallback, useMemo } from 'react';
-import CommerceApiClient from 'src/adapters/spiffy/commerce/api';
-import { v4 as uuid } from 'uuid';
-import { SessionRestartRequired } from 'src/adapters/spiffy/commerce/exceptions/sessionExceptions';
-import Logger from 'src/application/logging/logger';
+import { UserEventCategory } from "@spiffy-ai/commerce-api-client";
+import { useAtom, useAtomValue, useSetAtom } from "jotai";
+import {
+  createContext,
+  useEffect,
+  useState,
+  ReactNode,
+  useCallback,
+  useMemo,
+} from "react";
+import CommerceApiClient from "src/adapters/spiffy/commerce/api";
+import { v4 as uuid } from "uuid";
+import { SessionRestartRequired } from "src/adapters/spiffy/commerce/exceptions/sessionExceptions";
+import Logger from "src/application/logging/logger";
 import {
   Message,
   MessageRole,
   MessageType,
   NextMessageRequest,
   Response,
-} from 'src/application/models';
-import { AmplitudeAdapter, SpiffyMetricsEventName } from 'src/adapters/amplitude';
-import { messageFromResponse } from 'src/application/utils';
-import { chatIdAtom, userIdAtom, variantInfoAtom } from 'src/atoms/app';
+} from "src/application/models";
+import {
+  AmplitudeAdapter,
+  SpiffyMetricsEventName,
+} from "src/adapters/amplitude";
+import { messageFromResponse } from "src/application/utils";
+import { chatIdAtom, userIdAtom, variantInfoAtom } from "src/atoms/app";
 import {
   messagesAtom,
   requestFailureAtom,
@@ -25,27 +35,28 @@ import {
   userEventsAtom,
   suggestionsLoadingAtom,
   suggestionsAtom,
-} from 'src/atoms/chat';
+} from "src/atoms/chat";
 import {
   chatSearchProductSortingAtom,
   chatSearchProducts,
   chatSearchStateAtom,
   handleSearchResultsAtom,
   chatSearchIsLoadingAtom,
-} from 'src/atoms/search/chatSearch';
-import { orgIdAtom } from 'src/atoms/org/org';
-import { useSystemSettingsContext } from 'src/hooks';
-import { createAppLoadedEvent, createVisitUserEvent } from 'src/hooks/utils';
-import { useMessageInterceptor } from 'src/interceptors/useMessageInterceptor';
-import { supportedEventAtom } from 'src/atoms/app/variant';
-import { chatAtom, getAtomStore } from 'src/atoms';
+} from "src/atoms/search/chatSearch";
+import { orgIdAtom } from "src/atoms/org/org";
+import { useSystemSettingsContext } from "src/hooks";
+import { createAppLoadedEvent, createVisitUserEvent } from "src/hooks/utils";
+import { useMessageInterceptor } from "src/interceptors/useMessageInterceptor";
+import { supportedEventAtom } from "src/atoms/app/variant";
+import { chatAtom } from "src/atoms/chat";
+import { getAtomStore } from "src/atoms/atomStore";
 import {
   clearUserEventAtom,
   createResponsePayload,
   processUserEventAtom,
   userEventQueueAtom,
   userQueueEventCountAtom,
-} from 'src/atoms/chat/messageQueue';
+} from "src/atoms/chat/messageQueue";
 
 /**
  * Record the chat assistant response in Amplitude
@@ -53,7 +64,10 @@ import {
  * @param startTimeMs The start time of the assistant response
  * @param payload The payload used to generate the response
  */
-const recordAssistantResponse = (startTimeMs: number, payload: NextMessageRequest) => {
+const recordAssistantResponse = (
+  startTimeMs: number,
+  payload: NextMessageRequest
+) => {
   const atomStore = getAtomStore();
   const chatState = atomStore.get(chatAtom);
   const chatSearchState = atomStore.get(chatSearchStateAtom);
@@ -72,26 +86,31 @@ const recordAssistantResponse = (startTimeMs: number, payload: NextMessageReques
   }
 
   const eventProps: Record<string, unknown> = {
-    response_time_ms: assistantResponseTimeMs.end - assistantResponseTimeMs.start,
+    response_time_ms:
+      assistantResponseTimeMs.end - assistantResponseTimeMs.start,
     user_event_type: chatState.replyEventCategory,
     user_query: userQueryProperty,
   };
 
   if (chatState.replyEventCategory === UserEventCategory.FormSubmitted) {
     const lastAssistantTurn = chatState.messages
-      .filter((turn) => turn.length > 0 && turn[0].role === MessageRole.Assistant)
+      .filter(
+        (turn) => turn.length > 0 && turn[0].role === MessageRole.Assistant
+      )
       .pop();
     const formType = payload.userEvents?.find(
-      (event) => event.category === UserEventCategory.FormSubmitted,
+      (event) => event.category === UserEventCategory.FormSubmitted
     )?.attributes.formType;
-    const formStatus = lastAssistantTurn?.some((response) => response.type === MessageType.Order);
+    const formStatus = lastAssistantTurn?.some(
+      (response) => response.type === MessageType.Order
+    );
     eventProps.form_submitted_attributes = {
       form_type: formType,
-      status: formStatus ? 'success' : 'failed',
+      status: formStatus ? "success" : "failed",
     };
   }
 
-  if (chatSearchState === 'product-page') {
+  if (chatSearchState === "product-page") {
     eventProps.search_products_returned = searchProducts.length;
     eventProps.search_products_sort_type = searchProductsSort;
   }
@@ -109,13 +128,16 @@ const ChatContext = createContext<ChatContextParams | undefined>(undefined);
 const updateMessageState = (
   message: Message,
   lastMessage: Message,
-  setMessages: (updater: (prev: Message[][]) => Message[][]) => void,
+  setMessages: (updater: (prev: Message[][]) => Message[][]) => void
 ): Message => {
   if (lastMessage == null) {
     setMessages((prev) => [...prev, [message]]);
     return message;
   }
-  if (lastMessage.type === MessageType.Text && message.type === MessageType.Text) {
+  if (
+    lastMessage.type === MessageType.Text &&
+    message.type === MessageType.Text
+  ) {
     const newMessage = {
       ...lastMessage,
       metadata: {
@@ -132,14 +154,17 @@ const updateMessageState = (
     });
     return newMessage;
   }
-  setMessages((prev) => [...prev.slice(0, prev.length - 1), [...prev[prev.length - 1], message]]);
+  setMessages((prev) => [
+    ...prev.slice(0, prev.length - 1),
+    [...prev[prev.length - 1], message],
+  ]);
   return message;
 };
 
 const handleStreamingError = (
   _error: unknown,
   setRequestFailure: (failed: boolean) => void,
-  setMessages: (updater: (prev: Message[][]) => Message[][]) => void,
+  setMessages: (updater: (prev: Message[][]) => Message[][]) => void
 ) => {
   setRequestFailure(true);
   setMessages((prev) => [
@@ -161,11 +186,13 @@ const handleStreamingError = (
 
 const processStreamingResponse = async (
   stream: AsyncIterable<Response>,
-  messageInterceptor: { intercept: (response?: Response) => boolean | undefined },
+  messageInterceptor: {
+    intercept: (response?: Response) => boolean | undefined;
+  },
   handleSearchResults: (message: Message) => void,
   setMessages: (updater: (prev: Message[][]) => Message[][]) => void,
   setSearchIsLoading: (loading: boolean) => void,
-  chatId: string,
+  chatId: string
 ): Promise<{ hasSearchResults: boolean }> => {
   let lastMessage: Message | undefined;
   let hasSearchResults = false;
@@ -178,7 +205,7 @@ const processStreamingResponse = async (
 
       const message = messageFromResponse(response);
       if (!message) {
-        throw new Error('Failed to transform API response to client message');
+        throw new Error("Failed to transform API response to client message");
       }
 
       if (message.type === MessageType.ProductSearch) {
@@ -195,7 +222,7 @@ const processStreamingResponse = async (
         {
           lastResponse: lastMessage,
           response,
-        },
+        }
       );
     }
   }
@@ -211,8 +238,12 @@ const ChatContextProvider = ({ children }: { children: ReactNode }) => {
   const [messages, setMessages] = useAtom<Message[][]>(messagesAtom);
   const setUserEvents = useSetAtom(userEventsAtom);
   const setSuggestions = useSetAtom(suggestionsAtom);
-  const [suggestionsLoading, setSuggestionsLoading] = useAtom<boolean>(suggestionsLoadingAtom);
-  const [responseStreaming, setResponseStreaming] = useAtom<boolean>(responseStreamingAtom);
+  const [suggestionsLoading, setSuggestionsLoading] = useAtom<boolean>(
+    suggestionsLoadingAtom
+  );
+  const [responseStreaming, setResponseStreaming] = useAtom<boolean>(
+    responseStreamingAtom
+  );
   const setRequestFailure = useSetAtom(requestFailureAtom);
   const userEvents = useAtomValue(userEventQueueAtom);
   const userQueueEventCount = useAtomValue(userQueueEventCountAtom);
@@ -230,7 +261,9 @@ const ChatContextProvider = ({ children }: { children: ReactNode }) => {
   const setSearchIsLoading = useSetAtom(chatSearchIsLoadingAtom);
 
   const getStreamingResponses = useCallback(
-    async (payload: NextMessageRequest): Promise<{ hasSearchResults: boolean }> => {
+    async (
+      payload: NextMessageRequest
+    ): Promise<{ hasSearchResults: boolean }> => {
       logPerfMetric(PerfMetricsEvents.FirstResponseStarted);
       const stream = CommerceApiClient.getNextResponseStreaming(payload);
 
@@ -243,7 +276,7 @@ const ChatContextProvider = ({ children }: { children: ReactNode }) => {
           handleSearchResults,
           setMessages,
           setSearchIsLoading,
-          chatId,
+          chatId
         );
 
         return { hasSearchResults };
@@ -262,7 +295,7 @@ const ChatContextProvider = ({ children }: { children: ReactNode }) => {
       setMessages,
       setSearchIsLoading,
       chatId,
-    ],
+    ]
   );
 
   const getSuggestions = useCallback(async () => {
@@ -274,13 +307,22 @@ const ChatContextProvider = ({ children }: { children: ReactNode }) => {
       userEvents: [],
       generationParams: settingsContext.generationParams,
     });
-    const response = await CommerceApiClient.getNextSuggestions(payloadWithoutAppLoaded);
+    const response = await CommerceApiClient.getNextSuggestions(
+      payloadWithoutAppLoaded
+    );
 
     // sort the suggestions by shortest length so the pills can be stacked horizontally
-    setSuggestions(response.sort((a, b) => a.content.length - b.content.length));
+    setSuggestions(
+      response.sort((a, b) => a.content.length - b.content.length)
+    );
     setSuggestionsLoading(false);
     logPerfMetric(PerfMetricsEvents.FirstSuggestionsCompleted);
-  }, [logPerfMetric, setSuggestionsLoading, setSuggestions, settingsContext.generationParams]);
+  }, [
+    logPerfMetric,
+    setSuggestionsLoading,
+    setSuggestions,
+    settingsContext.generationParams,
+  ]);
 
   const getResponses = useCallback(
     async (payload?: NextMessageRequest) => {
@@ -301,7 +343,7 @@ const ChatContextProvider = ({ children }: { children: ReactNode }) => {
         recordAssistantResponse(startTimeMs, requestPayload);
         await getSuggestions();
       } catch (error) {
-        Logger.logError('[spiffy-ai] getResponses error', error);
+        Logger.logError("[spiffy-ai] getResponses error", error);
       } finally {
         // Remove search loading management from here - it's now handled independently
         // in the processStreamingResponse function when search results are detected
@@ -319,7 +361,7 @@ const ChatContextProvider = ({ children }: { children: ReactNode }) => {
       markUserEventsProcessed,
       getSuggestions,
       setUserHasReplied,
-    ],
+    ]
   );
 
   useEffect(() => {
@@ -329,25 +371,28 @@ const ChatContextProvider = ({ children }: { children: ReactNode }) => {
       }
 
       if (
-        (variantInfo.variant === 'pdp' && !variantInfo.productId) ||
-        (variantInfo.variant === 'plp' && !variantInfo.plpId) ||
-        (variantInfo.variant === 'page_visit' && !variantInfo.url)
+        (variantInfo.variant === "pdp" && !variantInfo.productId) ||
+        (variantInfo.variant === "plp" && !variantInfo.plpId) ||
+        (variantInfo.variant === "page_visit" && !variantInfo.url)
       ) {
-        Logger.logDebug('[spiffy-ai] variantInfo has invalid values, skipping...', {
-          variantInfo,
-          supportedEvent,
-        });
+        Logger.logDebug(
+          "[spiffy-ai] variantInfo has invalid values, skipping...",
+          {
+            variantInfo,
+            supportedEvent,
+          }
+        );
         return;
       }
 
       Logger.logDebug(
-        `Assistants Turn is_currently_streaming=${responseStreaming} initialized=${widgetInitialized}`,
+        `Assistants Turn is_currently_streaming=${responseStreaming} initialized=${widgetInitialized}`
       );
       try {
         await getResponses();
         Logger.logInfo(`Assistants Turn [finished]`);
       } catch (error: unknown) {
-        Logger.logError('[spiffy-ai] Assistants Turn error', error);
+        Logger.logError("[spiffy-ai] Assistants Turn error", error);
       }
     };
     if (userQueueEventCount > 0) {
@@ -365,7 +410,7 @@ const ChatContextProvider = ({ children }: { children: ReactNode }) => {
   useEffect(() => {
     if (widgetInitialized || responseStreaming) {
       Logger.logDebug(
-        `[spiffy-ai] initializeWidget [skipped] is_currently_streaming=${responseStreaming} is_initialized=${widgetInitialized}`,
+        `[spiffy-ai] initializeWidget [skipped] is_currently_streaming=${responseStreaming} is_initialized=${widgetInitialized}`
       );
       return;
     }
@@ -373,20 +418,20 @@ const ChatContextProvider = ({ children }: { children: ReactNode }) => {
     const hydrateChat = async () => {
       try {
         Logger.logDebug(
-          `[spiffy-ai] initializeWidget is_currently_streaming=${responseStreaming} is_initialized=${widgetInitialized}`,
+          `[spiffy-ai] initializeWidget is_currently_streaming=${responseStreaming} is_initialized=${widgetInitialized}`
         );
         // on mount, try to get the responses from an active session if one exists
-        const { messages: existingMessages, userEvents } = await CommerceApiClient.getResponses(
-          orgId,
-          chatId,
-          userId,
-        );
+        const { messages: existingMessages, userEvents } =
+          await CommerceApiClient.getResponses(orgId, chatId, userId);
         setMessages([...existingMessages]);
         setUserEvents([...userEvents]);
         getResponses();
       } catch (error) {
         // no active chat session was found, start a new one
-        Logger.logInfo(`Init chat [exception] chat_id=${chatId} error=${error}`, error);
+        Logger.logInfo(
+          `Init chat [exception] chat_id=${chatId} error=${error}`,
+          error
+        );
         if (error instanceof SessionRestartRequired) {
           const appLoadedEvent = createAppLoadedEvent();
           const visitEvent = createVisitUserEvent({ variantInfo });
@@ -411,11 +456,8 @@ const ChatContextProvider = ({ children }: { children: ReactNode }) => {
   const onFocus = useCallback(async () => {
     try {
       if (!responseStreaming && !suggestionsLoading) {
-        const { messages: existingMessages } = await CommerceApiClient.getResponses(
-          orgId,
-          chatId,
-          userId,
-        );
+        const { messages: existingMessages } =
+          await CommerceApiClient.getResponses(orgId, chatId, userId);
 
         if (existingMessages.length > messages.length) {
           setMessages([...existingMessages]);
@@ -429,22 +471,32 @@ const ChatContextProvider = ({ children }: { children: ReactNode }) => {
         }
       }
     } catch (error: unknown) {
-      Logger.logError('[spiffy-ai] onFocus error', error);
+      Logger.logError("[spiffy-ai] onFocus error", error);
     }
-  }, [responseStreaming, suggestionsLoading, orgId, chatId, userId, messages.length, setMessages]);
+  }, [
+    responseStreaming,
+    suggestionsLoading,
+    orgId,
+    chatId,
+    userId,
+    messages.length,
+    setMessages,
+  ]);
 
   // listen for page focus to get latest messages from the server
   useEffect(() => {
-    window.addEventListener('focus', onFocus);
+    window.addEventListener("focus", onFocus);
 
     return () => {
-      window.removeEventListener('focus', onFocus);
+      window.removeEventListener("focus", onFocus);
     };
   }, [onFocus]);
 
   const chatContext = useMemo(() => ({}), []);
 
-  return <ChatContext.Provider value={chatContext}>{children}</ChatContext.Provider>;
+  return (
+    <ChatContext.Provider value={chatContext}>{children}</ChatContext.Provider>
+  );
 };
 
 export { ChatContext, ChatContextProvider };

package/src/events/registerAnalyticsListeners.ts

@@ -1,10 +1,13 @@
-import { AmplitudeAdapter, SpiffyMetricsEventName } from 'src/adapters/amplitude';
-import { getAtomStore } from 'src/atoms/atomStore';
+import {
+  AmplitudeAdapter,
+  SpiffyMetricsEventName,
+} from "src/adapters/amplitude";
+import { getAtomStore } from "src/atoms/atomStore/atomStore";
 import {
   pageLoadOffsetTimeAtom,
   performanceMetricsAtom,
   resetPerformanceMetricsAtom,
-} from 'src/atoms/chat';
+} from "src/atoms/chat";
 
 const registerPerformanceMetricsListener = () => {
   const atomStore = getAtomStore();
@@ -12,19 +15,19 @@ const registerPerformanceMetricsListener = () => {
   const pageLoadOffsetTime = atomStore.get(pageLoadOffsetTimeAtom);
 
   const handleVisibilityChange = () => {
-    if (document.visibilityState === 'hidden' && performanceMetrics.size > 0) {
+    if (document.visibilityState === "hidden" && performanceMetrics.size > 0) {
       const perfMetricsProperties = Object.fromEntries(
         Array.from(performanceMetrics.entries()).map(([key, value]) => [
           `performanceMetrics.${key}`,
           value,
-        ]),
+        ])
       );
 
       AmplitudeAdapter.trackEvent({
         eventName: SpiffyMetricsEventName.PerformanceMetrics,
         eventProps: {
           ...perfMetricsProperties,
-          'performance_metrics.page_load_offset_ms': pageLoadOffsetTime,
+          "performance_metrics.page_load_offset_ms": pageLoadOffsetTime,
         },
       });
       resetPerformanceMetricsAtom();
@@ -33,15 +36,16 @@ const registerPerformanceMetricsListener = () => {
 
   // do not use anything other than visibilitychange to detect when a page or
   // session has ended as other events may not fire in all browsers/devices
-  window.addEventListener('visibilitychange', handleVisibilityChange);
+  window.addEventListener("visibilitychange", handleVisibilityChange);
 
   return () => {
-    window.removeEventListener('visibilitychange', handleVisibilityChange);
+    window.removeEventListener("visibilitychange", handleVisibilityChange);
   };
 };
 
 export const registerAnalyticsListeners = () => {
-  const cleanupPerformanceMetricsListener = registerPerformanceMetricsListener();
+  const cleanupPerformanceMetricsListener =
+    registerPerformanceMetricsListener();
 
   return () => {
     cleanupPerformanceMetricsListener();

package/src/hooks/useFileUpload.ts

@@ -1,14 +1,16 @@
-import { AttachmentRequest } from '@spiffy-ai/commerce-api-client';
-import { useAtom, useAtomValue } from 'jotai';
-import { useRef, useState } from 'react';
-import { customerServiceAttachment } from 'src/atoms';
-import { orgCustomerServiceService } from 'src/atoms/org/orgUIConfig';
+import { AttachmentRequest } from "@spiffy-ai/commerce-api-client";
+import { useAtom, useAtomValue } from "jotai";
+import { useRef, useState } from "react";
+import {
+  orgCustomerServiceService,
+  customerServiceAttachment,
+} from "src/atoms/org";
 
 export const useFileUpload = () => {
   const fileInputRef = useRef(null);
   const [attachment, setAttachment] = useAtom(customerServiceAttachment);
   const customerServiceImpl = useAtomValue(orgCustomerServiceService);
-  const [error, setError] = useState('');
+  const [error, setError] = useState("");
 
   const isValidFile = (file?: File) => {
     const maxSize = customerServiceImpl.maxfileUploadSize;
@@ -41,7 +43,7 @@ export const useFileUpload = () => {
     if (attachment) {
       return {
         ...attachment,
-        base64_content: attachment?.base64_content.split(',')[1],
+        base64_content: attachment?.base64_content.split(",")[1],
       } as AttachmentRequest;
     }
   };

package/src/hooks/useSearch.tsx

@@ -7,7 +7,6 @@ import {
   clearSearchFiltersAtom,
   createFilterOption,
   filteredSearchProductsAtom,
-  orgUIConfigAtom,
   performSearchAtom,
   removeSearchFilterAtom,
   searchAtom,
@@ -16,11 +15,11 @@ import {
   searchProductSortingAtom,
   searchSelectedFiltersAtom,
   SelectedFilterOption,
-} from "src/atoms";
+} from "src/atoms/search";
 import {
   autocompleteStateAtom,
   isFilterOpenAtom,
-} from "src/atoms/globalSearch";
+} from "src/atoms/globalSearch/globalSearch";
 import { formatFilterDisplayName } from "src/atoms/search/utils";
 import { ProductSorting } from "src/atoms/search/types";
 import {
@@ -32,11 +31,9 @@ import { ProductCardConfig } from "src/contexts/types";
 import Logger from "src/application/logging/logger";
 import { SearchResult } from "src/application/models/api/search";
 import { SearchResponseProduct } from "@spiffy-ai/commerce-api-client";
-import {
-  SearchFilter,
-  SelectFilterItem,
-} from "src/types/search-filter-types.ts";
+import { SearchFilter, SelectFilterItem } from "src/types/search-filter-types";
 import { getSearchResultsState, SearchResultsState } from "./utils";
+import { orgUIConfigAtom } from "src/atoms/org";
 
 export interface SearchResultsHocProps {
   // Data

package/src/initialize.ts

@@ -11,7 +11,7 @@ import {
   initAmplitude,
   initDataLayerWrapper,
 } from "src/application/utils/analyticsUtils";
-import { getAtomStore } from "src/atoms/atomStore";
+import { getAtomStore } from "src/atoms/atomStore/atomStore";
 import {
   apiKeyAtom,
   featureFlagServiceAtom,
@@ -89,7 +89,7 @@ const loadAndInit = async () => {
   script.id = "spiffy-injection-script";
   document.head.appendChild(script);
   // #else
-  const { initApp } = await import("./main.tsx");
+  const { initApp } = await import("./main");
   await initApp();
   // #endif
 };