@envive-ai/react-hooks 0.1.0 → 0.1.2

package/src/application/service/windowFrontendConfigService.ts

@@ -1,11 +1,19 @@
-import Logger from 'src/application/logging/logger';
-import { EnvironmentService } from 'src/application/service/environmentService';
-import { applyOverrides, Override } from 'src/application/utils/overrides';
-import { getAtomStore } from 'src/atoms/atomStore';
-import { colorsConfigAtom, frontendConfigAtom } from 'src/atoms/org/graphqlConfig';
-import { orgPageConfigAtom } from 'src/atoms/org/orgPageConfig';
-import { orgUIConfigAtom } from 'src/atoms/org/orgUIConfig';
-import { ColorMapping, OrgUIConfig, WidgetConfig, WidgetMountingConfig } from 'src/contexts/types';
+import Logger from "src/application/logging/logger";
+import { EnvironmentService } from "src/application/service/environmentService";
+import { applyOverrides, Override } from "src/application/utils/overrides";
+import { getAtomStore } from "src/atoms/atomStore/atomStore";
+import {
+  colorsConfigAtom,
+  frontendConfigAtom,
+} from "src/atoms/org/graphqlConfig";
+import { orgPageConfigAtom } from "src/atoms/org/orgPageConfig";
+import { orgUIConfigAtom } from "src/atoms/org/orgUIConfig";
+import {
+  ColorMapping,
+  OrgUIConfig,
+  WidgetConfig,
+  WidgetMountingConfig,
+} from "src/contexts/types";
 
 type CustomizableFrontendConfig = {
   orgUIConfig: OrgUIConfig;
@@ -39,19 +47,26 @@ class WindowFrontendConfigService {
 
       // Attach an explicit apply function to be called by the host page
       const apply = (overrides: FrontendConfigOverrides[]) => {
-        Logger.logDebug('[spiffy-ai] applyFrontendConfigOverrides invoked');
+        Logger.logDebug("[spiffy-ai] applyFrontendConfigOverrides invoked");
         WindowFrontendConfigService.applyOverridesToFrontendConfig(overrides);
       };
 
       window[identifyingPrefix].applyFrontendConfigOverrides = apply;
 
-      Logger.logDebug('[spiffy-ai] FrontendConfig overrides apply function attached');
+      Logger.logDebug(
+        "[spiffy-ai] FrontendConfig overrides apply function attached"
+      );
     } catch (e) {
-      Logger.logError('[spiffy-ai] Failed to attach FrontendConfig overrides apply function', e);
+      Logger.logError(
+        "[spiffy-ai] Failed to attach FrontendConfig overrides apply function",
+        e
+      );
     }
   }
 
