@envive-ai/react-hooks 0.2.6-alpha-arthur-1 → 0.2.6-alpha.11

package/src/contexts/featureFlagContext/featureFlagContext.tsx

@@ -1,13 +1,23 @@
-import React, { createContext, useContext, useCallback, useMemo } from 'react';
-import Logger from '../../application/logging/logger';
-import { StatsigFeatureGate } from '@spiffy-ai/commerce-api-client';
-import { useSessionStorage } from '../../contexts/sessionStorageContext';
-import { useEnviveConfig } from '../../contexts/enviveConfigContext/enviveConfigContext';
-import { FeatureFlagContextType, FeatureGates, OrgConfigFeatureGate } from '@envive-ai/types';
-
-const FEATURE_FLAGS_STORAGE_KEY = 'spiffy-feature-flags';
-
-const FeatureFlagContext = createContext<FeatureFlagContextType | undefined>(undefined);
+import React, { createContext, useContext, useCallback, useMemo } from "react";
+import Logger from "src/application/logging/logger";
+import { StatsigFeatureGate } from "@spiffy-ai/commerce-api-client";
+import { FeatureGates } from "src/application/models/featureGates";
+import { useSessionStorage } from "src/contexts/sessionStorageContext";
+import { OrgConfigFeatureGate } from "src/application/models/api/orgConfigResults";
+import { useEnviveConfig } from "src/contexts/enviveConfigContext/enviveConfigContext";
+
+const FEATURE_FLAGS_STORAGE_KEY = "spiffy-feature-flags";
+
+export interface FeatureFlagContextType {
+  isFeatureGateEnabled: (featureGate: FeatureGates) => boolean;
+  isClientSessionEnabled: () => boolean;
+  getFeatureFlags: () => Record<string, boolean>;
+  persistFeatureGateOverrides: () => void;
+}
+
+const FeatureFlagContext = createContext<FeatureFlagContextType | undefined>(
+  undefined
+);
 
 export const FeatureFlagProvider: React.FC<{
   featureGates: OrgConfigFeatureGate[];
@@ -24,12 +34,12 @@ export const FeatureFlagProvider: React.FC<{
       const value = paramsObj[featureGate];
 
       if (value != null) {
-        return value === 'true';
+        return value === "true";
       }
 
       return undefined;
     },
-    [],
+    []
   );
 
   const getWindowFeatureGateOverrides = useCallback(
@@ -41,7 +51,7 @@ export const FeatureFlagProvider: React.FC<{
 
       return undefined;
     },
-    [featureOverrides],
+    [featureOverrides]
   );
 
   const getStoredFeatureGateOverrides = useCallback(
@@ -54,15 +64,15 @@ export const FeatureFlagProvider: React.FC<{
           return featureFlagsObj[featureGate];
         } catch (err) {
           Logger.logError(
-            '[spiffy-ai] getStoredFeatureGateOverrides: error parsing feature flags',
-            err,
+            "[spiffy-ai] getStoredFeatureGateOverrides: error parsing feature flags",
+            err
           );
         }
       }
 
       return undefined;
     },
