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

package/src/application/utils/messageFromFormSubmittedEvent.ts

@@ -5,7 +5,7 @@ import {
   MessageRole,
   MessageType,
   UserEvent,
-} from '@envive-ai/types';
+} from 'src/application/models';
 
 export const messageFromFormSubmittedEvent = (
   event: UserEvent,

package/src/application/utils/messageFromQueryEvent.ts

@@ -1,5 +1,5 @@
-import { Message, MessageRole, MessageType, UserEvent } from '@envive-ai/types';
 import { UserEventCategory } from '@spiffy-ai/commerce-api-client';
+import { Message, MessageRole, MessageType, UserEvent } from 'src/application/models';
 
 /**
  * Transforms a query UserEvent object into a Message object for presentation.

package/src/application/utils/messageFromResponse.ts

@@ -1,5 +1,5 @@
-import { Message, MessageType, MessageRole, ApiResponse } from "src/types";
-import { ResponseCategory } from "@spiffy-ai/commerce-api-client";
+import { ResponseCategory } from '@spiffy-ai/commerce-api-client';
+import { Message, MessageRole, MessageType, Response } from 'src/application/models';
 
 /**
  * Transforms a server Response object into a Message object for presentation.
@@ -8,9 +8,7 @@ import { ResponseCategory } from "@spiffy-ai/commerce-api-client";
  *
  * @returns A Message if the response contains known attributes, undefined otherwise
  */
-export const messageFromResponse = (
-  response?: ApiResponse
-): Message | undefined => {
+export const messageFromResponse = (response?: Response): Message | undefined => {
   if (response == null) {
     return undefined;
   }
@@ -108,15 +106,13 @@ export const messageFromResponse = (
       type: MessageType.Form,
       metadata: {
         formType: response.attributes.formCategory?.formType,
-        fields: Object.entries(response.attributes.schema.properties).map(
-          ([key, value]) => ({
-            key,
-            title: value.title,
-            type: value.type,
-            format: value.format,
-            required: response.attributes.schema.required.includes(key),
-          })
-        ),
+        fields: Object.entries(response.attributes.schema.properties).map(([key, value]) => ({
+          key,
+          title: value.title,
+          type: value.type,
+          format: value.format,
+          required: response.attributes.schema.required.includes(key),
+        })),
       },
     };
   }

package/src/application/utils/messageFromSuggestionEvent.ts

@@ -1,6 +1,5 @@
-import { Message, MessageRole, MessageType, Suggestion } from "src/types";
-import { UserEvent } from "@envive-ai/types";
-import { UserEventCategory } from "@spiffy-ai/commerce-api-client";
+import { UserEventCategory } from '@spiffy-ai/commerce-api-client';
+import { Message, MessageRole, MessageType, Suggestion, UserEvent } from 'src/application/models';
 
 /**
  * Transforms a UserEvent object into a Message object for presentation.
@@ -12,7 +11,7 @@ import { UserEventCategory } from "@spiffy-ai/commerce-api-client";
  */
 export const messageFromSuggestionEvent = (
   event: UserEvent,
-  suggestions: Suggestion[]
+  suggestions: Suggestion[],
 ): Message | undefined => {
   if (event.category === UserEventCategory.SuggestionClicked) {
     const { suggestionId } = event.attributes;
@@ -24,8 +23,7 @@ export const messageFromSuggestionEvent = (
       createdAt: event.createdAt,
       metadata: {
         suggestionId,
-        suggestionContent:
-          suggestions.find((s) => s.id === suggestionId)?.content ?? "",
+        suggestionContent: suggestions.find((s) => s.id === suggestionId)?.content ?? '',
       },
     };
   }

package/src/application/utils/mouseEventTypes.ts

@@ -1 +1 @@
-
+export type MouseEventTypes = 'click' | 'dblclick' | 'mouseup' | 'mousedown';

package/src/application/utils/nextMessageRequestToApiRequest.ts

@@ -1,6 +1,6 @@
 import { NextMessageRequest as ApiNextMessageRequest } from '@spiffy-ai/commerce-api-client';
+import { NextMessageRequest } from '../models';
 import { coreUserEventToApiUserEvent } from './coreUserEventToApiUserEvent';
-import { NextMessageRequest } from '@envive-ai/types';
 
 export const messageRequestToCommerceMessageRequest = (
   data: NextMessageRequest,

package/src/application/utils/overrides.ts

@@ -1,4 +1,52 @@
-import { DeleteOp, MergeOptions, NoInfer, Override, ReplaceOp } from '@envive-ai/types';
+export type ReplaceOp<T> = { $replace: T };
+export type DeleteOp = { $delete: true };
+
+// Treat these as atomic values (not recursed into)
+type Builtin = Date | RegExp | ((...args: unknown[]) => unknown);
+
+type Primitive = string | number | boolean | bigint | symbol | null | undefined;
+
+/**
+ * Override<T> is a DeepPartial-like type with special operators:
+ * - { $replace: T } to replace an entire subtree/array
+ * - { $delete: true } to delete an object key
+ *
+ * Arrays behavior:
+ * - Arrays of objects: merge-by-index by default (unless `arrayStrategy: 'replace'` or `$replace` is used)
+ * - Arrays of primitives (string/number/boolean/...): replaced by default when a patch array is provided
+ */
+export type Override<T> =
+  // atomic
+  T extends Primitive | Builtin
+    ? T | ReplaceOp<T> | DeleteOp
+    : // arrays
+      T extends (infer U)[]
+      ? Array<Override<U> | undefined> | ReplaceOp<T>
+      : // maps/sets – keep simple: only allow full replace
+        T extends Map<unknown, unknown> | Set<unknown>
+        ? ReplaceOp<T>
+        : // objects
+          T extends object
+          ? { [K in keyof T]?: Override<T[K]> | DeleteOp | null } | ReplaceOp<T>
+          : T;
+
+export type MergeOptions = {
+  /**
+   * How to treat arrays when patch provides an array (not $replace):
+   * - 'replace': always use patch array as whole value
+   * - 'mergeByIndex': merge each index recursively (default for arrays of objects)
+   * Note: Arrays of primitives are replaced by default regardless of this option.
+   */
+  arrayStrategy?: 'replace' | 'mergeByIndex';
+  /**
+   * If true, a `null` patch value deletes the key from an object (RFC 7396-ish)
+   */
+  nullDeletes?: boolean;
+};
+
+// Prevents T from being inferred from the 'patch' parameter; it must be inferred from 'base'.
+// See: https://github.com/microsoft/TypeScript/issues/14829#issuecomment-504042546
+type NoInfer<T> = [T][T extends unknown ? 0 : never];
 
 function isPlainObject(x: unknown): x is Record<string, unknown> {
   return (

package/src/application/utils/supportedEventRequestToApiRequest.ts

@@ -1,10 +1,8 @@
 import { SupportedEventRequest as ApiSupportedEventRequest } from '@spiffy-ai/commerce-api-client';
-import { SupportedEventRequest } from '@envive-ai/types';
+import { SupportedEventRequest as CoreSupportedEventRequest } from '../models/api/supportedEventRequest';
 import { coreUserEventToApiUserEvent } from './coreUserEventToApiUserEvent';
 import { coreContextToApiContext } from './coreContextToApiContext';
 
-type CoreSupportedEventRequest = SupportedEventRequest;
-
 export const coreSupportedEventRequestToApiRequest = (
   coreSupportedEventRequest: CoreSupportedEventRequest,
 ): ApiSupportedEventRequest => ({

package/src/application/utils/urlsParser.ts

@@ -1,4 +1,4 @@
-import { SearchMessage } from '@envive-ai/types';
+import { MessageRole, ProductSearchMessageMetadata } from '../models/message';
 
 export const parseHref = (
   href: string,
@@ -27,6 +27,12 @@ export const getQueryParam = (key: string): string | null => {
   return urlObj.searchParams.get(key);
 };
 
+type SearchMessage = {
+  id: string;
+  role: MessageRole;
+  createdAt: string;
+} & ProductSearchMessageMetadata;
+
 export const buildSearchHash = (message: SearchMessage): string =>
   `#evs=true&s=${message.id}&q=${message.metadata.generatedQuery}`;
 

package/src/atoms/amplitude/amplitudeTrackEventAtom.ts

@@ -1,5 +1,5 @@
-import { SpiffyMetricsEventName } from "@envive-ai/types";
 import { atom } from "jotai";
+import { SpiffyMetricsEventName } from "src/contexts/amplitudeContext/amplitudeContext";
 
 interface TrackEventParams {
   eventName: SpiffyMetricsEventName;

package/src/atoms/app/index.ts

@@ -1,11 +1,14 @@
-import { ContextEnvEnum, ContextSourceEnum } from '@spiffy-ai/commerce-api-client';
-import { atom } from 'jotai';
-import { atomWithStorage } from 'jotai/utils';
-import { VariantInfo, UserIdentityContextType } from '@envive-ai/types';
-import { useUserIdentity } from 'src/contexts/userIdentityContext/userIdentityContext';
-import { variantInfoAtom } from 'src/atoms/app/variant';
-import { v4 as uuid } from 'uuid';
-import { contextSourceAtom } from '../envive/enviveConfig';
+import {
+  ContextEnvEnum,
+  ContextSourceEnum,
+} from "@spiffy-ai/commerce-api-client";
+import { atom } from "jotai";
+import { atomWithStorage } from "jotai/utils";
+import { VariantInfo } from "src/application/models";
+import { UserIdentityContextType, useUserIdentity } from "src/contexts/userIdentityContext/userIdentityContext";
+import { variantInfoAtom } from "src/atoms/app/variant";
+import { v4 as uuid } from "uuid";
+import { contextSourceAtom } from "../envive/enviveConfig";
 
 export interface AppDetails {
   orgId: string;
@@ -17,7 +20,7 @@ export interface AppDetails {
   variantInfo: VariantInfo;
 }
 
-export { variantInfoAtom } from './variant';
+export { variantInfoAtom } from "./variant";
 
 const internalUserIdAtom = atom<string | undefined>(undefined);
 
@@ -34,14 +37,21 @@ export const userIdAtom = atom(
   },
   (_, set, value: string | undefined) => {
     set(internalUserIdAtom, value);
-  },
+  }
 );
 
-export const userIdentityAtom = atom<UserIdentityContextType | undefined>(undefined);
+export const userIdentityAtom = atom<UserIdentityContextType | undefined>(
+  undefined
+);
 
 export const appSourceAtom = atom<ContextSourceEnum>(
-  (get): ContextSourceEnum => get(contextSourceAtom) ?? ContextSourceEnum.App,
+  (get): ContextSourceEnum => get(contextSourceAtom) ?? ContextSourceEnum.App
+);
+export const chatIdAtom = atomWithStorage<string>(
+  "v1-spiffy-chat-session-id",
+  uuid(),
+  undefined,
+  {
+    getOnInit: true,
+  }
 );
-export const chatIdAtom = atomWithStorage<string>('v1-spiffy-chat-session-id', uuid(), undefined, {
-  getOnInit: true,
-});

package/src/atoms/app/variant.ts

@@ -7,7 +7,7 @@ import {
   PLPVariantInfo,
   VariantInfo,
   VariantTypeEnum,
-} from '@envive-ai/types';
+} from 'src/application/models';
 import { sessionStorageUtil } from 'src/atoms/atomStore';
 
 export interface SupportedEvent

package/src/atoms/chat/chatState.ts

@@ -1,14 +1,14 @@
 import { UserEventCategory } from "@spiffy-ai/commerce-api-client/dist/models/UserEventCategory";
 import { atom } from "jotai";
+import { SpiffyMetricsEventName } from "src/contexts/amplitudeContext/amplitudeContext";
 import {
   FormSubmittedAttributes,
   Message,
   Suggestion,
   UserEvent,
-  SpiffyEventName,
-  ChatElementDisplayLocation,
-  SpiffyMetricsEventName,
-} from "@envive-ai/types";
+} from "src/application/models";
+import { ChatElementDisplayLocation } from "src/application/models/chatElementDisplayLocation";
+import { SpiffyEventName } from "src/application/models/events";
 
 export const userHasRepliedAtom = atom<boolean>(false);
 export const replyEventCategoryAtom = atom<UserEventCategory>(

package/src/atoms/chat/form.ts

@@ -1,6 +1,6 @@
 import { UserEventCategory } from '@spiffy-ai/commerce-api-client';
 import { atom } from 'jotai';
-import { FormSubmittedAttributes, UserEvent } from '@envive-ai/types';
+import { FormSubmittedAttributes, UserEvent } from 'src/application/models';
 import { v4 as uuid } from 'uuid';
 import { formSubmitAtom, replyEventCategoryAtom } from 'src/atoms/chat';
 import { queueUserEventAtom } from 'src/atoms/chat/messageQueue';

package/src/atoms/chat/messageQueue.ts

@@ -1,10 +1,18 @@
-import { atom } from 'jotai';
-import { v4 as uuid } from 'uuid';
-import { GenerationParams, NextMessageRequest, UserEvent } from '@envive-ai/types';
-import { getAtomStore } from 'src/atoms/atomStore/atomStore';
-import { userIdAtom, chatIdAtom } from 'src/atoms/app';
-import { orgShortNameAtom, contextSourceAtom, envAtom } from 'src/atoms/envive/enviveConfig';
-import { orgIdAtom, featureFlagServiceAtom } from 'src/atoms/org/graphqlConfig';
+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 { userIdAtom, chatIdAtom } from "src/atoms/app";
+import {
+  orgShortNameAtom,
+  contextSourceAtom,
+  envAtom,
+} from "src/atoms/envive/enviveConfig";
+import { orgIdAtom, featureFlagServiceAtom } from "src/atoms/org/graphqlConfig";
 
 const internalUserEventQueueAtom = atom<UserEvent[]>([]);
 
@@ -19,12 +27,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
@@ -37,15 +51,25 @@ 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
+);
 
-import { ContextSourceEnum, ContextEnvEnum } from '@spiffy-ai/commerce-api-client'; // Import necessary enums
+import {
+  ContextSourceEnum,
+  ContextEnvEnum,
+} from "@spiffy-ai/commerce-api-client"; // Import necessary enums
 // import type { Context } from "@spiffy-ai/commerce-api-client/dist/models/Context"; // Import Context type
 
 export const createResponsePayload = ({
@@ -66,22 +90,23 @@ export const createResponsePayload = ({
   const featureFlagService = atomStore.get(featureFlagServiceAtom);
 
   const context = {
-    userId: userId ?? '',
-    org_id: orgId ?? '',
-    org_short_name: orgShortName ?? '',
-    chat_id: chatId ?? '',
+    userId: userId ?? "",
+    org_id: orgId ?? "",
+    org_short_name: orgShortName ?? "",
+    chat_id: chatId ?? "",
     source: source ?? ContextSourceEnum.App,
     env: (env as ContextEnvEnum) ?? ContextEnvEnum.Dev,
   };
 
-  const featureFlags = featureFlagService?.featureFlagService?.getFeatureFlags() || {};
+  const featureFlags =
+    featureFlagService?.featureFlagService?.getFeatureFlags() || {};
 
   return {
     id: uuid(),
     context,
     userEvents,
     featureFlags: Object.fromEntries(
-      Object.entries(featureFlags).filter(([, isEnabled]) => isEnabled),
+      Object.entries(featureFlags).filter(([, isEnabled]) => isEnabled)
     ), // Convert back to Record<string, boolean>
     generationParams,
   };

package/src/atoms/chat/replies.ts

@@ -1,5 +1,5 @@
 import { atom } from "jotai";
-import { Message, MessageType, SpiffyMetricsEventName } from "@envive-ai/types";
+import { Message, MessageType } from "src/application/models";
 import {
   userHasRepliedAtom,
   messagesAtom,
@@ -8,6 +8,7 @@ import {
 } from "src/atoms/chat";
 import { UserEventCategory } from "@spiffy-ai/commerce-api-client";
 import { queueUserEventAtom } from "./messageQueue";
+import { SpiffyMetricsEventName } from "src/contexts/amplitudeContext/amplitudeContext";
 import { amplitudeTrackEventAtom } from "src/atoms/amplitude/amplitudeTrackEventAtom";
 
 type HandleReplyParams = {

package/src/atoms/chat/suggestions.ts

@@ -1,41 +1,36 @@
-import { atom } from "jotai";
-import { Message, MessageRole, MessageType, Suggestion } from "src/types";
+import { atom } from 'jotai';
+import { Message, MessageRole, MessageType, Suggestion } from 'src/application/models';
 import {
   messagesAtom,
   replyEventCategoryAtom,
   suggestionAtom,
   userHasRepliedAtom,
-} from "src/atoms/chat";
-import { FilterAttribute, ProductResponseAttributes } from "src/types";
+} from 'src/atoms/chat';
+import { UserEventCategory } from '@spiffy-ai/commerce-api-client';
+import { queueUserEventAtom } from './messageQueue';
 
-import { UserEventCategory } from "@spiffy-ai/commerce-api-client";
-import { queueUserEventAtom } from "./messageQueue";
+export const handleSuggestionAtom = atom(null, (get, set, suggestion: Suggestion) => {
+  const newMessage: Message = {
+    id: suggestion.id,
+    role: MessageRole.User,
+    type: MessageType.SuggestionClicked,
+    createdAt: new Date().toISOString(),
+    metadata: {
+      suggestionId: suggestion.id,
+      suggestionContent: suggestion.content,
+    },
+  };
 
-export const handleSuggestionAtom = atom(
-  null,
-  (get, set, suggestion: Suggestion) => {
-    const newMessage: Message = {
-      id: suggestion.id,
-      role: MessageRole.User,
-      type: MessageType.SuggestionClicked,
-      createdAt: new Date().toISOString(),
-      metadata: {
-        suggestionId: suggestion.id,
-        suggestionContent: suggestion.content,
-      },
-    };
-
-    set(replyEventCategoryAtom, UserEventCategory.SuggestionClicked);
-    set(suggestionAtom, suggestion);
-    set(messagesAtom, [...get(messagesAtom), [newMessage]]);
-    set(userHasRepliedAtom, true);
-    set(queueUserEventAtom, {
-      eventId: suggestion.id,
-      category: UserEventCategory.SuggestionClicked,
-      createdAt: newMessage.createdAt,
-      attributes: {
-        suggestionId: suggestion.id,
-      },
-    });
-  }
-);
+  set(replyEventCategoryAtom, UserEventCategory.SuggestionClicked);
+  set(suggestionAtom, suggestion);
+  set(messagesAtom, [...get(messagesAtom), [newMessage]]);
+  set(userHasRepliedAtom, true);
+  set(queueUserEventAtom, {
+    eventId: suggestion.id,
+    category: UserEventCategory.SuggestionClicked,
+    createdAt: newMessage.createdAt,
+    attributes: {
+      suggestionId: suggestion.id,
+    },
+  });
+});

package/src/atoms/envive/enviveConfig.ts

@@ -1,19 +1,23 @@
-import Logger from 'src/application/logging/logger';
-import { atom } from 'jotai';
-import { ContextSourceEnum } from '@spiffy-ai/commerce-api-client';
-import { LocalStorageKeys, EnviveConfig } from '@envive-ai/types';
+import Logger from "src/application/logging/logger";
+import { atom } from "jotai";
+import { EnviveConfig } from "src/contexts/types";
+import { ContextSourceEnum } from "@spiffy-ai/commerce-api-client";
+import { LocalStorageKeys } from "src/contexts/localStorageContext";
 
 const internalEnviveConfigAtom = atom<EnviveConfig | undefined>(undefined);
 
 export const enviveConfigAtom = atom(
   (get) => {
     const config = get(internalEnviveConfigAtom);
-    Logger.logDebug('enviveConfig.ts: Accessing internalEnviveConfigAtom', config);
+    Logger.logDebug(
+      "enviveConfig.ts: Accessing internalEnviveConfigAtom",
+      config
+    );
     return config; // Return undefined if not set instead of throwing
   },
   (_, set, value: EnviveConfig) => {
     set(internalEnviveConfigAtom, value);
-  },
+  }
 );
 
 export const amplitudeApiKeyAtom = atom((get) => {
@@ -30,7 +34,7 @@ export const envAtom = atom((get) => {
 });
 export const baseUrlAtom = atom((get) => {
   const config = get(enviveConfigAtom);
-  return config?.baseUrl || 'https://commerce-api.dev.spiffy.ai';
+  return config?.baseUrl || "https://commerce-api.dev.spiffy.ai";
 });
 export const reactAppNameAtom = atom((get) => {
   const config = get(enviveConfigAtom);
@@ -48,8 +52,10 @@ export const contextSourceAtom = atom((get) => {
     return config.contextSource as ContextSourceEnum;
   }
 
-  const spiffyOnFeatureFlagSet = window.localStorage.getItem(LocalStorageKeys.SpiffyOnOverride);
-  if (spiffyOnFeatureFlagSet === 'true') {
+  const spiffyOnFeatureFlagSet = window.localStorage.getItem(
+    LocalStorageKeys.SpiffyOnOverride
+  );
+  if (spiffyOnFeatureFlagSet === "true") {
     return ContextSourceEnum.Playground;
   }
 
@@ -58,22 +64,22 @@ export const contextSourceAtom = atom((get) => {
 
 export const orgLevelApiKeyAtom = atom((get) => {
   const config = get(enviveConfigAtom);
-  Logger.logDebug('enviveConfig.ts: Accessing orgLevelApiKey', config);
+  Logger.logDebug("enviveConfig.ts: Accessing orgLevelApiKey", config);
   return config?.orgLevelApiKey;
 });
 export const orgShortNameAtom = atom((get) => {
   const config = get(enviveConfigAtom);
-  Logger.logDebug('enviveConfig.ts: Accessing orgShortName', config);
+  Logger.logDebug("enviveConfig.ts: Accessing orgShortName", config);
   return config?.orgShortName;
 });
 export const identifyingPrefixAtom = atom((get) => {
   const config = get(enviveConfigAtom);
-  Logger.logDebug('enviveConfig.ts: Accessing identifyingPrefix', config);
-  return config?.identifyingPrefix || 'spiffy';
+  Logger.logDebug("enviveConfig.ts: Accessing identifyingPrefix", config);
+  return config?.identifyingPrefix || "spiffy";
 });
 
 export const publicKeyAtom = atom((get) => {
   const config = get(enviveConfigAtom);
-  Logger.logDebug('enviveConfig.ts: Accessing publicKey', config);
+  Logger.logDebug("enviveConfig.ts: Accessing publicKey", config);
   return config?.publicKey;
 });

package/src/atoms/org/customerService.ts

@@ -1,9 +1,13 @@
-import { AttachmentRequest, CustServiceConversationMessages } from '@spiffy-ai/commerce-api-client';
-import { atom } from 'jotai';
-import { ChatState } from '@envive-ai/types';
+import {
+  AttachmentRequest,
+  CustServiceConversationMessages,
+} from "@spiffy-ai/commerce-api-client";
+import { atom } from "jotai";
+import { ChatState } from "src/types/custservice-types";
 
 export const isBusinessHoursAtom = atom<boolean>(true);
 export const isCustomerServiceOpenAtom = atom<boolean>(false);
-export const customerServiceResponseAtom = atom<CustServiceConversationMessages>();
+export const customerServiceResponseAtom =
+  atom<CustServiceConversationMessages>();
 export const customerServiceChatStateAtom = atom<ChatState>();
 export const customerServiceAttachment = atom<AttachmentRequest | undefined>();

package/src/atoms/org/graphqlConfig.ts

@@ -1,16 +1,24 @@
-import { atom } from 'jotai';
-import { ColorMapping, FrontendConfig } from '@envive-ai/types';
-import { FeatureFlagContextType } from 'src/contexts/featureFlagServiceContext/featureFlagServiceContext'; // Import FeatureFlagContextType from new context
+import { atom } from "jotai";
+import { ColorMapping } from "src/application/models/colorsConfig";
+import { FrontendConfig } from "src/application/models/frontendConfig";
+import { orgShortNameAtom } from "../envive/enviveConfig";
+import { FeatureFlagContextType } from "src/contexts/featureFlagServiceContext/featureFlagServiceContext"; // Import FeatureFlagContextType from new context
 
-export const internalGraphQLColorsConfigAtom = atom<ColorMapping | undefined>(undefined);
-const internalGraphQLFrontendConfigAtom = atom<FrontendConfig | undefined>(undefined);
+export const internalGraphQLColorsConfigAtom = atom<ColorMapping | undefined>(
+  undefined
+);
+const internalGraphQLFrontendConfigAtom = atom<FrontendConfig | undefined>(
+  undefined
+);
 
 export const orgIdAtom = atom<string | undefined>(undefined); // New atom for orgId
-export const featureFlagServiceAtom = atom<FeatureFlagContextType | undefined>(undefined); // New atom for FeatureFlagService
+export const featureFlagServiceAtom = atom<FeatureFlagContextType | undefined>(
+  undefined
+); // New atom for FeatureFlagService
 
 export const frontendConfigAtom = atom(
   (get) => get(internalGraphQLFrontendConfigAtom),
   (_, set, value: FrontendConfig | undefined) => {
     set(internalGraphQLFrontendConfigAtom, value);
-  },
+  }
 );

package/src/atoms/org/index.ts

@@ -1,4 +1,6 @@
-export * from './customerService';
-export * from './graphqlConfig';
-export * from './orgAnalyticsConfig';
-export * from './newOrgConfigAtom';
+export * from "./customerService";
+export * from "./graphqlConfig";
+// export * from "./org";
+export * from "./orgAnalyticsConfig";
+export * from "./newOrgConfigAtom";
+// export * from "./orgUIConfig";

package/src/atoms/org/newOrgConfigAtom.ts

@@ -1,4 +1,4 @@
-import { atom } from 'jotai';
-import { GraphQlConfigValues } from '@envive-ai/types';
+import { atom } from "jotai";
+import { GraphQlConfigValues } from "src/contexts/graphqlContext";
 
 export const newOrgConfigAtom = atom<GraphQlConfigValues | null>(null);