-  private static async applyOverridesToFrontendConfig(overrides: FrontendConfigOverrides[]) {
+  private static async applyOverridesToFrontendConfig(
+    overrides: FrontendConfigOverrides[]
+  ) {
     const atomStore = getAtomStore();
     try {
       // Get the current frontend config(s) from the atoms once
@@ -68,15 +83,19 @@ class WindowFrontendConfigService {
         widgetConfigs: orgPageConfig.widgetConfigs,
       };
 
-      Logger.logInfo('[spiffy-ai] base config', {
+      Logger.logInfo("[spiffy-ai] base config", {
         baseConfig: currentConfig,
       });
 
       for (let i = 0; i < overrides.length; i += 1) {
         const currentOverride = overrides[i];
-        currentConfig = applyOverrides<CustomizableFrontendConfig>(currentConfig, currentOverride, {
-          arrayStrategy: 'mergeByIndex',
-        });
+        currentConfig = applyOverrides<CustomizableFrontendConfig>(
+          currentConfig,
+          currentOverride,
+          {
+            arrayStrategy: "mergeByIndex",
+          }
+        );
       }
 
       // Update the atoms with the new frontend config(s)
@@ -91,11 +110,14 @@ class WindowFrontendConfigService {
         widgetConfigs: currentConfig.widgetConfigs,
       });
 
-      Logger.logInfo('[spiffy-ai] atoms updated via overrides', {
+      Logger.logInfo("[spiffy-ai] atoms updated via overrides", {
         currentConfig,
       });
     } catch (e) {
-      Logger.logError('[spiffy-ai] Failed to apply FrontendConfig overrides', e);
+      Logger.logError(
+        "[spiffy-ai] Failed to apply FrontendConfig overrides",
+        e
+      );
     }
   }
 }

package/src/application/utils/index.ts

@@ -1,3 +1,22 @@
-export * from './messageFromQueryEvent';
-export * from './messageFromResponse';
-export * from './messageFromSuggestionEvent';
+// utils
+export * from "./analyticsUtils";
+export * from "./coreContextToApiContext";
+export * from "./coreUserEventToApiUserEvent";
+export * from "./divideArray";
+export * from "./domObserver";
+export * from "./elementObserver";
+export * from "./imageFilter";
+export * from "./merchantUtils";
+export * from "./messageFromFormSubmittedEvent";
+export * from "./messageFromQueryEvent";
+export * from "./messageFromResponse";
+export * from "./messageFromSuggestionEvent";
+export * from "./mouseEventTypes";
+export * from "./mutationHelper";
+export * from "./nextMessageRequestToApiRequest";
+export * from "./nodeSelector";
+export * from "./overrides";
+export * from "./stringUtils";
+export * from "./supportedEventRequestToApiRequest";
+export * from "./urlsParser";
+export * from "./validation";

package/src/atoms/app/variant.ts

@@ -1,10 +1,10 @@
-import { atomWithStorage } from 'jotai/utils';
-import { atom } from 'jotai';
+import { atomWithStorage } from "jotai/utils";
+import { atom } from "jotai";
 import {
   SupportedEventProductCategory,
   SupportedEventResponse,
   PageVisitCategory,
-} from '@spiffy-ai/commerce-api-client';
+} from "@spiffy-ai/commerce-api-client";
 import {
   PageVisitVariantInfo,
   PDPVariantInfo,
@@ -12,14 +12,14 @@ import {
   VariantInfo,
   FeatureGates,
   OrgShortName,
-} from 'src/application/models';
-import { sessionStorageUtil } from 'src/atoms/atomStore';
-import { featureFlagServiceAtom, orgShortNameAtom } from 'src/atoms/org/org';
+} from "src/application/models";
+import { sessionStorageUtil } from "src/atoms/atomStore/atomStore";
+import { featureFlagServiceAtom, orgShortNameAtom } from "src/atoms/org/org";
 
 export interface SupportedEvent
   extends Pick<
     SupportedEventResponse,
-    'supported' | 'ready' | 'category' | 'collections' | 'top_category'
+    "supported" | "ready" | "category" | "collections" | "top_category"
   > {
   numberOfReviews: number | undefined;
   merchant_tags?: string[];
@@ -92,7 +92,10 @@ export type BackendPageVariantConfig = {
 
 export interface UrlResolverResponse {
   variant_type: string;
-  specific_details: UrlResolvingPDPConfig | UrlResolvingPLPConfig | UrlResolvingGenericConfig;
+  specific_details:
+    | UrlResolvingPDPConfig
+    | UrlResolvingPLPConfig
+    | UrlResolvingGenericConfig;
   ready: boolean;
   user_event?: {
     event_id?: string;
@@ -107,12 +110,12 @@ export interface UrlResolverResponse {
 export type UrlResolverCache = Record<string, UrlResolverResponse | undefined>;
 
 const internalStorageUrlResolverAtom = atomWithStorage<string | undefined>(
-  'spiffy-url-resolver',
+  "spiffy-url-resolver",
   undefined,
   sessionStorageUtil,
   {
     getOnInit: true,
-  },
+  }
 );
 
 export const urlResolverAtom = atom(
@@ -123,22 +126,26 @@ export const urlResolverAtom = atom(
     }
     return JSON.parse(maybeUrlResolver);
   },
-  (get, set, value: { url: string; response: UrlResolverResponse | undefined }) => {
+  (
+    get,
+    set,
+    value: { url: string; response: UrlResolverResponse | undefined }
+  ) => {
     // Get current cache from storage
     const currentCache = get(urlResolverAtom);
     const newCache = { ...currentCache, [value.url]: value.response };
 
     set(internalStorageUrlResolverAtom, JSON.stringify(newCache));
-  },
+  }
 );
 
 const internalStorageSupportedEventAtom = atomWithStorage<string | undefined>(
-  'spiffy-supported-event',
+  "spiffy-supported-event",
   undefined,
   sessionStorageUtil,
   {
     getOnInit: true,
-  },
+  }
 );
 const internalSupportedEventAtom = atom<SupportedEvent | undefined>(undefined);
 
@@ -167,10 +174,13 @@ export const supportedEventAtom = atom(
 
     // TODO: clean up this logic & the feature gate when we've fully rolled out
     if (
-      !featureFlagService.isFeatureGateEnabled(FeatureGates.IsNonShapewearEnabled) &&
+      !featureFlagService.isFeatureGateEnabled(
+        FeatureGates.IsNonShapewearEnabled
+      ) &&
       variantCategory &&
       variantCategory !== SupportedEventProductCategory.Shapewear &&
-      (shortName === OrgShortName.Spanx || shortName === OrgShortName.SpanxStaging)
+      (shortName === OrgShortName.Spanx ||
+        shortName === OrgShortName.SpanxStaging)
     ) {
       const modifiedSupportedEvent = {
         supported: false,
@@ -182,14 +192,17 @@ export const supportedEventAtom = atom(
         merchant_tags: value.merchant_tags,
       };
       set(internalSupportedEventAtom, modifiedSupportedEvent);
-      set(internalStorageSupportedEventAtom, JSON.stringify(modifiedSupportedEvent));
+      set(
+        internalStorageSupportedEventAtom,
+        JSON.stringify(modifiedSupportedEvent)
+      );
 
       return;
     }
 
     set(internalSupportedEventAtom, value);
     set(internalStorageSupportedEventAtom, JSON.stringify(value));
-  },
+  }
 );
 
 const internalVariantIdAtom = atom<string>();
@@ -199,22 +212,28 @@ const internalProductUrlAtom = atom<string>();
 const internalPlpIdAtom = atom<string>();
 const internalUrlAtom = atom<string>();
 const internalPageVisitCategoryAtom = atom<PageVisitCategory>();
-const internalVariantAtom = atom<'pdp' | 'plp' | 'search' | 'page_visit'>('pdp');
+const internalVariantAtom = atom<"pdp" | "plp" | "search" | "page_visit">(
+  "pdp"
+);
 
 export const variantIdAtom = atom((get) => get(internalVariantIdAtom));
 export const productIdAtom = atom((get) => get(internalProductIdAtom));
-export const parentProductIdAtom = atom((get) => get(internalParentProductIdAtom));
+export const parentProductIdAtom = atom((get) =>
+  get(internalParentProductIdAtom)
+);
 export const productUrlAtom = atom((get) => get(internalProductUrlAtom));
 export const plpIdAtom = atom((get) => get(internalPlpIdAtom));
 export const urlAtom = atom((get) => get(internalUrlAtom));
-export const pageVisitCategoryAtom = atom((get) => get(internalPageVisitCategoryAtom));
+export const pageVisitCategoryAtom = atom((get) =>
+  get(internalPageVisitCategoryAtom)
+);
 export const variantAtom = atom((get) => get(internalVariantAtom));
 export const hasParsedVariantInfoAtom = atom(false);
 
 export const variantInfoAtom = atom(
   (get): VariantInfo => {
     const variant = get(variantAtom);
-    if (variant === 'pdp') {
+    if (variant === "pdp") {
       return {
         variantId: get(variantIdAtom),
         variant,
@@ -223,7 +242,7 @@ export const variantInfoAtom = atom(
         url: get(urlAtom),
       } as PDPVariantInfo;
     }
-    if (variant === 'plp') {
+    if (variant === "plp") {
       return {
         variantId: get(variantIdAtom),
         variant,
@@ -231,7 +250,7 @@ export const variantInfoAtom = atom(
         url: get(urlAtom),
       } as PLPVariantInfo;
     }
-    if (variant === 'page_visit') {
+    if (variant === "page_visit") {
       return {
         variantId: get(variantIdAtom),
         variant,
@@ -239,23 +258,23 @@ export const variantInfoAtom = atom(
         pageVisitCategory: get(pageVisitCategoryAtom),
       } as PageVisitVariantInfo;
     }
-    throw new Error('Invalid variantInfo details');
+    throw new Error("Invalid variantInfo details");
   },
   (_, set, newVariant: VariantInfo) => {
     set(internalVariantAtom, newVariant.variant);
     set(internalVariantIdAtom, newVariant.variantId);
-    if (newVariant.variant === 'pdp') {
+    if (newVariant.variant === "pdp") {
       set(internalProductIdAtom, newVariant.productId);
       set(internalParentProductIdAtom, newVariant.parentProductId);
       set(internalUrlAtom, newVariant.url);
     }
-    if (newVariant.variant === 'plp') {
+    if (newVariant.variant === "plp") {
       set(internalPlpIdAtom, newVariant.plpId);
       set(internalUrlAtom, newVariant.url);
     }
-    if (newVariant.variant === 'page_visit') {
+    if (newVariant.variant === "page_visit") {
       set(internalUrlAtom, newVariant.url);
       set(internalPageVisitCategoryAtom, newVariant.pageVisitCategory);
     }
-  },
+  }
 );

package/src/atoms/atomStore/index.ts

@@ -0,0 +1 @@
+export * from "./atomStore";

package/src/atoms/chat/messageQueue.ts

@@ -1,9 +1,13 @@
-import { atom } from 'jotai';
-import { v4 as uuid } from 'uuid';
-import { GenerationParams, NextMessageRequest, UserEvent } from 'src/application/models';
-import { getAtomStore } from 'src/atoms/atomStore';
-import { appDetailsAtom } from 'src/atoms/app';
-import { featureFlagServiceAtom } from 'src/atoms/org/org';
+import { atom } from "jotai";
+import { v4 as uuid } from "uuid";
+import {
+  GenerationParams,
+  NextMessageRequest,
+  UserEvent,
+} from "src/application/models";
+import { getAtomStore } from "src/atoms/atomStore/atomStore";
+import { appDetailsAtom } from "src/atoms/app";
+import { featureFlagServiceAtom } from "src/atoms/org/org";
 
 const internalUserEventQueueAtom = atom<UserEvent[]>([]);
 
@@ -18,12 +22,18 @@ export const userEventQueueAtom = atom((get) => {
  * If the event has the same eventId as an existing message in the queue the NEW
  * event is ignored
  */
-export const queueUserEventAtom = atom(null, (get, set, userEvent: UserEvent) => {
-  if (userEvent === undefined) {
-    return;
+export const queueUserEventAtom = atom(
+  null,
+  (get, set, userEvent: UserEvent) => {
+    if (userEvent === undefined) {
+      return;
+    }
+    set(internalUserEventQueueAtom, [
+      ...get(internalUserEventQueueAtom),
+      userEvent,
+    ]);
   }
-  set(internalUserEventQueueAtom, [...get(internalUserEventQueueAtom), userEvent]);
-});
+);
 
 /**
  * This atom exposes a function to reset the entire queue. All messages in the queue will be purged
@@ -36,13 +46,20 @@ export const clearUserEventAtom = atom(null, (_, set) => {
  * This atom is used to mark events as processed and remove them from the queue
  * It accepts a list of eventId values and will remove all events with those eventIds from the queue.
  */
-export const processUserEventAtom = atom(null, (get, set, eventIds: string[]) => {
-  const curr = get(internalUserEventQueueAtom);
-  const remaining = curr?.filter((event) => !eventIds.includes(event.eventId));
-  set(internalUserEventQueueAtom, remaining);
-});
+export const processUserEventAtom = atom(
+  null,
+  (get, set, eventIds: string[]) => {
+    const curr = get(internalUserEventQueueAtom);
+    const remaining = curr?.filter(
+      (event) => !eventIds.includes(event.eventId)
+    );
+    set(internalUserEventQueueAtom, remaining);
+  }
+);
 
-export const userQueueEventCountAtom = atom((get) => get(userEventQueueAtom).length);
+export const userQueueEventCountAtom = atom(
+  (get) => get(userEventQueueAtom).length
+);
 
 export const createResponsePayload = ({
   userEvents,

package/src/atoms/chat/performanceMetrics.ts

@@ -1,28 +1,31 @@
-import { atom } from 'jotai';
-import { atomWithStorage } from 'jotai/utils';
-import Logger from 'src/application/logging/logger';
-import { getAtomStore, sessionStorageUtil } from 'src/atoms/atomStore';
+import { atom } from "jotai";
+import { atomWithStorage } from "jotai/utils";
+import Logger from "src/application/logging/logger";
+import {
+  getAtomStore,
+  sessionStorageUtil,
+} from "src/atoms/atomStore/atomStore";
 
-export const APP_INITIAL_START_TIME_KEY = 'spiffy-app-initial-start-time';
-export const PAGE_LOAD_OFFSET_TIME_KEY = 'spiffy-page-load-offset-time';
+export const APP_INITIAL_START_TIME_KEY = "spiffy-app-initial-start-time";
+export const PAGE_LOAD_OFFSET_TIME_KEY = "spiffy-page-load-offset-time";
 /**
  * The different performance metrics that can be logged. All times are relative to the
  * initial start time of the app and are stored in milliseconds.
  */
 export enum PerfMetricsEvents {
-  PageLoadOffset = 'page_load_offset_ms',
-  MainBundleLoaded = 'main_bundle_loaded_ms',
-  OrgConfigLoadStarted = 'org_config_load_started_ms',
-  OrgConfigLoadEnded = 'org_config_load_ended_ms',
-  FirstResponseStarted = 'first_response_started_ms',
-  FirstResponseCompleted = 'first_response_completed_ms',
-  FirstSuggestionsStarted = 'first_suggestions_started_ms',
-  FirstSuggestionsCompleted = 'first_suggestions_completed_ms',
-  EmbeddedWidgetRendered = 'embedded_widget_rendered_ms',
-  FloatingButtonRendered = 'floating_button_rendered_ms',
-  TopSuggestionsBarRendered = 'top_suggestions_bar_rendered_ms',
-  BottomSuggestionsBarRendered = 'bottom_suggestions_bar_rendered_ms',
-  SearchPromptRendered = 'search_prompt_rendered_ms',
+  PageLoadOffset = "page_load_offset_ms",
+  MainBundleLoaded = "main_bundle_loaded_ms",
+  OrgConfigLoadStarted = "org_config_load_started_ms",
+  OrgConfigLoadEnded = "org_config_load_ended_ms",
+  FirstResponseStarted = "first_response_started_ms",
+  FirstResponseCompleted = "first_response_completed_ms",
+  FirstSuggestionsStarted = "first_suggestions_started_ms",
+  FirstSuggestionsCompleted = "first_suggestions_completed_ms",
+  EmbeddedWidgetRendered = "embedded_widget_rendered_ms",
+  FloatingButtonRendered = "floating_button_rendered_ms",
+  TopSuggestionsBarRendered = "top_suggestions_bar_rendered_ms",
+  BottomSuggestionsBarRendered = "bottom_suggestions_bar_rendered_ms",
+  SearchPromptRendered = "search_prompt_rendered_ms",
 }
 
 const internalPerfMetricsAtom = atom<Map<PerfMetricsEvents, number>>(new Map());
@@ -32,7 +35,7 @@ export const appInitialStartTimeMsAtom = atomWithStorage<string | undefined>(
   sessionStorageUtil,
   {
     getOnInit: true,
-  },
+  }
 );
 
 export const pageLoadOffsetTimeAtom = atomWithStorage<string | undefined>(
@@ -41,7 +44,7 @@ export const pageLoadOffsetTimeAtom = atomWithStorage<string | undefined>(
   sessionStorageUtil,
   {
     getOnInit: true,
-  },
+  }
 );
 
 /**
@@ -54,7 +57,9 @@ export const resetPerformanceMetricsAtom = () => {
   const atomStore = getAtomStore();
   atomStore.set(internalPerfMetricsAtom, new Map());
 };
-export const performanceMetricsAtom = atom((get) => get(internalPerfMetricsAtom));
+export const performanceMetricsAtom = atom((get) =>
+  get(internalPerfMetricsAtom)
+);
 export const hasReportedPerformanceMetricsAtom = atom<boolean>(false);
 
 /**
@@ -63,22 +68,30 @@ export const hasReportedPerformanceMetricsAtom = atom<boolean>(false);
  *
  * @param value The performance metric name to log.
  */
-export const logPerfMetricAtom = atom(null, (get, set, value: PerfMetricsEvents) => {
-  const initialTimeStorageValue = get(appInitialStartTimeMsAtom);
-  const initialTimeMs = initialTimeStorageValue ? parseInt(initialTimeStorageValue, 10) : undefined;
+export const logPerfMetricAtom = atom(
+  null,
+  (get, set, value: PerfMetricsEvents) => {
+    const initialTimeStorageValue = get(appInitialStartTimeMsAtom);
+    const initialTimeMs = initialTimeStorageValue
+      ? parseInt(initialTimeStorageValue, 10)
+      : undefined;
 
-  if (initialTimeMs == null) {
-    Logger.logWarn(`[spiffy-ai] No initial app start time found. Skipping...`, undefined);
-    return;
-  }
+    if (initialTimeMs == null) {
+      Logger.logWarn(
+        `[spiffy-ai] No initial app start time found. Skipping...`,
+        undefined
+      );
+      return;
+    }
 
-  const currentPerfMetrics = get(internalPerfMetricsAtom);
-  if (currentPerfMetrics.has(value)) {
-    return;
-  }
+    const currentPerfMetrics = get(internalPerfMetricsAtom);
+    if (currentPerfMetrics.has(value)) {
+      return;
+    }
 
-  const currentTimeMs = Date.now();
-  const deltaMs = currentTimeMs - initialTimeMs;
-  currentPerfMetrics.set(value, deltaMs);
-  set(internalPerfMetricsAtom, currentPerfMetrics);
-});
+    const currentTimeMs = Date.now();
+    const deltaMs = currentTimeMs - initialTimeMs;
+    currentPerfMetrics.set(value, deltaMs);
+    set(internalPerfMetricsAtom, currentPerfMetrics);
+  }
+);

package/src/atoms/chat/renderedWidgetRefs.ts

@@ -1,28 +1,27 @@
-import { atom } from 'jotai';
-import { getAtomStore } from 'src/atoms/atomStore';
+import { atom } from "jotai";
+import { getAtomStore } from "src/atoms/atomStore/atomStore";
 
-const internalWidgetArrayAtom = atom<HTMLElement[]>([])
+const internalWidgetArrayAtom = atom<HTMLElement[]>([]);
 
-export const widgetArrayAtom = atom((get) =>
-  get(internalWidgetArrayAtom))
+export const widgetArrayAtom = atom((get) => get(internalWidgetArrayAtom));
 
 /**
  * This function call is used to create a list of the Spiffy widgets
  * that are rendering on the page.
- * 
+ *
  * It is used by the FloatingButton widget to slide out of view when it
  * overlaps with another Spiffy widget.
- * 
+ *
  * The spiffy widgets should be added to the this array for the floating button
  * to know about them.
- * 
+ *
  * Today the "SuggestionBar" widget is not added, but the other widgets are.
- * 
+ *
  */
 export const addWidget = (ref: HTMLElement, idx?: number) => {
-  const atomStore = getAtomStore()
-  const val = atomStore.get(internalWidgetArrayAtom)
-  const insertIdx = idx ?? val.length
-  val[insertIdx] = ref
-  atomStore.set(internalWidgetArrayAtom, val)
-}
+  const atomStore = getAtomStore();
+  const val = atomStore.get(internalWidgetArrayAtom);
+  const insertIdx = idx ?? val.length;
+  val[insertIdx] = ref;
+  atomStore.set(internalWidgetArrayAtom, val);
+};

package/src/atoms/globalSearch/index.ts

@@ -0,0 +1 @@
+export * from "./globalSearch";

package/src/atoms/org/org.ts

@@ -7,14 +7,12 @@ import { GraphQLClient } from "src/adapters/spiffy/commerce/graphql";
 import { OrgConfig } from "src/application/models/api/orgConfigResults";
 import { EnvironmentService } from "src/application/service/environmentService";
 import { FeatureFlagService } from "src/application/service/featureFlagService";
-import { FeatureGates } from "src/application/models/featureGates";
 import { UserIdentityService } from "src/application/service/userIdentityService";
-import { AtomStore, getAtomStore } from "src/atoms/atomStore";
+import { AtomStore, getAtomStore } from "src/atoms/atomStore/atomStore";
 import { PerfMetricsEvents, logPerfMetricAtom } from "src/atoms/chat";
 import { orgAnalyticsConfigAtom } from "src/atoms/org/orgAnalyticsConfig";
 import { colorsConfigAtom, frontendConfigAtom } from "./graphqlConfig";
 import { getOrgUIConfig } from "./orgUIConfig";
-import Logger from "src/application/logging/logger";
 import { useEnviveConfig } from "src/contexts/enviveConfigContext";
 
 const internalApiKeyAtom = atom<string | undefined>(undefined);