-    [],
+    []
   );
 
   const getFeatureFlagOverride = useCallback(
@@ -70,7 +80,7 @@ export const FeatureFlagProvider: React.FC<{
       const queryOverride = getQueryParamFeatureGateOverrides(featureGate);
       if (queryOverride != null) {
         Logger.logDebug(
-          `[spiffy-ai] isFeatureGateEnabled featureGate:${featureGate} overridden by URL param. New value: ${queryOverride}`,
+          `[spiffy-ai] isFeatureGateEnabled featureGate:${featureGate} overridden by URL param. New value: ${queryOverride}`
         );
         return queryOverride;
       }
@@ -78,7 +88,7 @@ export const FeatureFlagProvider: React.FC<{
       const windowOverride = getWindowFeatureGateOverrides(featureGate);
       if (windowOverride != null) {
         Logger.logDebug(
-          `[spiffy-ai] isFeatureGateEnabled featureGate:${featureGate} overridden by window param. New value: ${windowOverride}`,
+          `[spiffy-ai] isFeatureGateEnabled featureGate:${featureGate} overridden by window param. New value: ${windowOverride}`
         );
         return windowOverride;
       }
@@ -86,7 +96,7 @@ export const FeatureFlagProvider: React.FC<{
       const storedOverride = getStoredFeatureGateOverrides(featureGate);
       if (storedOverride != null) {
         Logger.logDebug(
-          `[spiffy-ai] isFeatureGateEnabled featureGate:${featureGate} overridden by stored value. New value: ${storedOverride}`,
+          `[spiffy-ai] isFeatureGateEnabled featureGate:${featureGate} overridden by stored value. New value: ${storedOverride}`
         );
         return storedOverride;
       }
@@ -97,7 +107,7 @@ export const FeatureFlagProvider: React.FC<{
       getQueryParamFeatureGateOverrides,
       getWindowFeatureGateOverrides,
       getStoredFeatureGateOverrides,
-    ],
+    ]
   );
 
   const isFeatureGateEnabled = useCallback(
@@ -111,7 +121,7 @@ export const FeatureFlagProvider: React.FC<{
 
       if (gateValue == null || gateValue.value == null) {
         Logger.logDebug(
-          `[spiffy-ai] isFeatureGateEnabled featureGate:${featureGate} value is undefined - returning false`,
+          `[spiffy-ai] isFeatureGateEnabled featureGate:${featureGate} value is undefined - returning false`
         );
 
         return false;
@@ -119,7 +129,7 @@ export const FeatureFlagProvider: React.FC<{
 
       return gateValue.value;
     },
-    [featureGates, getFeatureFlagOverride],
+    [featureGates, getFeatureFlagOverride]
   );
 
   const isClientSessionEnabled = useCallback((): boolean => {
@@ -127,7 +137,9 @@ export const FeatureFlagProvider: React.FC<{
     const isEnabled =
       gates == null ||
       gates?.filter(
-        (gate) => gate.name === FeatureGates.IsClientSessionEnabled && gate.value === true,
+        (gate) =>
+          gate.name === FeatureGates.IsClientSessionEnabled &&
+          gate.value === true
       ).length > 0;
 
     return isEnabled;
@@ -138,7 +150,7 @@ export const FeatureFlagProvider: React.FC<{
       Object.values(FeatureGates).map((featureGate: FeatureGates) => [
         featureGate,
         isFeatureGateEnabled(featureGate),
-      ]),
+      ])
     );
   }, [isFeatureGateEnabled]);
 
@@ -157,16 +169,25 @@ export const FeatureFlagProvider: React.FC<{
       getFeatureFlags,
       persistFeatureGateOverrides,
     }),
-    [isFeatureGateEnabled, isClientSessionEnabled, getFeatureFlags, persistFeatureGateOverrides],
+    [
+      isFeatureGateEnabled,
+      isClientSessionEnabled,
+      getFeatureFlags,
+      persistFeatureGateOverrides,
+    ]
   );
 
-  return <FeatureFlagContext.Provider value={value}>{children}</FeatureFlagContext.Provider>;
+  return (
+    <FeatureFlagContext.Provider value={value}>
+      {children}
+    </FeatureFlagContext.Provider>
+  );
 };
 
 export const useFeatureFlag = () => {
   const context = useContext(FeatureFlagContext);
   if (context === undefined) {
-    throw new Error('useFeatureFlag must be used within a FeatureFlagProvider');
+    throw new Error("useFeatureFlag must be used within a FeatureFlagProvider");
   }
   return context;
 };

package/src/contexts/featureFlagServiceContext/featureFlagServiceContext.tsx

@@ -1,5 +1,6 @@
 import React, { createContext, useContext, useMemo, ReactNode } from "react";
-import { OrgConfigFeatureGate, FeatureGates } from "@envive-ai/types";
+import { OrgConfigFeatureGate } from "src/application/models/api/orgConfigResults";
+import { FeatureGates } from "src/application/models/featureGates";
 import Logger from "src/application/logging/logger";
 
 // This is the class that was previously implicitly used or defined elsewhere
@@ -48,7 +49,6 @@ export class FeatureFlagService {
 }
 
 export interface FeatureFlagContextType {
-  isFeatureGateEnabled(IsRecommendedProductsEnabled: FeatureGates): unknown;
   featureFlagService: FeatureFlagService | undefined;
 }
 
@@ -69,16 +69,8 @@ export const FeatureFlagServiceProvider: React.FC<
     [featureGates]
   );
 
