@envive-ai/react-hooks 0.3.17 → 0.3.19

package/src/contexts/featureFlagServiceContext/featureFlagServiceContext.tsx

@@ -5,6 +5,8 @@ import Logger from 'src/application/logging/logger';
 
 const FEATURE_FLAGS_STORAGE_KEY = 'spiffy-feature-flags';
 
+const logger = new Logger('featureFlagServiceContext');
+
 export interface FullFlagValue {
   resolved: boolean;
   initial: boolean | undefined;
@@ -66,10 +68,7 @@ export class FeatureFlagService {
       const featureFlagsObj = JSON.parse(featureFlags) as Record<string, boolean>;
       return featureFlagsObj[featureGate];
     } catch (err) {
-      Logger.logError(
-        '[spiffy-ai] getStoredFeatureGateOverrides: error parsing feature flags',
-        err,
-      );
+      logger.logError('getStoredFeatureGateOverrides: error parsing feature flags', err);
       return undefined;
     }
   }
@@ -77,24 +76,24 @@ export class FeatureFlagService {
   static getFeatureFlagOverride(featureGate: FeatureGates): boolean | undefined {
     const queryOverride = FeatureFlagService.getQueryParamFeatureGateOverrides(featureGate);
     if (queryOverride != null) {
-      Logger.logDebug(
-        `[spiffy-ai] isFeatureGateEnabled featureGate:${featureGate} overridden by URL param. New value: ${queryOverride}`,
+      logger.logDebug(
+        `isFeatureGateEnabled featureGate:${featureGate} overridden by URL param. New value: ${queryOverride}`,
       );
       return queryOverride;
     }
 
     const windowOverride = FeatureFlagService.getWindowFeatureGateOverrides(featureGate);
     if (windowOverride != null) {
-      Logger.logDebug(
-        `[spiffy-ai] isFeatureGateEnabled featureGate:${featureGate} overridden by window param. New value: ${windowOverride}`,
+      logger.logDebug(
+        `isFeatureGateEnabled featureGate:${featureGate} overridden by window param. New value: ${windowOverride}`,
       );
       return windowOverride;
     }
 
     const storedOverride = FeatureFlagService.getStoredFeatureGateOverrides(featureGate);
     if (storedOverride != null) {
-      Logger.logDebug(
-        `[spiffy-ai] isFeatureGateEnabled featureGate:${featureGate} overridden by stored value. New value: ${storedOverride}`,
+      logger.logDebug(
+        `isFeatureGateEnabled featureGate:${featureGate} overridden by stored value. New value: ${storedOverride}`,
       );
       return storedOverride;
     }
@@ -111,8 +110,8 @@ export class FeatureFlagService {
     }
 
     if (gateValue == null || gateValue.value == null) {
-      Logger.logDebug(
-        `[spiffy-ai] isFeatureGateEnabled featureGate:${featureGate} value is undefined - returning false`,
+      logger.logDebug(
+        `isFeatureGateEnabled featureGate:${featureGate} value is undefined - returning false`,
       );
       return false;
     }

package/src/contexts/graphqlContext/__tests__/graphqlContext.test.tsx

@@ -8,9 +8,9 @@ import { getMerchantOrgIdQuery } from 'src/application/models/graphql/queries/ge
 import { GraphQLProvider, useGraphQLClient } from '../graphqlContext';
 
 // Mock the Logger to avoid console output in tests
-vi.spyOn(Logger, 'logDebug').mockImplementation(() => {});
-vi.spyOn(Logger, 'logWarn').mockImplementation(() => {});
-vi.spyOn(Logger, 'logError').mockImplementation(() => {});
+vi.spyOn(Logger.prototype, 'logDebug').mockImplementation(() => {});
+vi.spyOn(Logger.prototype, 'logWarn').mockImplementation(() => {});
+vi.spyOn(Logger.prototype, 'logError').mockImplementation(() => {});
 
 // Mock fetch globally
 global.fetch = vi.fn();
@@ -625,7 +625,7 @@ describe('GraphQLProvider', () => {
     });
 
     it('should handle errors and return undefined configs', async () => {
-      const logErrorSpy = vi.spyOn(Logger, 'logError');
+      const logErrorSpy = vi.spyOn(Logger.prototype, 'logError');
 
       (global.fetch as any).mockRejectedValueOnce(new Error('Network error'));
 

package/src/contexts/graphqlContext/graphqlContext.tsx

@@ -47,6 +47,8 @@ interface GraphQLContextValue {
 
 const GraphQLContext = createContext<GraphQLContextValue | null>(null);
 
+const logger = new Logger('graphqlContext');
+
 type GraphQLProviderProps = {
   children: ReactNode;
   requestV3Config?: boolean;
@@ -254,7 +256,7 @@ export const GraphQLProvider = ({
 
       // If the v3 root config is not found and we are configured to return the deprecated config, we will return the mocked config
       if ((!v3RootConfig && mockV3ConfigToDeprecatedConfig) || (isStorybook && isSemanticColors)) {
-        Logger.logInfo('GraphQLContext | Returning mock v3 config', {
+        logger.logDebug('GraphQLContext | Returning mock v3 config', {
           colorsConfig: mockV3ColorsConfig as ColorsConfigV3Response,
           frontendConfig: mockV3FrontendConfig as FrontendConfigV3Response,
         });
@@ -273,7 +275,7 @@ export const GraphQLProvider = ({
         };
       }
 
-      Logger.logInfo('GraphQLContext | Returning v3 config', {
+      logger.logDebug('GraphQLContext | Returning v3 config', {
         colorsConfig: v3ColorsConfig as ColorsConfigV3Response,
         frontendConfig: v3FrontendConfig as FrontendConfigV3Response,
         orgPageConfig: {
@@ -299,7 +301,7 @@ export const GraphQLProvider = ({
         // TODO: Add widgets and other config here
       };
     } catch (err) {
-      Logger.logError('Error fetching graphql colors and frontend config', err);
+      logger.logError('Error fetching graphql colors and frontend config', err);
       return { colorsConfig: undefined, frontendConfig: undefined };
     }
   }, [executeQuery, mockV3ConfigToDeprecatedConfig]);
@@ -340,17 +342,17 @@ export const GraphQLProvider = ({
         frontendConfig: frontendConfig as FrontendConfigV3Response,
       };
     } catch (err) {
-      Logger.logError('Error fetching graphql colors and frontend config', err);
+      logger.logError('Error fetching graphql colors and frontend config', err);
       return { colorsConfig: undefined, frontendConfig: undefined };
     }
   }, [executeQuery]);
 
   const getConfig = useCallback(async (): Promise<GraphQlConfigValues> => {
     if (requestV3Config) {
-      Logger.logInfo('GraphQLContext | Getting v3 config', requestV3Config);
+      logger.logDebug('GraphQLContext | Getting v3 config', requestV3Config);
       return getV3Config();
     }
-    Logger.logInfo('GraphQLContext | Getting colors and frontend config', requestV3Config);
+    logger.logDebug('GraphQLContext | Getting colors and frontend config', requestV3Config);
     return getColorsAndFrontendConfig();
   }, [getColorsAndFrontendConfig, getV3Config, requestV3Config]);
 

package/src/contexts/hardcopyContext/hardcopyContext.tsx

@@ -15,6 +15,8 @@ import { WidgetTypeV3 } from '../typesV3';
 import { useFeatureFlagService } from '../featureFlagServiceContext/featureFlagServiceContext';
 import { useAmplitude } from '../amplitudeContext';
 
+const logger = new Logger('hardcopyContext');
+
 interface HardcopyRequest {
   widgetType: WidgetTypeV3;
   userEvent: UserEvent;
@@ -218,7 +220,7 @@ export const HardcopyProvider: React.FC<HardcopyProviderProps> = ({
   const getHardcopyFromBackend = useCallback(
     async (request: HardcopyRequest): Promise<HardcopyResponse> => {
       if (hardcopyOverride?.[request.widgetType]) {
-        Logger.logInfo('hardcopyContext | using hardcopy override', request.widgetType);
+        logger.logDebug('using hardcopy override', request.widgetType);
         return hardcopyOverride[request.widgetType]!;
       }
       const overrideConfigVersion =
@@ -245,7 +247,7 @@ export const HardcopyProvider: React.FC<HardcopyProviderProps> = ({
         const response = await CommerceApiClient.getHardcopy(widgetTextRequest);
         if (response) {
           const convertedResponse = convertToHardcopyResponse(response);
-          Logger.logInfo('hardcopyContext | converted response', convertedResponse);
+          logger.logDebug('converted response', convertedResponse);
           trackEvent({
             eventName: EnviveMetricsEventName.WidgetTextResponse,
             eventProps: {
@@ -258,11 +260,11 @@ export const HardcopyProvider: React.FC<HardcopyProviderProps> = ({
           return convertedResponse;
         }
       } catch (error) {
-        Logger.logError('hardcopyContext | error getting hardcopy from backend', error);
+        logger.logError('error getting hardcopy from backend', error);
       }
       const mockResponse = MOCK_HARDCOPY_RESPONSE[request.widgetType];
       if (mockResponse) {
-        Logger.logInfo('hardcopyContext | no real response, using mock', mockResponse);
+        logger.logDebug('no real response, using mock', mockResponse);
         return mockResponse;
       }
       throw new Error(`No hardcopy response found for widget type: ${request.widgetType}`);
@@ -273,11 +275,11 @@ export const HardcopyProvider: React.FC<HardcopyProviderProps> = ({
   const getHardcopy = useCallback(
     async (request: HardcopyRequest): Promise<HardcopyResponse> => {
       setIsLoading(true);
-      Logger.logInfo('hardcopyContext | retrieving hardcopy', languages);
+      logger.logDebug('retrieving hardcopy', languages);
 
-      Logger.logInfo('hardcopyContext | request', request);
+      logger.logDebug('request', request);
       const response = await getHardcopyFromBackend(request);
-      Logger.logInfo('hardcopyContext | returning hardcopy response', response);
+      logger.logDebug('returning hardcopy response', response);
       if (!response) {
         setIsLoading(false);
         throw new Error(`No hardcopy response found for widget type: ${request.widgetType}`);

package/src/contexts/localStorageContext/__tests__/localStorageContext.test.tsx

@@ -5,9 +5,9 @@ import { LocalStorageEventListener } from 'src/application/models/localStorageEv
 import { LocalStorageKeys, LocalStorageProvider, useLocalStorage } from '../localStorageContext';
 
 // Mock the Logger to avoid console output in tests
-vi.spyOn(Logger, 'logDebug').mockImplementation(() => {});
-vi.spyOn(Logger, 'logWarn').mockImplementation(() => {});
-vi.spyOn(Logger, 'logError').mockImplementation(() => {});
+vi.spyOn(Logger.prototype, 'logDebug').mockImplementation(() => {});
+vi.spyOn(Logger.prototype, 'logWarn').mockImplementation(() => {});
+vi.spyOn(Logger.prototype, 'logError').mockImplementation(() => {});
 
 // Component that uses the useLocalStorage hook
 const MockLocalStorageComponent: React.FC = () => {
@@ -184,7 +184,7 @@ describe('LocalStorageProvider', () => {
     });
 
     it('should log error when localStorage is not available', async () => {
-      const logErrorSpy = vi.spyOn(Logger, 'logError');
+      const logErrorSpy = vi.spyOn(Logger.prototype, 'logError');
       const originalLocalStorage = window.localStorage;
       Object.defineProperty(window, 'localStorage', {
         value: undefined,
@@ -558,7 +558,7 @@ describe('LocalStorageProvider', () => {
     });
 
     it('should log debug message when storage event is received', async () => {
-      const logDebugSpy = vi.spyOn(Logger, 'logDebug');
+      const logDebugSpy = vi.spyOn(Logger.prototype, 'logDebug');
 
       const TestComponent: React.FC = () => {
         const { attachListener, setItem, detachListener } = useLocalStorage();
@@ -602,7 +602,7 @@ describe('LocalStorageProvider', () => {
       await waitFor(
         () => {
           expect(logDebugSpy).toHaveBeenCalledWith(
-            '[spiffy-ai] Storage event key=test-key, value=',
+            'Storage event key=test-key, value=',
             'test-value',
           );
         },

package/src/contexts/localStorageContext/localStorageContext.tsx

@@ -20,6 +20,8 @@ interface LocalStorageContextType {
 
 const LocalStorageContext = createContext<LocalStorageContextType | null>(null);
 
+const logger = new Logger('localStorageContext');
+
 export const LocalStorageProvider: React.FC<{ children: React.ReactNode }> = ({ children }) => {
   const isAvailable = useMemo(() => {
     try {
@@ -31,7 +33,7 @@ export const LocalStorageProvider: React.FC<{ children: React.ReactNode }> = ({
 
   useEffect(() => {
     if (!isAvailable) {
-      Logger.logError('localStorage is not available', undefined);
+      logger.logError('localStorage is not available', undefined);
     }
   }, [isAvailable]);
 
@@ -78,7 +80,7 @@ export const LocalStorageProvider: React.FC<{ children: React.ReactNode }> = ({
           if (event.key !== listener.storageKey) {
             return;
           }
-          Logger.logDebug(`[spiffy-ai] Storage event key=${event.key}, value=`, event.newValue);
+          logger.logDebug(`Storage event key=${event.key}, value=`, event.newValue);
           listener.listener(event);
         };
         listenersCache.set(listener.storageKey, handler);

package/src/contexts/pageContext/__tests__/pageContext.test.tsx

@@ -15,9 +15,9 @@ import { mapUrlResolverResponseToVariantInfo } from '../mapping';
 import { PageProvider, usePage } from '../pageContext';
 
 // Mock the Logger to avoid console output in tests
-vi.spyOn(Logger, 'logInfo').mockImplementation(() => {});
-vi.spyOn(Logger, 'logWarn').mockImplementation(() => {});
-vi.spyOn(Logger, 'logError').mockImplementation(() => {});
+vi.spyOn(Logger.prototype, 'logInfo').mockImplementation(() => {});
+vi.spyOn(Logger.prototype, 'logWarn').mockImplementation(() => {});
+vi.spyOn(Logger.prototype, 'logError').mockImplementation(() => {});
 
 // Mock CommerceApiClient
 const mockResolveUrl = vi.fn();
@@ -468,7 +468,7 @@ describe('PageProvider', () => {
 
   describe('Error Handling', () => {
     it('should log error and not crash when resolveUrl fails', async () => {
-      const errorSpy = vi.spyOn(Logger, 'logError');
+      const errorSpy = vi.spyOn(Logger.prototype, 'logError');
       const error = new Error('Network error');
       mockResolveUrl.mockRejectedValue(error);
 
@@ -487,7 +487,7 @@ describe('PageProvider', () => {
     });
 
     it('should handle invalid variant type gracefully', async () => {
-      const errorSpy = vi.spyOn(Logger, 'logError');
+      const errorSpy = vi.spyOn(Logger.prototype, 'logError');
 
       const invalidResponse = {
         variant_type: 'invalid_type',

package/src/contexts/pageContext/pageContext.tsx

@@ -21,6 +21,8 @@ import { VariantTypeEnum } from 'src/application/models';
 import { mapApiUserEventToUserEvent, mapUrlResolverResponseToVariantInfo } from './mapping';
 import { PageDetails } from './types';
 
+const logger = new Logger('pageContext');
+
 const PageContext = createContext<
   | (PageDetails & {
       isLoading: boolean;
@@ -104,7 +106,7 @@ export const PageProvider: React.FC<{
         setIsSupported(response.ready);
       } catch (e) {
         setIsLoading(false);
-        Logger.logError('Failed to resolve page URL', e, { pageUrl });
+        logger.logError('Failed to resolve page URL', e, { pageUrl });
       }
     };
     resolvePageUrl();

package/src/contexts/salesAgentContext/chatAPI.ts

@@ -29,6 +29,8 @@ const TRACKED_USER_EVENTS = [
   UserEventCategory.PdpVisit,
   UserEventCategory.PlpVisit,
 ];
+
+const logger = new Logger('chatAPI');
 export interface SalesAgentChatAPI {
   logPageVisit: ({ pageVisitCategory }: { pageVisitCategory: PageVisitCategory }) => void;
   logUserEvent: (event: UserEvent) => void;
@@ -88,11 +90,9 @@ export const useSalesAgentChatAPI = (widget?: WidgetInteractionComponent) => {
   const logUserEvent = useCallback(
     (event: UserEvent) => {
       if (!hasParsedVariantInfo) {
-        Logger.logWarn(
-          '[envive-ai] hasParsedVariantInfo is false, not logging user event',
-          undefined,
-          { event },
-        );
+        logger.logWarn('hasParsedVariantInfo is false, not logging user event', undefined, {
+          event,
+        });
         return;
       }
       if (TRACKED_USER_EVENTS.includes(event.category)) {

package/src/contexts/salesAgentContext/salesAgentContext.tsx

@@ -47,6 +47,8 @@ export interface MockSalesAgentData {
 
 const SalesAgentContext = createContext<SalesAgent | undefined>(undefined);
 
+const logger = new Logger('salesAgentContext');
+
 export interface SalesAgentProviderProps {
   children: ReactNode;
   previewMode?: boolean;
@@ -99,7 +101,7 @@ export const SalesAgentProvider: React.FC<SalesAgentProviderProps> = ({
         // Remove the pending message from the user events
         requestPayload.userEvents?.map(userEvent => markUserEventsProcessed([userEvent.eventId]));
       } catch (error) {
-        Logger.logError('[envive-ai] error sending message', error);
+        logger.logError('error sending message', error);
       }
     },
     [getStreamingResponses, setIsInitialized, markUserEventsProcessed],
@@ -207,7 +209,7 @@ export const SalesAgentProvider: React.FC<SalesAgentProviderProps> = ({
         try {
           await hydrateMessages();
         } catch (error) {
-          Logger.logError('[envive-ai] error hydrating messages', error);
+          logger.logError('error hydrating messages', error);
         } finally {
           setIsHydrated(true);
         }

package/src/contexts/salesAgentContext/salesAgentService.ts

@@ -12,7 +12,7 @@ import {
   Response,
   UserEvent,
 } from 'src/application/models';
-import { messageFromQueryEvent, messageFromResponse } from 'src/application/utils';
+import { messageFromResponse } from 'src/application/utils';
 import { appDetailsAtom } from 'src/atoms/app';
 import { analyticsContextAtom } from 'src/atoms/app/variant';
 import {
@@ -33,6 +33,8 @@ import { v4 as uuid } from 'uuid';
 
 import { StatusCodeError } from './statusCodeError';
 
+const logger = new Logger('salesAgentService');
+
 interface SalesAgentService {
   createResponsePayload: (payload: {
     userEvents: UserEvent[];
@@ -223,7 +225,7 @@ const processStreamingResponse = async (
 
       lastMessage = updateMessageState(message, lastMessage!, setMessages);
     } catch (error: unknown) {
-      Logger.logWarn(`[spiffy-ai] Failed to generate responses from stream`, error, {
+      logger.logWarn('Failed to generate responses from stream', error, {
         lastResponse: lastMessage,
         response,
       });

package/src/contexts/searchContext/__tests__/searchContext.test.tsx

@@ -1,10 +1,7 @@
 import React from 'react';
 import { act, render, screen, waitFor } from '@testing-library/react';
 import { Provider, useAtomValue } from 'jotai';
-import {
-  EnviveConfigProvider,
-  useEnviveConfig,
-} from 'src/contexts/enviveConfigContext/enviveConfigContext';
+import { EnviveConfigProvider, useEnviveConfig } from 'src/contexts/enviveConfigContext';
 import { LocalStorageProvider } from 'src/contexts/localStorageContext/localStorageContext';
 import { GraphQLProvider } from 'src/contexts/graphqlContext/graphqlContext';
 import { UserIdentityProvider } from 'src/contexts/userIdentityContext/userIdentityContext';
@@ -79,14 +76,20 @@ vi.mock('src/contexts/enviveConfigContext/enviveConfigContext', async () => {
 });
 
 // Mock Logger
-vi.mock('src/application/logging/logger', () => ({
-  default: {
-    logInfo: vi.fn(),
-    logWarn: vi.fn(),
-    logError: vi.fn(),
-    logDebug: vi.fn(),
-  },
-}));
+vi.mock('src/application/logging/logger', () => {
+  const MockLogger = vi.fn(function MockLogger() {
+    return {
+      logInfo: vi.fn(),
+      logWarn: vi.fn(),
+      logError: vi.fn(),
+      logDebug: vi.fn(),
+    };
+  });
+
+  return {
+    default: MockLogger,
+  };
+});
 
 // Mock the search service adapter
 vi.mock('src/atoms/search/searchServiceAdapter', () => ({

package/src/contexts/searchContext/searchContext.tsx

@@ -9,7 +9,7 @@ import {
 import { baseUrlAtom } from 'src/atoms/envive/enviveConfig';
 import Logger from 'src/application/logging/logger';
 import { useAppDetails } from 'src/hooks/AppDetails/useAppDetails';
-import { useEnviveConfig } from 'src/contexts/enviveConfigContext/enviveConfigContext';
+import { useEnviveConfig } from 'src/contexts/enviveConfigContext';
 import { SessionRestartRequired } from 'src/types/exceptions/sessionExceptions';
 import { UnsupportedProductException } from 'src/types/exceptions/unsupportedProductExceptions';
 import { SearchParams, SearchResult } from 'src/application/models/api/search';
@@ -18,6 +18,8 @@ import {
   setSearchServiceFunction,
 } from 'src/atoms/search/searchServiceAdapter';
 
+const logger = new Logger('searchContext');
+
 const transformProductResponses = (products: SearchResult['products']) =>
   products.map(data => ({
     id: data.id,
@@ -49,7 +51,7 @@ async function errorResponseBody(error: ResponseError) {
 
 async function throwSessionRestartRequiredIf(errorMsg: string, error: unknown) {
   if (!(error instanceof ResponseError)) {
-    Logger.logInfo(errorMsg, error);
+    logger.logInfo(errorMsg, error);
     throw error;
   }
 
@@ -63,7 +65,7 @@ async function throwSessionRestartRequiredIf(errorMsg: string, error: unknown) {
     errorResponse?.app_code?.toUpperCase() === 'RESTART_SESSION' ||
     errorResponse?.sub_code?.toUpperCase() === 'NOT_FOUND'
   ) {
-    Logger.logInfo(
+    logger.logInfo(
       'Session does not exist. Re-start session',
       error,
       error.response,
@@ -72,7 +74,7 @@ async function throwSessionRestartRequiredIf(errorMsg: string, error: unknown) {
     throw new SessionRestartRequired();
   }
 
-  Logger.logInfo(errorMsg, error);
+  logger.logInfo(errorMsg, error);
   throw error;
 }
 

package/src/contexts/sessionStorageContext/sessionStorageContext.tsx

@@ -9,6 +9,8 @@ interface SessionStorageContextType {
 
 const SessionStorageContext = createContext<SessionStorageContextType | null>(null);
 
+const logger = new Logger('sessionStorageContext');
+
 export const SessionStorageProvider: React.FC<{
   children: React.ReactNode;
 }> = ({ children }) => {
@@ -22,7 +24,7 @@ export const SessionStorageProvider: React.FC<{
 
   useEffect(() => {
     if (!isAvailable) {
-      Logger.logError('sessionStorage is not available', undefined);
+      logger.logError('sessionStorage is not available', undefined);
     }
   }, [isAvailable]);
 

package/src/contexts/uiConfigContext/__tests__/uiConfigContext.test.tsx

@@ -6,13 +6,13 @@ import { SparkleIconColor } from '@envive-ai/react-toolkit-v3/WelcomeMessage';
 import { ChatHeaderVariant } from '@envive-ai/react-toolkit-v3/ChatHeader';
 import { Theme } from '@envive-ai/react-toolkit-v3/Tokens';
 import { FloatingButtonLocation } from '@envive-ai/react-toolkit-v3/FloatingButton';
-import { UiConfigProvider, useUiConfig } from '../uiConfigContext';
+import { useUiConfig } from '../uiConfigContext';
 import { ConfigVersionEnum, OrgUIConfigV3 } from '../../typesV3';
 
 // Mock the Logger to avoid console output in tests
-vi.spyOn(Logger, 'logInfo').mockImplementation(() => {});
-vi.spyOn(Logger, 'logWarn').mockImplementation(() => {});
-vi.spyOn(Logger, 'logError').mockImplementation(() => {});
+vi.spyOn(Logger.prototype, 'logInfo').mockImplementation(() => {});
+vi.spyOn(Logger.prototype, 'logWarn').mockImplementation(() => {});
+vi.spyOn(Logger.prototype, 'logError').mockImplementation(() => {});
 
 // Mock the useNewOrgConfig hook
 vi.mock('src/hooks/NewOrgConfig', () => ({
@@ -30,7 +30,7 @@ const MockUiConfigComponent: React.FC = () => {
     setIsLoadingState(true);
     try {
       const config = await getUiConfig();
-      setUiConfig(config);
+      setUiConfig(config ?? null);
       setError(null);
     } catch (err: unknown) {
       setError(err instanceof Error ? err.message : 'Unknown error');
@@ -74,7 +74,7 @@ const TestWrapper: React.FC<{
     loading: mockNewOrgConfig.loading ?? false,
   });
 
-  return <UiConfigProvider>{children}</UiConfigProvider>;
+  return children;
 };
 
 describe('UiConfigProvider', () => {
@@ -129,7 +129,7 @@ describe('UiConfigProvider', () => {
   });
 
   describe('useUiConfig Hook Integration', () => {
-    it('should provide context through useUiConfig hook', async () => {
+    it('should provide ui config data via useUiConfig hook', async () => {
       const mockUiConfig = createMockUiConfig();
 
       render(
@@ -151,31 +151,6 @@ describe('UiConfigProvider', () => {
 
       expect(screen.getByTestId('is-loading')).toHaveTextContent('false');
     });
-
-    it('should throw error when used outside of UiConfigProvider', () => {
-      const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
-
-      const TestComponent: React.FC = () => {
-        try {
-          useUiConfig();
-          return <div data-testid="no-error">No Error</div>;
-        } catch (error: unknown) {
-          return (
-            <div data-testid="error">
-              {error instanceof Error ? error.message : 'Unknown error'}
-            </div>
-          );
-        }
-      };
-
-      render(<TestComponent />);
-
-      expect(screen.getByTestId('error')).toHaveTextContent(
-        'useUiConfig must be used within a UiConfigProvider',
-      );
-
-      consoleSpy.mockRestore();
-    });
   });
 
   describe('getUiConfig', () => {

package/src/contexts/uiConfigContext/uiConfigContext.tsx

@@ -1,44 +1,32 @@
-import { ReactNode, createContext, useCallback, useContext, useMemo, useState } from 'react';
 import Logger from 'src/application/logging/logger';
 import { useNewOrgConfig } from 'src/hooks/NewOrgConfig';
 import { OrgUIConfigV3 } from '../typesV3';
 
-interface UiConfigContextType {
-  getUiConfig: () => Promise<OrgUIConfigV3>;
+const logger = new Logger('uiConfigContext');
+interface UiConfigHookResult {
+  getUiConfig: () => Promise<OrgUIConfigV3 | undefined>;
   isLoading: boolean;
 }
 
-const UiConfigContext = createContext<UiConfigContextType | undefined>(undefined);
+export const useUiConfig = (): UiConfigHookResult => {
+  const { frontendConfig, loading } = useNewOrgConfig();
 
-export const UiConfigProvider: React.FC<{ children: ReactNode }> = ({ children }) => {
-  const { frontendConfig, loading: isFrontendConfigLoading } = useNewOrgConfig();
-  const [isLoadingUiConfig, setIsLoadingUiConfig] = useState(false);
+  const getUiConfig = async (): Promise<OrgUIConfigV3 | undefined> => {
+    logger.logDebug('uiConfigContext | retrieving ui config');
 
-  const getUiConfig = useCallback(async (): Promise<OrgUIConfigV3> => {
-    setIsLoadingUiConfig(true);
-    Logger.logInfo('uiConfigContext | retrieving ui config');
-    if (isFrontendConfigLoading) {
-      setIsLoadingUiConfig(false);
+    if (loading) {
+      logger.logDebug('uiConfigContext | frontend config still loading');
       throw new Error('Frontend config is loading');
     }
 
-    const response = frontendConfig?.uiConfigs as OrgUIConfigV3;
-    Logger.logInfo('uiConfigContext | returning ui config response', response);
-    setIsLoadingUiConfig(false);
-    return response;
-  }, [frontendConfig, isFrontendConfigLoading]);
-
-  const isLoading = isFrontendConfigLoading || isLoadingUiConfig;
-
-  const value = useMemo(() => ({ getUiConfig, isLoading }), [getUiConfig, isLoading]);
+    const response = frontendConfig?.uiConfigs as OrgUIConfigV3 | undefined;
+    logger.logDebug('uiConfigContext | returning ui config response', response);
 
-  return <UiConfigContext.Provider value={value}>{children}</UiConfigContext.Provider>;
-};
+    return response;
+  };
 
-export const useUiConfig = () => {
-  const context = useContext(UiConfigContext);
-  if (!context) {
-    throw new Error('useUiConfig must be used within a UiConfigProvider');
-  }
-  return context;
+  return {
+    getUiConfig,
+    isLoading: loading,
+  };
 };