@envive-ai/react-hooks 0.3.1 → 0.3.3

package/src/application/models/guards/api/isApiSearchEventAttributes.ts

@@ -12,7 +12,7 @@ export const isApiSearchAttributes = (data: unknown): data is SearchAttributes =
     return false;
   }
 
-  if (!!data.search_term) {
+  if (data.search_term) {
     return true;
   }
 

package/src/application/models/index.ts

@@ -1,3 +1,4 @@
+/* eslint-disable import/export */
 // models
 export * from './cachedValue';
 export * from './chatElementDisplayLocation';

package/src/application/models/message.ts

@@ -1,14 +1,14 @@
 import { CustServiceAttachment, FormType } from '@spiffy-ai/commerce-api-client';
 import {
+  AcceptableFormFieldType,
   OrderResponseAttributes,
+  PageResponseAttributes,
   ProductResponseAttributes,
   ReviewResponseAttributes,
-  PageResponseAttributes,
-  TextResponseAttributes,
-  SearchResponseAttributes,
-  SearchProductResponseAttributes,
-  AcceptableFormFieldType,
   SearchProductFilterAttributes,
+  SearchProductResponseAttributes,
+  SearchResponseAttributes,
+  TextResponseAttributes,
 } from './api/response';
 
 export enum MessageRole {

package/src/application/models/utilityTypes/delimiterCase.ts

@@ -6,6 +6,7 @@ import type { UpperCaseCharacters, WordSeparators } from './internal';
 type UpperCaseToLowerCase<T extends string> = T extends Uppercase<T> ? Lowercase<T> : T;
 
 // This implementation does not support SCREAMING_SNAKE_CASE, it is used internally by `SplitIncludingDelimiters`.
+// eslint-disable-next-line @typescript-eslint/naming-convention
 type SplitIncludingDelimiters_<Source extends string, Delimiter extends string> = Source extends ''
   ? []
   : Source extends `${infer FirstPart}${Delimiter}${infer SecondPart}`

package/src/application/models/validators/validateGraphQLColorsConfig.ts

@@ -1,8 +1,9 @@
-import { ColorMapping, ColorNames } from 'src/application/models/colorsConfig';
+import { ColorMapping } from 'src/application/models/colorsConfig';
 import { isGraphQLColorsConfig } from 'src/application/models/guards/graphQL/isGraphQLColorsConfig';
 
 export const validateGraphQLColorsConfig = (data: unknown): ColorMapping | undefined => {
   if (!isGraphQLColorsConfig(data)) {
     return undefined;
   }
+  return data as unknown as ColorMapping;
 };

package/src/application/models/validators/validateGraphQLFrontendConfig.ts

@@ -1,9 +1,9 @@
 import { FrontendConfig } from 'src/application/models/frontendConfig';
 import { transformSnakeToCamel } from 'src/application/models/utils/snakeToCamelTransformer';
 import {
-  WidgetConfig,
   PageVariantConfig,
   PageVariantTestType,
+  WidgetConfig,
   WidgetMountingConfig,
 } from 'src/contexts/types';
 import { DOMInsertionType } from 'src/merchants/domInsertion';

package/src/application/models/variantInfo/variantInfo.ts

@@ -6,6 +6,9 @@ export enum VariantTypeEnum {
   Pdp = 'pdp',
   Plp = 'plp',
   PageVisit = 'page_visit',
+  Home = 'home',
+  Search = 'search',
+  Other = 'other',
 }
 
 export type VariantType = 'pdp' | 'plp' | 'page_visit';

package/src/application/utils/analyticsUtils.ts

@@ -1,9 +1,9 @@
 import Logger from 'src/application/logging/logger';
 import {
-  isLegacyUAEcommerceEvent,
-  isGA4EcommerceEvent,
-  isBaseEcommerceEvent,
   BaseEcommerceEvent,
+  isBaseEcommerceEvent,
+  isGA4EcommerceEvent,
+  isLegacyUAEcommerceEvent,
 } from 'src/application/models';
 import { SpiffyMetricsEventName } from 'src/contexts/amplitudeContext/amplitudeContext';
 

package/src/application/utils/domObserver.ts

@@ -22,6 +22,7 @@ import { NodeSelector } from './nodeSelector';
  */
 export class DOMObserver {
   private static documentObserver: MutationObserver | null;
+
   private static listeners: Map<string, ElementObserver> = new Map();
 
   private static notifyAdition(records: MutationRecord[], nodeMapping: Map<Node, ElementObserver>) {

package/src/application/utils/elementObserver.ts

@@ -168,6 +168,7 @@ export class ElementObserver {
     if (this.node) {
       return createPortal(fn(), this.node);
     }
+    return undefined;
   }
 
   fire(event: MouseEventTypes) {

package/src/application/utils/mutationHelper.ts

@@ -38,7 +38,9 @@ export class MutationHelper {
   }
 
   static fireSubtreeChange(nodes: NodeList, fn?: (nodes: NodeList) => void) {
-    nodes.length && fn?.(nodes);
+    if (nodes.length && fn) {
+      fn(nodes);
+    }
   }
 
   static isClass(mutation: MutationRecord) {

package/src/application/utils/nodeSelector.ts

@@ -1,5 +1,7 @@
+/* eslint-disable @typescript-eslint/no-use-before-define */
 export abstract class NodeSelector {
   private pattern: string;
+
   private root: Document;
 
   constructor(pattern: string) {
@@ -73,7 +75,10 @@ class ChainSelector extends NodeSelector {
         node = (currentNode as HTMLIFrameElement).contentWindow?.document;
       }
 
-      return parseChain(selectors[++selectorIndex].trim(), node);
+      const nextIndex = selectorIndex + 1;
+      const result = parseChain(selectors[nextIndex].trim(), node);
+      selectorIndex = nextIndex; // Update the outer scope variable to reflect the advancement
+      return result;
     };
 
     return parseChain(selectors[selectorIndex].trim());
@@ -84,6 +89,7 @@ class Empty extends NodeSelector {
   constructor() {
     super('');
   }
+
   parse(): Node | null {
     return null;
   }

package/src/application/utils/stringUtils.ts

@@ -47,6 +47,7 @@ class StringUtils {
         return pattern;
       }
     }
+    return undefined;
   }
 }
 

package/src/atoms/app/index.ts

@@ -2,13 +2,11 @@ import { ContextEnvEnum, ContextSourceEnum } from '@spiffy-ai/commerce-api-clien
 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 { UserIdentityContextType } from 'src/contexts/userIdentityContext/userIdentityContext';
 import { v4 as uuid } from 'uuid';
-import { contextSourceAtom } from '../envive/enviveConfig';
+import { contextSourceAtom, envAtom, orgShortNameAtom } from '../envive/enviveConfig';
+import { orgIdAtom } from '../org/graphqlConfig';
+import { variantInfoAtom } from './variant';
 
 export interface AppDetails {
   orgId: string;
@@ -49,3 +47,16 @@ export const appSourceAtom = atom<ContextSourceEnum>(
 export const chatIdAtom = atomWithStorage<string>('v1-spiffy-chat-session-id', uuid(), undefined, {
   getOnInit: true,
 });
+
+export const appDetailsAtom = atom(
+  (get): AppDetails => ({
+    orgId: get(orgIdAtom) ?? '',
+    // TODO: orgShortName should be available when this atom is created
+    orgShortName: get(orgShortNameAtom) ?? 'spiffy-ai',
+    chatId: get(chatIdAtom),
+    userId: get(userIdAtom),
+    source: get(appSourceAtom),
+    env: get(envAtom) as ContextEnvEnum,
+    variantInfo: get(variantInfoAtom),
+  }),
+);

package/src/atoms/app/variant.ts

@@ -1,20 +1,23 @@
 import { atomWithStorage } from 'jotai/utils';
 import { atom } from 'jotai';
-import { SupportedEventResponse, PageVisitCategory } from '@spiffy-ai/commerce-api-client';
 import {
-  PageVisitVariantInfo,
+  PageVisitCategory,
+  SupportedEventResponse,
+  UserEvent,
+} from '@spiffy-ai/commerce-api-client';
+import {
   PDPVariantInfo,
   PLPVariantInfo,
+  PageVisitVariantInfo,
   VariantInfo,
   VariantTypeEnum,
 } from 'src/application/models';
 import { sessionStorageUtil } from 'src/atoms/atomStore';
 
-export interface SupportedEvent
-  extends Pick<
-    SupportedEventResponse,
-    'supported' | 'ready' | 'category' | 'collections' | 'top_category'
-  > {
+export interface SupportedEvent extends Pick<
+  SupportedEventResponse,
+  'supported' | 'ready' | 'category' | 'collections' | 'top_category'
+> {
   numberOfReviews: number | undefined;
   merchant_tags?: string[];
 }
@@ -88,12 +91,7 @@ export interface UrlResolverResponse {
   variant_type: string;
   specific_details: UrlResolvingPDPConfig | UrlResolvingPLPConfig | UrlResolvingGenericConfig;
   ready: boolean;
-  user_event?: {
-    event_id?: string;
-    attributes?: PDPAttributes | PLPAttributes;
-    category?: string;
-    created_at?: string;
-  };
+  user_event?: UserEvent;
   page_variant?: BackendPageVariantConfig;
 }
 

package/src/atoms/chat/__tests__/messageQueue.test.spec.ts

@@ -0,0 +1,61 @@
+import { UserEventCategory } from '@spiffy-ai/commerce-api-client';
+import { createStore } from 'jotai';
+import { UserEvent } from 'src/application/models';
+import {
+  clearUserEventAtom,
+  processUserEventAtom,
+  queueUserEventAtom,
+  userEventQueueAtom,
+  userQueueEventCountAtom,
+} from 'src/atoms/chat/messageQueue';
+
+const userEvent1 = {
+  eventId: '123',
+  category: UserEventCategory.AppLoaded,
+  createdAt: 'now',
+} satisfies UserEvent;
+const userEvent2 = {
+  eventId: '456',
+  category: UserEventCategory.AppLoaded,
+  createdAt: 'now',
+} satisfies UserEvent;
+
+describe('eventQueue', () => {
+  it('should be able to enqueue items and show them in the queue', () => {
+    const store = createStore();
+    store.set(queueUserEventAtom, userEvent1);
+    expect(store.get(userEventQueueAtom)).toEqual([userEvent1]);
+    expect(store.get(userQueueEventCountAtom)).toBe(1);
+  });
+  it('should be able to mark eventQueue items as processed and remove them from the queue', () => {
+    const store = createStore();
+    store.set(queueUserEventAtom, userEvent1);
+    store.set(queueUserEventAtom, userEvent2);
+    expect(store.get(userEventQueueAtom)).toEqual([userEvent1, userEvent2]);
+    expect(store.get(userQueueEventCountAtom)).toBe(2);
+    store.set(processUserEventAtom, ['123']);
+    expect(store.get(userEventQueueAtom)).toEqual([userEvent2]);
+    expect(store.get(userQueueEventCountAtom)).toBe(1);
+  });
+  it('should be able to mark non-existent eventQueue items as procesed without an exception being raised', () => {
+    const store = createStore();
+    store.set(queueUserEventAtom, userEvent1);
+    store.set(queueUserEventAtom, userEvent2);
+    expect(store.get(userEventQueueAtom)).toEqual([userEvent1, userEvent2]);
+    expect(store.get(userQueueEventCountAtom)).toBe(2);
+    store.set(processUserEventAtom, ['foo']);
+    expect(store.get(userEventQueueAtom)).toEqual([userEvent1, userEvent2]);
+    expect(store.get(userQueueEventCountAtom)).toBe(2);
+  });
+  it('should be able to clear all eventQueue items', () => {
+    const store = createStore();
+    expect(store.get(userQueueEventCountAtom)).toBe(0);
+    store.set(queueUserEventAtom, userEvent1);
+    store.set(queueUserEventAtom, userEvent2);
+    expect(store.get(userEventQueueAtom)).toEqual([userEvent1, userEvent2]);
+    expect(store.get(userQueueEventCountAtom)).toBe(2);
+    store.set(clearUserEventAtom);
+    expect(store.get(userEventQueueAtom)).toEqual([]);
+    expect(store.get(userQueueEventCountAtom)).toBe(0);
+  });
+});

package/src/atoms/chat/index.ts

@@ -1,17 +1,17 @@
 import { atom } from 'jotai';
 import {
-  responseStreamingAtom,
-  suggestionsLoadingAtom,
-  messagesAtom,
-  userQueryAtom,
-  replyEventCategoryAtom,
-  userHasRepliedAtom,
   askQuestionBtnClickedAtom,
-  suggestionsAtom,
   chatIsOpenAtom,
   chatOnToggleAtom,
-  userEventsAtom,
+  messagesAtom,
+  replyEventCategoryAtom,
+  responseStreamingAtom,
   suggestionAtom,
+  suggestionsAtom,
+  suggestionsLoadingAtom,
+  userEventsAtom,
+  userHasRepliedAtom,
+  userQueryAtom,
 } from './chatState';
 
 export * from './chatState';

package/src/atoms/chat/messageQueue.ts

@@ -1,10 +1,5 @@
 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';
+import { UserEvent } from 'src/application/models';
 
 const internalUserEventQueueAtom = atom<UserEvent[]>([]);
 
@@ -43,46 +38,5 @@ export const processUserEventAtom = atom(null, (get, set, eventIds: string[]) =>
   set(internalUserEventQueueAtom, remaining);
 });
 
-export const userQueueEventCountAtom = atom(get => get(userEventQueueAtom).length);
-
-import { ContextSourceEnum, ContextEnvEnum } from '@spiffy-ai/commerce-api-client'; // Import necessary enums
+export const userQueueEventCountAtom = atom(get => get(userEventQueueAtom).length); // Import necessary enums
 // import type { Context } from "@spiffy-ai/commerce-api-client/dist/models/Context"; // Import Context type
-
-export const createResponsePayload = ({
-  userEvents,
-  generationParams,
-}: {
-  userEvents: UserEvent[];
-  generationParams?: GenerationParams;
-}): NextMessageRequest => {
-  const atomStore = getAtomStore();
-  const orgShortName = atomStore.get(orgShortNameAtom);
-  const orgId = atomStore.get(orgIdAtom);
-  const userId = atomStore.get(userIdAtom);
-  const chatId = atomStore.get(chatIdAtom);
-  const source = atomStore.get(contextSourceAtom);
-  const env = atomStore.get(envAtom);
-
-  const featureFlagService = atomStore.get(featureFlagServiceAtom);
-
-  const context = {
-    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() || {};
-
-  return {
-    id: uuid(),
-    context,
-    userEvents,
-    featureFlags: Object.fromEntries(
-      Object.entries(featureFlags).filter(([, isEnabled]) => isEnabled),
-    ), // Convert back to Record<string, boolean>
-    generationParams,
-  };
-};

package/src/atoms/chat/replies.ts

@@ -1,15 +1,15 @@
 import { atom } from 'jotai';
 import { Message, MessageType } from 'src/application/models';
 import {
-  userHasRepliedAtom,
   messagesAtom,
-  userQueryAtom,
   replyEventCategoryAtom,
+  userHasRepliedAtom,
+  userQueryAtom,
 } 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';
+import { queueUserEventAtom } from './messageQueue';
 
 type HandleReplyParams = {
   message: Message;

package/src/atoms/org/graphqlConfig.ts

@@ -1,7 +1,6 @@
 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);

package/src/atoms/org/orgAnalyticsConfig.ts

@@ -1,7 +1,7 @@
 import { atom } from 'jotai';
 import {
-  OrgAnalyticsConfig,
   OrgAnalyticsAmplitudeConfig,
+  OrgAnalyticsConfig,
   OrgAnalyticsCustomerServiceConfig,
   OrgAnalyticsGoogleAnalyticsConfig,
 } from 'src/application/models/api/orgAnalyticsConfig';

package/src/atoms/search/searchAPI.ts

@@ -1,5 +1,5 @@
 import { atom } from 'jotai';
-import { SearchResult, SearchParams } from 'src/application/models/api/search';
+import { SearchParams, SearchResult } from 'src/application/models/api/search';
 import { ProductSorting } from './types';
 import { ProductFilters } from './productFilters';
 import { ProductSorter } from './productSorter';

package/src/atoms/search/searchServiceAdapter.ts

@@ -1,4 +1,4 @@
-import { SearchResult, SearchParams } from 'src/application/models/api/search';
+import { SearchParams, SearchResult } from 'src/application/models/api/search';
 
 // This will be set by the SearchProvider when it initializes
 let searchServiceFunction: ((params: SearchParams) => Promise<SearchResult>) | null = null;

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

@@ -1,7 +1,6 @@
 import React from 'react';
-import { render, screen, waitFor, act } from '@testing-library/react';
+import { act, render, screen, waitFor } from '@testing-library/react';
 import { Provider, useStore } from 'jotai';
-import { AmplitudeProvider, useAmplitude, SpiffyMetricsEventName } from '../amplitudeContext';
 import {
   UserIdentityProvider,
   useUserIdentity,
@@ -11,7 +10,7 @@ import { EnviveConfigProvider } from 'src/contexts/enviveConfigContext/enviveCon
 import { FeatureFlagServiceProvider } from 'src/contexts/featureFlagServiceContext/featureFlagServiceContext';
 import { userIdAtom } from 'src/atoms/app';
 import Logger from 'src/application/logging/logger';
-import { createInstance } from '@amplitude/analytics-browser';
+import { AmplitudeProvider, SpiffyMetricsEventName, useAmplitude } from '../amplitudeContext';
 
 // Mock the Logger to avoid console output in tests
 // vi.spyOn(Logger, "logInfo").mockImplementation(() => {});
@@ -62,6 +61,7 @@ const MockAmplitudeComponent: React.FC = () => {
       <div data-testid="is-ready">{amplitude.isReady.toString()}</div>
       <button
         data-testid="track-event-button"
+        type="button"
         onClick={() =>
           amplitude.trackEvent({
             eventName: SpiffyMetricsEventName.ChatUserMessageInput,
@@ -373,6 +373,7 @@ describe('AmplitudeProvider with UserIdentityContext', () => {
         return (
           <button
             data-testid="track-multiple"
+            type="button"
             onClick={trackMultiple}
           >
             Track Multiple

package/src/contexts/amplitudeContext/amplitudeContext.tsx

@@ -1,4 +1,4 @@
-import React, { createContext, useContext, useCallback, useMemo, useEffect } from 'react';
+import React, { createContext, useCallback, useContext, useEffect, useMemo } from 'react';
 import { useAtomValue } from 'jotai';
 import { createInstance } from '@amplitude/analytics-browser';
 import { FeatureGates } from 'src/application/models/featureGates';
@@ -8,12 +8,12 @@ import {
   amplitudeApiKeyAtom,
   contextSourceAtom,
   dataResidencyAtom,
+  envAtom,
   identifyingPrefixAtom,
 } from 'src/atoms/envive/enviveConfig';
 import { LocalStorageKeys, useLocalStorage } from 'src/contexts/localStorageContext';
 import { orgAnalyticsGoogleAnalyticsConfigAtom } from 'src/atoms/org/orgAnalyticsConfig';
 import { userIdAtom } from 'src/atoms/app';
-import { envAtom } from 'src/atoms/envive/enviveConfig';
 import Logger from 'src/application/logging/logger';
 import type {
   BrowserClient,
@@ -162,8 +162,8 @@ export const AmplitudeProvider: React.FC<{ children: React.ReactNode }> = ({ chi
   const amplitudeSessionReplayInit = useCallback((): boolean => {
     const isEnabled = Boolean(
       orgShortName === OrgShortName.UniqueVintage &&
-        featureFlagService?.isClientSessionEnabled() &&
-        featureFlagService?.isFeatureGateEnabled(FeatureGates.IsNewFeatureEnabled),
+      featureFlagService?.isClientSessionEnabled() &&
+      featureFlagService?.isFeatureGateEnabled(FeatureGates.IsNewFeatureEnabled),
     );
     const sampleRate = 1;
 
@@ -358,7 +358,7 @@ export const AmplitudeProvider: React.FC<{ children: React.ReactNode }> = ({ chi
           if (window.dataLayer) {
             (window.dataLayer as any[]).push({
               event: decoratedEventName,
-              eventProps: eventProps,
+              eventProps,
             });
           }
         }

package/src/contexts/cdnContext/cdnContext.tsx

@@ -1,4 +1,4 @@
-import React, { createContext, useContext, useCallback, useMemo } from 'react';
+import React, { createContext, useCallback, useContext, useMemo } from 'react';
 import { useAtomValue } from 'jotai';
 import { cdnUrlAtom } from '../../atoms/envive/enviveConfig';
 

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

@@ -1,10 +1,9 @@
 import React from 'react';
 import { render, screen, waitFor } from '@testing-library/react';
-import { Provider } from 'jotai';
-import { useAtomValue } from 'jotai';
-import { EnviveConfigProvider, useEnviveConfig } from '../enviveConfigContext';
+import { Provider, useAtomValue } from 'jotai';
 import { enviveConfigAtom } from 'src/atoms/envive/enviveConfig';
 import Logger from 'src/application/logging/logger';
+import { EnviveConfigProvider, useEnviveConfig } from '../enviveConfigContext';
 
 // Mock the Logger to avoid console output in tests
 vi.spyOn(Logger, 'logDebug').mockImplementation(() => {});

package/src/contexts/enviveConfigContext/enviveConfigContext.tsx

@@ -1,5 +1,5 @@
-import React, { createContext, useContext, ReactNode, useEffect } from 'react';
-import { useSetAtom, useAtomValue } from 'jotai';
+import React, { ReactNode, createContext, useEffect } from 'react';
+import { useAtomValue, useSetAtom } from 'jotai';
 import { enviveConfigAtom } from 'src/atoms/envive/enviveConfig';
 import Logger from 'src/application/logging/logger';
 import { OrgConfigFeatureGate } from 'src/application/models/api/orgConfigResults';
@@ -82,5 +82,5 @@ export const EnviveConfigProvider: React.FC<EnviveConfigProviderProps> = ({
 export const useEnviveConfig = (): EnviveConfig => {
   const config = useAtomValue(enviveConfigAtom);
 
-  return config ? config : {};
+  return config || {};
 };

package/src/contexts/enviveContext/enviveContext.tsx

@@ -0,0 +1,89 @@
+import { ReactNode, createContext } from 'react';
+
+import { OrgConfigFeatureGate } from 'src/application/models/api/orgConfigResults';
+import { AmplitudeProvider } from '../amplitudeContext';
+import { EnviveConfigProvider } from '../enviveConfigContext';
+import { EnviveCssProvider } from '../enviveCssContext';
+import { FeatureFlagServiceProvider } from '../featureFlagServiceContext';
+import { GraphQLProvider } from '../graphqlContext';
+import { LocalStorageProvider } from '../localStorageContext';
+import { NewOrgConfigProvider } from '../newOrgConfigContext';
+import { UserIdentityProvider } from '../userIdentityContext';
+import { EnviveAgent } from './types';
+import { SearchProvider } from '../searchContext';
+import { SalesAgentProvider } from '../salesAgentContext/salesAgentContext';
+import { SystemSettingsContextProvider } from '../systemSettingsContext';
+
+const EnviveContext = createContext<null>(null);
+
+interface AgentWrapperProps {
+  children: ReactNode;
+  enabledAgents: EnviveAgent[];
+}
+
+interface EnviveProviderProps extends AgentWrapperProps {
+  amplitudeApiKey?: string;
+  dataResidency?: string;
+  env?: string;
+  baseUrl?: string;
+  reactAppName?: string;
+  cdnUrl?: string;
+  contextSource?: string;
+  orgLevelApiKey?: string;
+  orgShortName?: string;
+  identifyingPrefix: string;
+  featureOverrides?: Record<string, boolean>;
+  variantUrlOverride?: string;
+  variantInfoOverride?: any;
+  show?: boolean;
+  publicKey?: string;
+  featureGates?: OrgConfigFeatureGate[]; // New prop for feature gates
+}
+
+const SearchAgentWrapper: React.FC<AgentWrapperProps> = ({ children, enabledAgents }) => {
+  if (!enabledAgents.includes(EnviveAgent.SearchAgent)) {
+    return children;
+  }
+  return <SearchProvider>{children}</SearchProvider>;
+};
+
+const SalesAgentWrapper: React.FC<AgentWrapperProps> = ({ children, enabledAgents }) => {
+  if (!enabledAgents.includes(EnviveAgent.SalesAgent)) {
+    return children;
+  }
+  return (
+    <SystemSettingsContextProvider>
+      <SalesAgentProvider>{children}</SalesAgentProvider>
+    </SystemSettingsContextProvider>
+  );
+};
+
+export const EnviveProvider: React.FC<EnviveProviderProps> = ({
+  children,
+  enabledAgents,
+  ...config
+}) => (
+  <EnviveContext.Provider value={null}>
+    <EnviveConfigProvider {...config}>
+      <GraphQLProvider>
+        <NewOrgConfigProvider>
+          <LocalStorageProvider>
+            <FeatureFlagServiceProvider featureGates={[]}>
+              <UserIdentityProvider>
+                <AmplitudeProvider>
+                  <EnviveCssProvider>
+                    <SearchAgentWrapper enabledAgents={enabledAgents}>
+                      <SalesAgentWrapper enabledAgents={enabledAgents}>
+                        {children}
+                      </SalesAgentWrapper>
+                    </SearchAgentWrapper>
+                  </EnviveCssProvider>
+                </AmplitudeProvider>
+              </UserIdentityProvider>
+            </FeatureFlagServiceProvider>
+          </LocalStorageProvider>
+        </NewOrgConfigProvider>
+      </GraphQLProvider>
+    </EnviveConfigProvider>
+  </EnviveContext.Provider>
+);

package/src/contexts/enviveContext/index.ts

@@ -0,0 +1,2 @@
+export * from './enviveContext';
+export * from './types';

package/src/contexts/enviveContext/types.ts

@@ -0,0 +1,4 @@
+export enum EnviveAgent {
+  SalesAgent = 'sales',
+  SearchAgent = 'search',
+}