-  const contextValue = useMemo(
-    () => ({
-      featureFlagService,
-      isFeatureGateEnabled: featureFlagService.isFeatureGateEnabled,
-    }),
-    [featureFlagService]
-  );
-
   return (
-    <FeatureFlagServiceContext.Provider value={contextValue}>
+    <FeatureFlagServiceContext.Provider value={{ featureFlagService }}>
       {children}
     </FeatureFlagServiceContext.Provider>
   );

package/src/contexts/graphqlContext/graphqlContext.tsx

@@ -1,18 +1,61 @@
-import { createContext, useContext, useCallback, useMemo } from 'react';
-import { useAtomValue } from 'jotai';
-import { baseUrlAtom, orgLevelApiKeyAtom } from '../../atoms/envive/enviveConfig';
-import { getMerchantOrgIdQuery } from '../../application/models/graphql/queries/getMerchantOrgIdQuery';
-import { validateGraphQLOrgId } from '../../application/models/validators/validateGraphQLOrgId';
-import Logger from '../../application/logging/logger';
-import { transformSnakeToCamel } from '../../application/models';
-import { configVersion } from '../../util/configVersion';
+import React, {
+  createContext,
+  useContext,
+  useCallback,
+  useMemo,
+  ReactNode,
+} from "react";
+import { useAtomValue } from "jotai";
+import { baseUrlAtom, orgLevelApiKeyAtom } from "src/atoms/envive/enviveConfig";
+import { getMerchantOrgIdQuery } from "src/application/models/graphql/queries/getMerchantOrgIdQuery";
+import { validateGraphQLOrgId } from "src/application/models/validators/validateGraphQLOrgId";
 import {
-  GraphQLContextValue,
-  GraphQLProviderProps,
-  GraphQlConfigValues,
-  ColorsConfigResponse,
-  FrontendConfigResponse,
-} from '@envive-ai/types';
+  getMerchantColorsQuery,
+  GetMerchantColorsQueryData,
+  getMerchantFrontendConfigQuery,
+  GetMerchantFrontendConfigQueryData,
+} from "src/application/models/graphql";
+import { validateGraphQLColorsConfig } from "src/application/models/validators/validateGraphQLColorsConfig";
+import { validateGraphQLFrontendConfig } from "src/application/models/validators/validateGraphQLFrontendConfig";
+import { ColorMapping } from "src/application/models/colorsConfig";
+import { FrontendConfig } from "src/application/models/frontendConfig";
+import Logger from "src/application/logging/logger";
+import { configVersion } from "src/types/config-versions";
+import {
+  CamelCasedPropertiesDeep,
+  transformSnakeToCamel,
+} from "src/application/models";
+
+interface BaseMeConfigQueryResponse {
+  me: {
+    org?: {
+      id: string;
+    };
+    getProductsConfigByVersion?: {
+      frontend?: {
+        values: CamelCasedPropertiesDeep<GetMerchantFrontendConfigQueryData>;
+      };
+      colors?: { values: CamelCasedPropertiesDeep<GetMerchantColorsQueryData> };
+    };
+  };
+}
+export type ColorsConfigResponse = CamelCasedPropertiesDeep<ColorMapping>;
+export type FrontendConfigResponse = CamelCasedPropertiesDeep<FrontendConfig>;
+
+export type GraphQlConfigValues = {
+  colorsConfig?: ColorsConfigResponse;
+  frontendConfig?: CamelCasedPropertiesDeep<FrontendConfig>;
+};
+
+interface GraphQLContextValue {
+  executeQuery: <T>(
+    query: string,
+    variables?: Record<string, unknown>
+  ) => Promise<T>;
+  getOrgId: () => Promise<string | undefined>;
+  getColorsAndFrontendConfig: () => Promise<GraphQlConfigValues>;
+  isReady: boolean;
+}
 
 const GraphQLContext = createContext<GraphQLContextValue | null>(null);
 
@@ -27,6 +70,10 @@ const colorsAndFrontendConfigQuery = () => `
   }
 `;
 
+type GraphQLProviderProps = {
+  children: ReactNode;
+};
+
 export const GraphQLProvider = ({ children }: GraphQLProviderProps) => {
   const apiKey = useAtomValue(orgLevelApiKeyAtom);
   const baseUrl = useAtomValue(baseUrlAtom);
@@ -36,13 +83,13 @@ export const GraphQLProvider = ({ children }: GraphQLProviderProps) => {
   const executeQuery = useCallback(
     async (query: string, variables?: Record<string, unknown>) => {
       if (!isReady) {
-        throw new Error('GraphQL client not ready - missing apiKey or baseUrl');
+        throw new Error("GraphQL client not ready - missing apiKey or baseUrl");
       }
 
       const response = await fetch(`${baseUrl}/v1/graphql`, {
-        method: 'POST',
+        method: "POST",
         headers: {
-          'Content-Type': 'application/json',
+          "Content-Type": "application/json",
           Authorization: `Bearer ${apiKey}`,
         },
         body: JSON.stringify({ query, variables }),
@@ -59,7 +106,7 @@ export const GraphQLProvider = ({ children }: GraphQLProviderProps) => {
 
       return result.data;
     },
-    [apiKey, baseUrl, isReady],
+    [apiKey, baseUrl, isReady]
   );
 
   const getOrgId = useCallback(async () => {
@@ -67,26 +114,32 @@ export const GraphQLProvider = ({ children }: GraphQLProviderProps) => {
     return validateGraphQLOrgId(response.me.org?.id);
   }, [executeQuery]);
 
-  const getColorsAndFrontendConfig = useCallback(async (): Promise<GraphQlConfigValues> => {
-    try {
-      const query = await colorsAndFrontendConfigQuery();
-      if (!query) {
-        throw new Error('Colors and frontend config query is not defined');
+  const getColorsAndFrontendConfig =
+    useCallback(async (): Promise<GraphQlConfigValues> => {
+      try {
+        const query = await colorsAndFrontendConfigQuery();
+        if (!query) {
+          throw new Error("Colors and frontend config query is not defined");
+        }
+        const response = await executeQuery(query);
+        const colorsConfig =
+          response.me.getProductsConfigByVersion?.colors?.values;
+        const frontendConfig =
+          response.me.getProductsConfigByVersion?.frontend?.values;
+        const transformedColorConfig = transformSnakeToCamel(colorsConfig);
+        const transformedFrontendConfig = transformSnakeToCamel(frontendConfig);
+        return {
+          colorsConfig: transformedColorConfig as ColorsConfigResponse,
+          frontendConfig: transformedFrontendConfig as FrontendConfigResponse,
+        };
+      } catch (err) {
+        Logger.logError(
+          "Error fetching graphql colors and frontend config",
+          err
+        );
+        return { colorsConfig: undefined, frontendConfig: undefined };
       }
-      const response = await executeQuery(query);
-      const colorsConfig = response.me.getProductsConfigByVersion?.colors?.values;
-      const frontendConfig = response.me.getProductsConfigByVersion?.frontend?.values;
-      const transformedColorConfig = transformSnakeToCamel(colorsConfig);
-      const transformedFrontendConfig = transformSnakeToCamel(frontendConfig);
-      return {
-        colorsConfig: transformedColorConfig as ColorsConfigResponse,
-        frontendConfig: transformedFrontendConfig as FrontendConfigResponse,
-      };
-    } catch (err) {
-      Logger.logError('Error fetching graphql colors and frontend config', err);
-      return { colorsConfig: undefined, frontendConfig: undefined };
-    }
-  }, [executeQuery]);
+    }, [executeQuery]);
 
   const value = useMemo(
     () => ({
@@ -95,16 +148,18 @@ export const GraphQLProvider = ({ children }: GraphQLProviderProps) => {
       getColorsAndFrontendConfig,
       isReady,
     }),
-    [executeQuery, getOrgId, getColorsAndFrontendConfig, isReady],
+    [executeQuery, getOrgId, getColorsAndFrontendConfig, isReady]
   );
 
-  return <GraphQLContext.Provider value={value}>{children}</GraphQLContext.Provider>;
+  return (
+    <GraphQLContext.Provider value={value}>{children}</GraphQLContext.Provider>
+  );
 };
 
 export const useGraphQLClient = () => {
   const context = useContext(GraphQLContext);
   if (!context) {
-    throw new Error('useGraphQLClient must be used within a GraphQLProvider');
+    throw new Error("useGraphQLClient must be used within a GraphQLProvider");
   }
   return context;
 };

package/src/contexts/localStorageContext/localStorageContext.tsx

@@ -1,17 +1,37 @@
-import React, { createContext, useContext, useCallback, useMemo, useEffect } from 'react';
-import Logger from '../../application/logging/logger';
-import {
-  LocalStorageContextType,
-  LocalStorageEventListener,
-  LocalStorageKeys,
-} from '@envive-ai/types';
+import React, {
+  createContext,
+  useContext,
+  useCallback,
+  useMemo,
+  useEffect,
+} from "react";
+import Logger from "src/application/logging/logger";
+import { LocalStorageEventListener } from "src/application/models/localStorageEventListener";
+
+export enum LocalStorageKeys {
+  ChatId = "v1-spiffy-chat-session-id",
+  SpiffyOnOverride = "spiffy_on",
+  EnviveOnOverride = "envive_on",
+}
+
+interface LocalStorageContextType {
+  setItem: (key: string, value: string) => void;
+  getItem: (key: string) => string | null;
+  setSpiffyOnFeatureFlag: (value: boolean | null) => void;
+  getSpiffyOnFeatureFlag: () => string | null;
+  attachListener: (listener: LocalStorageEventListener) => void;
+  detachListener: (listener: LocalStorageEventListener) => void;
+  isAvailable: boolean;
+}
 
 const LocalStorageContext = createContext<LocalStorageContextType | null>(null);
 
-export const LocalStorageProvider: React.FC<{ children: React.ReactNode }> = ({ children }) => {
+export const LocalStorageProvider: React.FC<{ children: React.ReactNode }> = ({
+  children,
+}) => {
   const isAvailable = useMemo(() => {
     try {
-      return typeof window !== 'undefined' && !!window.localStorage;
+      return typeof window !== "undefined" && !!window.localStorage;
     } catch {
       return false;
     }
@@ -19,7 +39,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]);
 
@@ -27,9 +47,11 @@ export const LocalStorageProvider: React.FC<{ children: React.ReactNode }> = ({
     (key: string, value: string) => {
       if (!isAvailable) return;
       localStorage.setItem(key, value);
-      window.dispatchEvent(new StorageEvent('storage', { key, newValue: value }));
+      window.dispatchEvent(
+        new StorageEvent("storage", { key, newValue: value })
+      );
     },
-    [isAvailable],
+    [isAvailable]
   );
 
   const getItem = useCallback(
@@ -37,19 +59,19 @@ export const LocalStorageProvider: React.FC<{ children: React.ReactNode }> = ({
       if (!isAvailable) return null;
       return localStorage.getItem(key);
     },
-    [isAvailable],
+    [isAvailable]
   );
 
   const setSpiffyOnFeatureFlag = useCallback(
     (value: boolean | null): void => {
       if (!isAvailable) return;
       if (value === true) {
-        localStorage.setItem(LocalStorageKeys.SpiffyOnOverride, 'true');
+        localStorage.setItem(LocalStorageKeys.SpiffyOnOverride, "true");
       } else if (value === false) {
-        localStorage.setItem(LocalStorageKeys.SpiffyOnOverride, 'false');
+        localStorage.setItem(LocalStorageKeys.SpiffyOnOverride, "false");
       }
     },
-    [isAvailable],
+    [isAvailable]
   );
 
   const getSpiffyOnFeatureFlag = useCallback((): string | null => {
@@ -57,7 +79,10 @@ export const LocalStorageProvider: React.FC<{ children: React.ReactNode }> = ({
     return localStorage.getItem(LocalStorageKeys.SpiffyOnOverride);
   }, [isAvailable]);
 
-  const listenersCache = useMemo(() => new Map<string, (event: StorageEvent) => void>(), []);
+  const listenersCache = useMemo(
+    () => new Map<string, (event: StorageEvent) => void>(),
+    []
+  );
 
   const listenerForKey = useCallback(
     (listener: LocalStorageEventListener): ((event: StorageEvent) => void) => {
@@ -66,30 +91,33 @@ 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(
+            `[spiffy-ai] Storage event key=${event.key}, value=`,
+            event.newValue
+          );
           listener.listener(event);
         };
         listenersCache.set(listener.storageKey, handler);
       }
       return listenersCache.get(listener.storageKey)!;
     },
-    [listenersCache],
+    [listenersCache]
   );
 
   const attachListener = useCallback(
     (listener: LocalStorageEventListener): void => {
       if (!isAvailable) return;
-      window.addEventListener('storage', listenerForKey(listener));
+      window.addEventListener("storage", listenerForKey(listener));
     },
-    [isAvailable, listenerForKey],
+    [isAvailable, listenerForKey]
   );
 
   const detachListener = useCallback(
     (listener: LocalStorageEventListener): void => {
       if (!isAvailable) return;
-      window.removeEventListener('storage', listenerForKey(listener));
+      window.removeEventListener("storage", listenerForKey(listener));
     },
-    [isAvailable, listenerForKey],
+    [isAvailable, listenerForKey]
   );
 
   const value = useMemo(
@@ -110,16 +138,22 @@ export const LocalStorageProvider: React.FC<{ children: React.ReactNode }> = ({
       attachListener,
       detachListener,
       isAvailable,
-    ],
+    ]
   );
 
-  return <LocalStorageContext.Provider value={value}>{children}</LocalStorageContext.Provider>;
+  return (
+    <LocalStorageContext.Provider value={value}>
+      {children}
+    </LocalStorageContext.Provider>
+  );
 };
 
 export const useLocalStorage = () => {
   const context = useContext(LocalStorageContext);
   if (!context) {
-    throw new Error('useLocalStorage must be used within a LocalStorageProvider');
+    throw new Error(
+      "useLocalStorage must be used within a LocalStorageProvider"
+    );
   }
   return context;
 };

package/src/contexts/newOrgConfigContext/newOrgConfigContext.tsx

@@ -1,18 +1,28 @@
-import React, { createContext, useContext, ReactNode, useMemo } from 'react';
-import { useAtomValue, useSetAtom } from 'jotai';
-import { useColorsAndFrontendConfig } from 'src/hooks/GraphQLConfig/useGraphQLConfig';
-import { orgShortNameAtom } from 'src/atoms/envive/enviveConfig';
-import { newOrgConfigAtom } from 'src/atoms/org/newOrgConfigAtom';
-import { NewOrgConfigContextType, OrgConfigFeatureGate } from '@envive-ai/types';
-import { FeatureFlagServiceProvider } from '../featureFlagServiceContext';
+import React, { createContext, useContext, ReactNode, useMemo } from "react";
+import { useAtomValue, useSetAtom } from "jotai";
+import { useColorsAndFrontendConfig } from "src/hooks/GraphQLConfig/useGraphQLConfig";
+import { orgShortNameAtom } from "src/atoms/envive/enviveConfig";
+import { newOrgConfigAtom } from "src/atoms/org/newOrgConfigAtom"; // Import newOrgConfigAtom
+import { OrgConfigFeatureGate } from "src/application/models/api/orgConfigResults"; // Import OrgConfigFeatureGate
+import { FeatureFlagServiceProvider } from "src/contexts/featureFlagServiceContext/featureFlagServiceContext"; // Import FeatureFlagServiceProvider
+import { GraphQlConfigValues } from "../graphqlContext";
+
+export type NewOrgConfigContextType = GraphQlConfigValues & {
+  loading: boolean;
+  error: Error | null;
+};
 
-const NewOrgConfigContext = createContext<NewOrgConfigContextType | undefined>(undefined);
+const NewOrgConfigContext = createContext<NewOrgConfigContextType | undefined>(
+  undefined
+);
 
 interface NewOrgConfigProviderProps {
   children: ReactNode;
 }
 
-export const NewOrgConfigProvider: React.FC<NewOrgConfigProviderProps> = ({ children }) => {
+export const NewOrgConfigProvider: React.FC<NewOrgConfigProviderProps> = ({
+  children,
+}) => {
   const orgShortName = useAtomValue(orgShortNameAtom);
   const setNewOrgConfig = useSetAtom(newOrgConfigAtom);
 
@@ -45,7 +55,9 @@ export const NewOrgConfigProvider: React.FC<NewOrgConfigProviderProps> = ({ chil
 export const useNewOrgConfigContext = () => {
   const context = useContext(NewOrgConfigContext);
   if (context === undefined) {
-    throw new Error('useNewOrgConfigContext must be used within a NewOrgConfigProvider');
+    throw new Error(
+      "useNewOrgConfigContext must be used within a NewOrgConfigProvider"
+    );
   }
   return context;
 };