@envive-ai/react-hooks 0.1.6 → 0.1.8

package/dist/contexts/chatContext/index.js

@@ -0,0 +1,324 @@
+import "../../types-D3uOF0Oy.js";
+import "../../events-BHJJjPDN.js";
+import { createAppLoadedEvent, createVisitUserEvent } from "../../utils-Bcz5kAgP.js";
+import { useMessageInterceptor } from "../../useMessageInterceptor-D5oAekXn.js";
+import { logger_default } from "../../logger-CkhQayOW.js";
+import { MessageRole, MessageType } from "../../models-C48U9q70.js";
+import "../../featureGates-2Zea2D2S.js";
+import "../../urlsParser-DzEetiey.js";
+import "../../graphql-DRLWdYEk.js";
+import "../../utils-CEKzBcN2.js";
+import "../../api-d5uWvb3-.js";
+import "../../utilityTypes-DynzxjK3.js";
+import "../../variantInfo-BtOYUGWa.js";
+import "../../localStorageContext-DiTziaPa.js";
+import "../../enviveConfig-BQB14yuH.js";
+import "../../orgAnalyticsConfig-BC4_sEmn.js";
+import { getAtomStore } from "../../atomStore-BuopbV9k.js";
+import { chatIdAtom, supportedEventAtom, userIdAtom, variantInfoAtom } from "../../app-B9r0MF9n.js";
+import "../../enviveConfigContext-BCpBKqsz.js";
+import { SpiffyMetricsEventName } from "../../amplitudeContext-YRS1QOO3.js";
+import { messageFromResponse } from "../../utils-CVovRwlw.js";
+import "../../domObserver-B19-69gW.js";
+import "../../atomStore-BS6qtYZF.js";
+import { messagesAtom, requestFailureAtom, responseStreamingAtom, suggestionsAtom, suggestionsLoadingAtom, userEventsAtom, userHasRepliedAtom } from "../../chatState-ie771Hwy.js";
+import "../../graphqlConfig-BnjOdeX7.js";
+import { PerfMetricsEvents, chatAtom, clearUserEventAtom, createResponsePayload, logPerfMetricAtom, processUserEventAtom, userEventQueueAtom, userQueueEventCountAtom } from "../../chat-BNDYKsqF.js";
+import "../../org-CeWXnpwF.js";
+import "../../newOrgConfigAtom-bn1lnljf.js";
+import "../../utils-CqBxIpEV.js";
+import { chatSearchIsLoadingAtom, chatSearchProductSortingAtom, chatSearchProducts, chatSearchStateAtom, handleSearchResultsAtom } from "../../chatSearch-BiF2__V0.js";
+import "../../types-CS0Hrzja.js";
+import { SessionRestartRequired } from "../../unsupportedProductExceptions-ClxlJ6cU.js";
+import { commerce_api_default } from "../../commerce-api-Dz1jxPOJ.js";
+import { useAmplitudeTracking } from "../../useAmplitudeOperations-BottjwT9.js";
+import "../../systemSettingsContext-Dqng3YSZ.js";
+import { useSystemSettingsContext } from "../../SystemSettingsContext-gtrccL_q.js";
+import { UserEventCategory } from "@spiffy-ai/commerce-api-client";
+import { v4 } from "uuid";
+import { createContext, useCallback, useEffect, useMemo, useState } from "react";
+import { useAtom, useAtomValue, useSetAtom } from "jotai";
+import { jsx } from "react/jsx-runtime";
+
+//#region src/contexts/chatContext/chatContext.tsx
+/**
+* Record the chat assistant response in Amplitude
+*
+* @param startTimeMs The start time of the assistant response
+* @param payload The payload used to generate the response
+*/
+const recordAssistantResponse = (startTimeMs, payload, track) => {
+	const atomStore = getAtomStore();
+	const chatState = atomStore.get(chatAtom);
+	const chatSearchState = atomStore.get(chatSearchStateAtom);
+	const searchProducts = atomStore.get(chatSearchProducts);
+	const searchProductsSort = atomStore.get(chatSearchProductSortingAtom);
+	const assistantResponseTimeMs = {
+		start: startTimeMs,
+		end: Date.now()
+	};
+	let userQueryProperty;
+	if (chatState.replyEventCategory === UserEventCategory.SuggestionClicked && chatState.suggestion) userQueryProperty = chatState.suggestion.content;
+	else if (chatState.userQuery && chatState.userQuery.length > 0) userQueryProperty = chatState.userQuery;
+	const eventProps = {
+		response_time_ms: assistantResponseTimeMs.end - assistantResponseTimeMs.start,
+		user_event_type: chatState.replyEventCategory,
+		user_query: userQueryProperty
+	};
+	if (chatState.replyEventCategory === UserEventCategory.FormSubmitted) {
+		const lastAssistantTurn = chatState.messages.filter((turn) => turn.length > 0 && turn[0].role === MessageRole.Assistant).pop();
+		const formType = payload.userEvents?.find((event) => event.category === UserEventCategory.FormSubmitted)?.attributes.formType;
+		const formStatus = lastAssistantTurn?.some((response) => response.type === MessageType.Order);
+		eventProps.form_submitted_attributes = {
+			form_type: formType,
+			status: formStatus ? "success" : "failed"
+		};
+	}
+	if (chatSearchState === "product-page") {
+		eventProps.search_products_returned = searchProducts.length;
+		eventProps.search_products_sort_type = searchProductsSort;
+	}
+	track(SpiffyMetricsEventName.ChatAssistantResponse, { eventProps });
+};
+const ChatContext = createContext(void 0);
+const updateMessageState = (message, lastMessage, setMessages) => {
+	if (lastMessage == null) {
+		setMessages((prev) => [...prev, [message]]);
+		return message;
+	}
+	if (lastMessage.type === MessageType.Text && message.type === MessageType.Text) {
+		const newMessage = {
+			...lastMessage,
+			metadata: {
+				...lastMessage.metadata,
+				content: lastMessage.metadata.content + message.metadata.content
+			}
+		};
+		setMessages((prev) => {
+			const lastTurn = prev[prev.length - 1];
+			return [...prev.slice(0, prev.length - 1), [...lastTurn.slice(0, lastTurn.length - 1), newMessage]];
+		});
+		return newMessage;
+	}
+	setMessages((prev) => [...prev.slice(0, prev.length - 1), [...prev[prev.length - 1], message]]);
+	return message;
+};
+const handleStreamingError = (_error, setRequestFailure, setMessages) => {
+	setRequestFailure(true);
+	setMessages((prev) => [...prev, [{
+		id: v4(),
+		role: MessageRole.Assistant,
+		type: MessageType.Text,
+		createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+		metadata: { content: "I'm sorry! I'm having trouble right now. Please refresh the page or try again in a moment." }
+	}]]);
+};
+const processStreamingResponse = async (stream, messageInterceptor, handleSearchResults, setMessages, setSearchIsLoading, chatId) => {
+	let lastMessage;
+	let hasSearchResults = false;
+	for await (const response of stream) try {
+		if (messageInterceptor.intercept(response)) return { hasSearchResults };
+		const message = messageFromResponse(response);
+		if (!message) throw new Error("Failed to transform API response to client message");
+		if (message.type === MessageType.ProductSearch) {
+			handleSearchResults(message);
+			hasSearchResults = true;
+			setSearchIsLoading(false);
+		}
+		lastMessage = updateMessageState(message, lastMessage, setMessages);
+	} catch (error) {
+		logger_default.logWarn(`[spiffy-ai] Failed to generate responses from stream chat_id=${chatId}`, error, {
+			lastResponse: lastMessage,
+			response
+		});
+	}
+	return { hasSearchResults };
+};
+const ChatContextProvider = ({ children }) => {
+	const logPerfMetric = useSetAtom(logPerfMetricAtom);
+	const [widgetInitialized, setWidgetInitialized] = useState(false);
+	const setUserHasReplied = useSetAtom(userHasRepliedAtom);
+	const [messages, setMessages] = useAtom(messagesAtom);
+	const setUserEvents = useSetAtom(userEventsAtom);
+	const setSuggestions = useSetAtom(suggestionsAtom);
+	const [suggestionsLoading, setSuggestionsLoading] = useAtom(suggestionsLoadingAtom);
+	const [responseStreaming, setResponseStreaming] = useAtom(responseStreamingAtom);
+	const setRequestFailure = useSetAtom(requestFailureAtom);
+	const userEvents = useAtomValue(userEventQueueAtom);
+	const userQueueEventCount = useAtomValue(userQueueEventCountAtom);
+	const markUserEventsProcessed = useSetAtom(processUserEventAtom);
+	const clearUserEventQueue = useSetAtom(clearUserEventAtom);
+	const userId = useAtomValue(userIdAtom);
+	const chatId = useAtomValue(chatIdAtom);
+	const supportedEvent = useAtomValue(supportedEventAtom);
+	const orgId = "mock-org-id";
+	const variantInfo = useAtomValue(variantInfoAtom);
+	const settingsContext = useSystemSettingsContext();
+	const messageInterceptor = useMessageInterceptor();
+	const handleSearchResults = useSetAtom(handleSearchResultsAtom);
+	const setSearchIsLoading = useSetAtom(chatSearchIsLoadingAtom);
+	const { track } = useAmplitudeTracking();
+	const getStreamingResponses = useCallback(async (payload) => {
+		logPerfMetric(PerfMetricsEvents.FirstResponseStarted);
+		const stream = commerce_api_default.getNextResponseStreaming(payload);
+		try {
+			setRequestFailure(false);
+			const { hasSearchResults } = await processStreamingResponse(stream, messageInterceptor, handleSearchResults, setMessages, setSearchIsLoading, chatId);
+			return { hasSearchResults };
+		} catch (e) {
+			handleStreamingError(e, setRequestFailure, setMessages);
+			throw e;
+		} finally {
+			logPerfMetric(PerfMetricsEvents.FirstResponseCompleted);
+		}
+	}, [
+		logPerfMetric,
+		setRequestFailure,
+		messageInterceptor,
+		handleSearchResults,
+		setMessages,
+		setSearchIsLoading,
+		chatId
+	]);
+	const getSuggestions = useCallback(async () => {
+		logPerfMetric(PerfMetricsEvents.FirstSuggestionsStarted);
+		setSuggestionsLoading(true);
+		setSuggestions([]);
+		const payloadWithoutAppLoaded = createResponsePayload({
+			userEvents: [],
+			generationParams: settingsContext.generationParams
+		});
+		const response = await commerce_api_default.getNextSuggestions(payloadWithoutAppLoaded);
+		setSuggestions(response.sort((a, b) => a.content.length - b.content.length));
+		setSuggestionsLoading(false);
+		logPerfMetric(PerfMetricsEvents.FirstSuggestionsCompleted);
+	}, [
+		logPerfMetric,
+		setSuggestionsLoading,
+		setSuggestions,
+		settingsContext.generationParams
+	]);
+	const getResponses = useCallback(async (payload) => {
+		try {
+			const requestPayload = payload ?? createResponsePayload({
+				userEvents,
+				generationParams: settingsContext.generationParams
+			});
+			setResponseStreaming(true);
+			setSuggestions([]);
+			const startTimeMs = Date.now();
+			await getStreamingResponses(requestPayload);
+			recordAssistantResponse(startTimeMs, requestPayload, track);
+			await getSuggestions();
+		} catch (error) {
+			logger_default.logError("[spiffy-ai] getResponses error", error);
+		} finally {
+			markUserEventsProcessed(userEvents.map(({ eventId }) => eventId));
+			setUserHasReplied(false);
+			setResponseStreaming(false);
+		}
+	}, [
+		userEvents,
+		settingsContext.generationParams,
+		setResponseStreaming,
+		setSuggestions,
+		getStreamingResponses,
+		markUserEventsProcessed,
+		getSuggestions,
+		setUserHasReplied,
+		track
+	]);
+	useEffect(() => {
+		const processUserEvents = async () => {
+			if (responseStreaming || !widgetInitialized) return;
+			if (variantInfo.variant === "pdp" && !variantInfo.productId || variantInfo.variant === "plp" && !variantInfo.plpId || variantInfo.variant === "page_visit" && !variantInfo.url) {
+				logger_default.logDebug("[spiffy-ai] variantInfo has invalid values, skipping...", {
+					variantInfo,
+					supportedEvent
+				});
+				return;
+			}
+			logger_default.logDebug(`Assistants Turn is_currently_streaming=${responseStreaming} initialized=${widgetInitialized}`);
+			try {
+				await getResponses();
+				logger_default.logInfo(`Assistants Turn [finished]`);
+			} catch (error) {
+				logger_default.logError("[spiffy-ai] Assistants Turn error", error);
+			}
+		};
+		if (userQueueEventCount > 0) processUserEvents();
+	}, [
+		getResponses,
+		responseStreaming,
+		userQueueEventCount,
+		widgetInitialized,
+		variantInfo,
+		supportedEvent
+	]);
+	useEffect(() => {
+		if (widgetInitialized || responseStreaming) {
+			logger_default.logDebug(`[spiffy-ai] initializeWidget [skipped] is_currently_streaming=${responseStreaming} is_initialized=${widgetInitialized}`);
+			return;
+		}
+		const hydrateChat = async () => {
+			try {
+				logger_default.logDebug(`[spiffy-ai] initializeWidget is_currently_streaming=${responseStreaming} is_initialized=${widgetInitialized}`);
+				const { messages: existingMessages, userEvents: userEvents$1 } = await commerce_api_default.getResponses(orgId, chatId, userId);
+				setMessages([...existingMessages]);
+				setUserEvents([...userEvents$1]);
+				getResponses();
+			} catch (error) {
+				logger_default.logInfo(`Init chat [exception] chat_id=${chatId} error=${error}`, error);
+				if (error instanceof SessionRestartRequired) {
+					const appLoadedEvent = createAppLoadedEvent();
+					const visitEvent = createVisitUserEvent({ variantInfo });
+					setMessages([]);
+					clearUserEventQueue();
+					if (visitEvent) {
+						const payload = createResponsePayload({
+							userEvents: [appLoadedEvent, visitEvent],
+							generationParams: settingsContext.generationParams
+						});
+						getResponses(payload);
+					}
+				}
+			} finally {
+				setWidgetInitialized(true);
+			}
+		};
+		hydrateChat();
+	}, []);
+	const onFocus = useCallback(async () => {
+		try {
+			if (!responseStreaming && !suggestionsLoading && orgId) {
+				const { messages: existingMessages } = await commerce_api_default.getResponses(orgId, chatId, userId);
+				if (existingMessages.length > messages.length) setMessages([...existingMessages]);
+			}
+		} catch (error) {
+			logger_default.logError("[spiffy-ai] onFocus error", error);
+		}
+	}, [
+		responseStreaming,
+		suggestionsLoading,
+		orgId,
+		chatId,
+		userId,
+		messages.length,
+		setMessages
+	]);
+	useEffect(() => {
+		window.addEventListener("focus", onFocus);
+		return () => {
+			window.removeEventListener("focus", onFocus);
+		};
+	}, [onFocus]);
+	const chatContext = useMemo(() => ({}), []);
+	return /* @__PURE__ */ jsx(ChatContext.Provider, {
+		value: chatContext,
+		children
+	});
+};
+
+//#endregion
+export { ChatContext, ChatContextProvider };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"index.js","names":["userQueryProperty: string | undefined","eventProps: Record<string, unknown>","uuid","lastMessage: Message | undefined","error: unknown","CommerceApiClient","userEvents"],"sources":["../../../src/contexts/chatContext/chatContext.tsx"],"sourcesContent":["import { UserEventCategory } from \"@spiffy-ai/commerce-api-client\";\nimport { useAtom, useAtomValue, useSetAtom } from \"jotai\";\nimport {\n  createContext,\n  useEffect,\n  useState,\n  ReactNode,\n  useCallback,\n  useMemo,\n} from \"react\";\nimport CommerceApiClient from \"src/application/commerce-api\";\nimport { v4 as uuid } from \"uuid\";\nimport { SessionRestartRequired } from \"src/types/exceptions/sessionExceptions\";\nimport Logger from \"src/application/logging/logger\";\nimport {\n  Message,\n  MessageRole,\n  MessageType,\n  NextMessageRequest,\n  Response,\n} from \"src/application/models\";\nimport { SpiffyMetricsEventName } from \"src/contexts/amplitudeContext/amplitudeContext\";\nimport { messageFromResponse } from \"src/application/utils\";\nimport { chatIdAtom, userIdAtom, variantInfoAtom } from \"src/atoms/app\";\nimport {\n  messagesAtom,\n  requestFailureAtom,\n  responseStreamingAtom,\n  userHasRepliedAtom,\n  PerfMetricsEvents,\n  logPerfMetricAtom,\n  userEventsAtom,\n  suggestionsLoadingAtom,\n  suggestionsAtom,\n} from \"src/atoms/chat\";\nimport {\n  chatSearchProductSortingAtom,\n  chatSearchProducts,\n  chatSearchStateAtom,\n  handleSearchResultsAtom,\n  chatSearchIsLoadingAtom,\n} from \"src/atoms/search/chatSearch\";\nimport { createAppLoadedEvent, createVisitUserEvent } from \"src/hooks/utils\";\nimport { useMessageInterceptor } from \"src/interceptors/useMessageInterceptor\";\nimport { supportedEventAtom } from \"src/atoms/app/variant\";\nimport { chatAtom } from \"src/atoms/chat\";\nimport { getAtomStore } from \"src/atoms/atomStore\";\nimport {\n  clearUserEventAtom,\n  createResponsePayload,\n  processUserEventAtom,\n  userEventQueueAtom,\n  userQueueEventCountAtom,\n} from \"src/atoms/chat/messageQueue\";\nimport { useAmplitudeTracking } from \"src/hooks/AmplitudeOperations/useAmplitudeOperations\";\nimport { useSystemSettingsContext } from \"src/hooks/SystemSettingsContext\";\n\n/**\n * Record the chat assistant response in Amplitude\n *\n * @param startTimeMs The start time of the assistant response\n * @param payload The payload used to generate the response\n */\nconst recordAssistantResponse = (\n  startTimeMs: number,\n  payload: NextMessageRequest,\n  track: (\n    eventName: SpiffyMetricsEventName,\n    eventProps?: Record<string, unknown>\n  ) => void\n) => {\n  const atomStore = getAtomStore();\n  const chatState = atomStore.get(chatAtom);\n  const chatSearchState = atomStore.get(chatSearchStateAtom);\n  const searchProducts = atomStore.get(chatSearchProducts);\n  const searchProductsSort = atomStore.get(chatSearchProductSortingAtom);\n  const assistantResponseTimeMs = { start: startTimeMs, end: Date.now() };\n  let userQueryProperty: string | undefined;\n\n  if (\n    chatState.replyEventCategory === UserEventCategory.SuggestionClicked &&\n    chatState.suggestion\n  ) {\n    userQueryProperty = chatState.suggestion.content;\n  } else if (chatState.userQuery && chatState.userQuery.length > 0) {\n    userQueryProperty = chatState.userQuery;\n  }\n\n  const eventProps: Record<string, unknown> = {\n    response_time_ms:\n      assistantResponseTimeMs.end - assistantResponseTimeMs.start,\n    user_event_type: chatState.replyEventCategory,\n    user_query: userQueryProperty,\n  };\n\n  if (chatState.replyEventCategory === UserEventCategory.FormSubmitted) {\n    const lastAssistantTurn = chatState.messages\n      .filter(\n        (turn) => turn.length > 0 && turn[0].role === MessageRole.Assistant\n      )\n      .pop();\n    const formType = payload.userEvents?.find(\n      (event) => event.category === UserEventCategory.FormSubmitted\n    )?.attributes.formType;\n    const formStatus = lastAssistantTurn?.some(\n      (response) => response.type === MessageType.Order\n    );\n    eventProps.form_submitted_attributes = {\n      form_type: formType,\n      status: formStatus ? \"success\" : \"failed\",\n    };\n  }\n\n  if (chatSearchState === \"product-page\") {\n    eventProps.search_products_returned = searchProducts.length;\n    eventProps.search_products_sort_type = searchProductsSort;\n  }\n\n  track(SpiffyMetricsEventName.ChatAssistantResponse, {\n    eventProps,\n  });\n};\n\ninterface ChatContextParams {}\n\nconst ChatContext = createContext<ChatContextParams | undefined>(undefined);\n\nconst updateMessageState = (\n  message: Message,\n  lastMessage: Message,\n  setMessages: (updater: (prev: Message[][]) => Message[][]) => void\n): Message => {\n  if (lastMessage == null) {\n    setMessages((prev) => [...prev, [message]]);\n    return message;\n  }\n  if (\n    lastMessage.type === MessageType.Text &&\n    message.type === MessageType.Text\n  ) {\n    const newMessage = {\n      ...lastMessage,\n      metadata: {\n        ...lastMessage.metadata,\n        content: lastMessage.metadata.content + message.metadata.content,\n      },\n    };\n    setMessages((prev) => {\n      const lastTurn = prev[prev.length - 1];\n      return [\n        ...prev.slice(0, prev.length - 1),\n        [...lastTurn.slice(0, lastTurn.length - 1), newMessage],\n      ];\n    });\n    return newMessage;\n  }\n  setMessages((prev) => [\n    ...prev.slice(0, prev.length - 1),\n    [...prev[prev.length - 1], message],\n  ]);\n  return message;\n};\n\nconst handleStreamingError = (\n  _error: unknown,\n  setRequestFailure: (failed: boolean) => void,\n  setMessages: (updater: (prev: Message[][]) => Message[][]) => void\n) => {\n  setRequestFailure(true);\n  setMessages((prev) => [\n    ...prev,\n    [\n      {\n        id: uuid(),\n        role: MessageRole.Assistant,\n        type: MessageType.Text,\n        createdAt: new Date().toISOString(),\n        metadata: {\n          content:\n            \"I'm sorry! I'm having trouble right now. Please refresh the page or try again in a moment.\",\n        },\n      },\n    ],\n  ]);\n};\n\nconst processStreamingResponse = async (\n  stream: AsyncIterable<Response>,\n  messageInterceptor: {\n    intercept: (response?: Response) => boolean | undefined;\n  },\n  handleSearchResults: (message: Message) => void,\n  setMessages: (updater: (prev: Message[][]) => Message[][]) => void,\n  setSearchIsLoading: (loading: boolean) => void,\n  chatId: string\n): Promise<{ hasSearchResults: boolean }> => {\n  let lastMessage: Message | undefined;\n  let hasSearchResults = false;\n\n  for await (const response of stream) {\n    try {\n      if (messageInterceptor.intercept(response)) {\n        return { hasSearchResults };\n      }\n\n      const message = messageFromResponse(response);\n      if (!message) {\n        throw new Error(\"Failed to transform API response to client message\");\n      }\n\n      if (message.type === MessageType.ProductSearch) {\n        handleSearchResults(message);\n        hasSearchResults = true;\n        setSearchIsLoading(false); // Update search loading immediately when results are detected\n      }\n\n      lastMessage = updateMessageState(message, lastMessage!, setMessages);\n    } catch (error: unknown) {\n      Logger.logWarn(\n        `[spiffy-ai] Failed to generate responses from stream chat_id=${chatId}`,\n        error,\n        {\n          lastResponse: lastMessage,\n          response,\n        }\n      );\n    }\n  }\n\n  return { hasSearchResults };\n};\n\nconst ChatContextProvider = ({ children }: { children: ReactNode }) => {\n  const logPerfMetric = useSetAtom(logPerfMetricAtom);\n  const [widgetInitialized, setWidgetInitialized] = useState(false);\n  const setUserHasReplied = useSetAtom(userHasRepliedAtom);\n  // TODO: create atoms for setting/getting the last message turn\n  const [messages, setMessages] = useAtom<Message[][]>(messagesAtom);\n  const setUserEvents = useSetAtom(userEventsAtom);\n  const setSuggestions = useSetAtom(suggestionsAtom);\n  const [suggestionsLoading, setSuggestionsLoading] = useAtom<boolean>(\n    suggestionsLoadingAtom\n  );\n  const [responseStreaming, setResponseStreaming] = useAtom<boolean>(\n    responseStreamingAtom\n  );\n  const setRequestFailure = useSetAtom(requestFailureAtom);\n  const userEvents = useAtomValue(userEventQueueAtom);\n  const userQueueEventCount = useAtomValue(userQueueEventCountAtom);\n  const markUserEventsProcessed = useSetAtom(processUserEventAtom);\n  const clearUserEventQueue = useSetAtom(clearUserEventAtom);\n  const userId = useAtomValue(userIdAtom);\n  const chatId = useAtomValue(chatIdAtom);\n  const supportedEvent = useAtomValue(supportedEventAtom);\n  // TODO: Replace with actual orgId from useEnviveConfig or NewOrgConfigContext when available\n  const orgId = \"mock-org-id\";\n\n  const variantInfo = useAtomValue(variantInfoAtom);\n  const settingsContext = useSystemSettingsContext();\n  const messageInterceptor = useMessageInterceptor();\n  const handleSearchResults = useSetAtom(handleSearchResultsAtom);\n  const setSearchIsLoading = useSetAtom(chatSearchIsLoadingAtom);\n  const { track } = useAmplitudeTracking();\n\n  const getStreamingResponses = useCallback(\n    async (\n      payload: NextMessageRequest\n    ): Promise<{ hasSearchResults: boolean }> => {\n      logPerfMetric(PerfMetricsEvents.FirstResponseStarted);\n      const stream = CommerceApiClient.getNextResponseStreaming(payload);\n\n      try {\n        setRequestFailure(false);\n\n        const { hasSearchResults } = await processStreamingResponse(\n          stream,\n          messageInterceptor,\n          handleSearchResults,\n          setMessages,\n          setSearchIsLoading,\n          chatId\n        );\n\n        return { hasSearchResults };\n      } catch (e) {\n        handleStreamingError(e, setRequestFailure, setMessages);\n        throw e;\n      } finally {\n        logPerfMetric(PerfMetricsEvents.FirstResponseCompleted);\n      }\n    },\n    [\n      logPerfMetric,\n      setRequestFailure,\n      messageInterceptor,\n      handleSearchResults,\n      setMessages,\n      setSearchIsLoading,\n      chatId,\n    ]\n  );\n\n  const getSuggestions = useCallback(async () => {\n    logPerfMetric(PerfMetricsEvents.FirstSuggestionsStarted);\n    setSuggestionsLoading(true);\n    setSuggestions([]);\n\n    const payloadWithoutAppLoaded = createResponsePayload({\n      userEvents: [],\n      generationParams: settingsContext.generationParams,\n    });\n    const response = await CommerceApiClient.getNextSuggestions(\n      payloadWithoutAppLoaded\n    );\n\n    // sort the suggestions by shortest length so the pills can be stacked horizontally\n    setSuggestions(\n      response.sort((a, b) => a.content.length - b.content.length)\n    );\n    setSuggestionsLoading(false);\n    logPerfMetric(PerfMetricsEvents.FirstSuggestionsCompleted);\n  }, [\n    logPerfMetric,\n    setSuggestionsLoading,\n    setSuggestions,\n    settingsContext.generationParams,\n  ]);\n\n  const getResponses = useCallback(\n    async (payload?: NextMessageRequest) => {\n      try {\n        const requestPayload =\n          payload ??\n          createResponsePayload({\n            userEvents,\n            generationParams: settingsContext.generationParams,\n          });\n\n        setResponseStreaming(true);\n        setSuggestions([]);\n        const startTimeMs = Date.now();\n\n        await getStreamingResponses(requestPayload);\n\n        recordAssistantResponse(startTimeMs, requestPayload, track);\n        await getSuggestions();\n      } catch (error) {\n        Logger.logError(\"[spiffy-ai] getResponses error\", error);\n      } finally {\n        // Remove search loading management from here - it's now handled independently\n        // in the processStreamingResponse function when search results are detected\n        markUserEventsProcessed(userEvents.map(({ eventId }) => eventId));\n        setUserHasReplied(false);\n        setResponseStreaming(false);\n      }\n    },\n    [\n      userEvents,\n      settingsContext.generationParams,\n      setResponseStreaming,\n      setSuggestions,\n      getStreamingResponses,\n      markUserEventsProcessed,\n      getSuggestions,\n      setUserHasReplied,\n      track,\n    ]\n  );\n\n  useEffect(() => {\n    const processUserEvents = async () => {\n      if (responseStreaming || !widgetInitialized) {\n        return;\n      }\n\n      if (\n        (variantInfo.variant === \"pdp\" && !variantInfo.productId) ||\n        (variantInfo.variant === \"plp\" && !variantInfo.plpId) ||\n        (variantInfo.variant === \"page_visit\" && !variantInfo.url)\n      ) {\n        Logger.logDebug(\n          \"[spiffy-ai] variantInfo has invalid values, skipping...\",\n          {\n            variantInfo,\n            supportedEvent,\n          }\n        );\n        return;\n      }\n\n      Logger.logDebug(\n        `Assistants Turn is_currently_streaming=${responseStreaming} initialized=${widgetInitialized}`\n      );\n      try {\n        await getResponses();\n        Logger.logInfo(`Assistants Turn [finished]`);\n      } catch (error: unknown) {\n        Logger.logError(\"[spiffy-ai] Assistants Turn error\", error);\n      }\n    };\n    if (userQueueEventCount > 0) {\n      processUserEvents();\n    }\n  }, [\n    getResponses,\n    responseStreaming,\n    userQueueEventCount,\n    widgetInitialized,\n    variantInfo,\n    supportedEvent,\n  ]);\n\n  useEffect(() => {\n    if (widgetInitialized || responseStreaming) {\n      Logger.logDebug(\n        `[spiffy-ai] initializeWidget [skipped] is_currently_streaming=${responseStreaming} is_initialized=${widgetInitialized}`\n      );\n      return;\n    }\n\n    const hydrateChat = async () => {\n      try {\n        Logger.logDebug(\n          `[spiffy-ai] initializeWidget is_currently_streaming=${responseStreaming} is_initialized=${widgetInitialized}`\n        );\n        // on mount, try to get the responses from an active session if one exists\n        if (!orgId) {\n          throw new Error(\"orgId is not available\");\n        }\n        const { messages: existingMessages, userEvents } =\n          await CommerceApiClient.getResponses(orgId, chatId, userId);\n        setMessages([...existingMessages]);\n        setUserEvents([...userEvents]);\n        getResponses();\n      } catch (error) {\n        // no active chat session was found, start a new one\n        Logger.logInfo(\n          `Init chat [exception] chat_id=${chatId} error=${error}`,\n          error\n        );\n        if (error instanceof SessionRestartRequired) {\n          const appLoadedEvent = createAppLoadedEvent();\n          const visitEvent = createVisitUserEvent({ variantInfo });\n          setMessages([]);\n          clearUserEventQueue();\n          if (visitEvent) {\n            const payload = createResponsePayload({\n              userEvents: [appLoadedEvent, visitEvent],\n              generationParams: settingsContext.generationParams,\n            });\n            getResponses(payload);\n          }\n        }\n      } finally {\n        setWidgetInitialized(true);\n      }\n    };\n\n    hydrateChat();\n  }, []);\n\n  const onFocus = useCallback(async () => {\n    try {\n      if (!responseStreaming && !suggestionsLoading && orgId) {\n        const { messages: existingMessages } =\n          await CommerceApiClient.getResponses(orgId, chatId, userId);\n\n        if (existingMessages.length > messages.length) {\n          setMessages([...existingMessages]);\n          // TODO: Is this bug hack still necessary?\n          // If it is, come up with a better solution for it\n          // } else if (existingMessages.length === 0) {\n          //   // if there was an error during the initialization of a new session, the session would be\n          //   // created in the backend but without any messages. Retry the next_responses request with\n          //   // the current set of parameters to \"jumpstart\" the session\n          //   triggerGetResponseCall('onFocus');\n        }\n      }\n    } catch (error: unknown) {\n      Logger.logError(\"[spiffy-ai] onFocus error\", error);\n    }\n  }, [\n    responseStreaming,\n    suggestionsLoading,\n    orgId,\n    chatId,\n    userId,\n    messages.length,\n    setMessages,\n  ]);\n\n  // listen for page focus to get latest messages from the server\n  useEffect(() => {\n    window.addEventListener(\"focus\", onFocus);\n\n    return () => {\n      window.removeEventListener(\"focus\", onFocus);\n    };\n  }, [onFocus]);\n\n  const chatContext = useMemo(() => ({}), []);\n\n  return (\n    <ChatContext.Provider value={chatContext}>{children}</ChatContext.Provider>\n  );\n};\n\nexport { ChatContext, ChatContextProvider };\nexport type { ChatContextParams };\n"],"mappings":"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"}

package/dist/contexts/enviveConfigContext/index.cjs

@@ -0,0 +1,7 @@
+require('../../logger-DQ0WfCcD.cjs');
+require('../../localStorageContext-S38L0OSP.cjs');
+require('../../enviveConfig-DAA9sozZ.cjs');
+const require_enviveConfigContext = require('../../enviveConfigContext-Btg5JUMG.cjs');
+
+exports.EnviveConfigProvider = require_enviveConfigContext.EnviveConfigProvider;
+exports.useEnviveConfig = require_enviveConfigContext.useEnviveConfig;

package/dist/contexts/enviveConfigContext/index.d.cts

@@ -0,0 +1,30 @@
+import "../../chatElementDisplayLocation-DWmfNX_u.cjs";
+import { EnviveConfig, OrgConfigFeatureGate } from "../../frontendConfig-DnMZfvcA.cjs";
+import "../../test-types-ThQiO_cc.cjs";
+import React, { ReactNode } from "react";
+
+//#region src/contexts/enviveConfigContext/enviveConfigContext.d.ts
+interface EnviveConfigProviderProps {
+  children: ReactNode;
+  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[];
+}
+declare const EnviveConfigProvider: React.FC<EnviveConfigProviderProps>;
+declare const useEnviveConfig: () => EnviveConfig;
+//#endregion
+export { EnviveConfigProvider, useEnviveConfig };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC5jdHMiLCJuYW1lcyI6W10sInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2NvbnRleHRzL2Vudml2ZUNvbmZpZ0NvbnRleHQvZW52aXZlQ29uZmlnQ29udGV4dC5kLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCBSZWFjdCwgeyBSZWFjdE5vZGUgfSBmcm9tIFwicmVhY3RcIjtcbmltcG9ydCB7IE9yZ0NvbmZpZ0ZlYXR1cmVHYXRlIH0gZnJvbSBcInNyYy9hcHBsaWNhdGlvbi9tb2RlbHMvYXBpL29yZ0NvbmZpZ1Jlc3VsdHNcIjtcbmltcG9ydCB7IEVudml2ZUNvbmZpZyB9IGZyb20gXCIuLi90eXBlc1wiO1xuaW50ZXJmYWNlIEVudml2ZUNvbmZpZ1Byb3ZpZGVyUHJvcHMge1xuICAgIGNoaWxkcmVuOiBSZWFjdE5vZGU7XG4gICAgYW1wbGl0dWRlQXBpS2V5Pzogc3RyaW5nO1xuICAgIGRhdGFSZXNpZGVuY3k/OiBzdHJpbmc7XG4gICAgZW52Pzogc3RyaW5nO1xuICAgIGJhc2VVcmw/OiBzdHJpbmc7XG4gICAgcmVhY3RBcHBOYW1lPzogc3RyaW5nO1xuICAgIGNkblVybD86IHN0cmluZztcbiAgICBjb250ZXh0U291cmNlPzogc3RyaW5nO1xuICAgIG9yZ0xldmVsQXBpS2V5Pzogc3RyaW5nO1xuICAgIG9yZ1Nob3J0TmFtZT86IHN0cmluZztcbiAgICBpZGVudGlmeWluZ1ByZWZpeDogc3RyaW5nO1xuICAgIGZlYXR1cmVPdmVycmlkZXM/OiBSZWNvcmQ8c3RyaW5nLCBib29sZWFuPjtcbiAgICB2YXJpYW50VXJsT3ZlcnJpZGU/OiBzdHJpbmc7XG4gICAgdmFyaWFudEluZm9PdmVycmlkZT86IGFueTtcbiAgICBzaG93PzogYm9vbGVhbjtcbiAgICBwdWJsaWNLZXk/OiBzdHJpbmc7XG4gICAgZmVhdHVyZUdhdGVzPzogT3JnQ29uZmlnRmVhdHVyZUdhdGVbXTtcbn1cbmV4cG9ydCBkZWNsYXJlIGNvbnN0IEVudml2ZUNvbmZpZ1Byb3ZpZGVyOiBSZWFjdC5GQzxFbnZpdmVDb25maWdQcm92aWRlclByb3BzPjtcbmV4cG9ydCBkZWNsYXJlIGNvbnN0IHVzZUVudml2ZUNvbmZpZzogKCkgPT4gRW52aXZlQ29uZmlnO1xuZXhwb3J0IHt9O1xuIl0sIm1hcHBpbmdzIjoiOzs7Ozs7QUFHQSxJQUFJLDRCQUE0QjtDQUFDO09BQUc7T0FBQTtPQUFBO0NBQUE7QUFDcEMsSUFBVyx1QkFBWTtDQUFBO09BQUE7T0FBQSxNQUFBO0NBQUE7QUFDdkIsSUFBVyxrQkFBaUIsQ0FBQSxXQUFBLGFBQUEifQ==

package/dist/contexts/enviveConfigContext/index.d.ts

@@ -0,0 +1,30 @@
+import "../../chatElementDisplayLocation-BwiXrkN7.js";
+import { EnviveConfig, OrgConfigFeatureGate } from "../../frontendConfig-Dqxbqo8G.js";
+import "../../test-types-EzMFw_U3.js";
+import React, { ReactNode } from "react";
+
+//#region src/contexts/enviveConfigContext/enviveConfigContext.d.ts
+interface EnviveConfigProviderProps {
+  children: ReactNode;
+  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[];
+}
+declare const EnviveConfigProvider: React.FC<EnviveConfigProviderProps>;
+declare const useEnviveConfig: () => EnviveConfig;
+//#endregion
+export { EnviveConfigProvider, useEnviveConfig };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsIm5hbWVzIjpbXSwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvY29udGV4dHMvZW52aXZlQ29uZmlnQ29udGV4dC9lbnZpdmVDb25maWdDb250ZXh0LmQudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IFJlYWN0LCB7IFJlYWN0Tm9kZSB9IGZyb20gXCJyZWFjdFwiO1xuaW1wb3J0IHsgT3JnQ29uZmlnRmVhdHVyZUdhdGUgfSBmcm9tIFwic3JjL2FwcGxpY2F0aW9uL21vZGVscy9hcGkvb3JnQ29uZmlnUmVzdWx0c1wiO1xuaW1wb3J0IHsgRW52aXZlQ29uZmlnIH0gZnJvbSBcIi4uL3R5cGVzXCI7XG5pbnRlcmZhY2UgRW52aXZlQ29uZmlnUHJvdmlkZXJQcm9wcyB7XG4gICAgY2hpbGRyZW46IFJlYWN0Tm9kZTtcbiAgICBhbXBsaXR1ZGVBcGlLZXk/OiBzdHJpbmc7XG4gICAgZGF0YVJlc2lkZW5jeT86IHN0cmluZztcbiAgICBlbnY/OiBzdHJpbmc7XG4gICAgYmFzZVVybD86IHN0cmluZztcbiAgICByZWFjdEFwcE5hbWU/OiBzdHJpbmc7XG4gICAgY2RuVXJsPzogc3RyaW5nO1xuICAgIGNvbnRleHRTb3VyY2U/OiBzdHJpbmc7XG4gICAgb3JnTGV2ZWxBcGlLZXk/OiBzdHJpbmc7XG4gICAgb3JnU2hvcnROYW1lPzogc3RyaW5nO1xuICAgIGlkZW50aWZ5aW5nUHJlZml4OiBzdHJpbmc7XG4gICAgZmVhdHVyZU92ZXJyaWRlcz86IFJlY29yZDxzdHJpbmcsIGJvb2xlYW4+O1xuICAgIHZhcmlhbnRVcmxPdmVycmlkZT86IHN0cmluZztcbiAgICB2YXJpYW50SW5mb092ZXJyaWRlPzogYW55O1xuICAgIHNob3c/OiBib29sZWFuO1xuICAgIHB1YmxpY0tleT86IHN0cmluZztcbiAgICBmZWF0dXJlR2F0ZXM/OiBPcmdDb25maWdGZWF0dXJlR2F0ZVtdO1xufVxuZXhwb3J0IGRlY2xhcmUgY29uc3QgRW52aXZlQ29uZmlnUHJvdmlkZXI6IFJlYWN0LkZDPEVudml2ZUNvbmZpZ1Byb3ZpZGVyUHJvcHM+O1xuZXhwb3J0IGRlY2xhcmUgY29uc3QgdXNlRW52aXZlQ29uZmlnOiAoKSA9PiBFbnZpdmVDb25maWc7XG5leHBvcnQge307XG4iXSwibWFwcGluZ3MiOiI7Ozs7OztBQUdBLElBQUksNEJBQTRCO0NBQUM7T0FBRztPQUFBO09BQUE7Q0FBQTtBQUNwQyxJQUFXLHVCQUFZO0NBQUE7T0FBQTtPQUFBLE1BQUE7Q0FBQTtBQUN2QixJQUFXLGtCQUFpQixDQUFBLFdBQUEsYUFBQSJ9

package/dist/contexts/enviveConfigContext/index.js

@@ -0,0 +1,6 @@
+import "../../logger-CkhQayOW.js";
+import "../../localStorageContext-DiTziaPa.js";
+import "../../enviveConfig-BQB14yuH.js";
+import { EnviveConfigProvider, useEnviveConfig } from "../../enviveConfigContext-BCpBKqsz.js";
+
+export { EnviveConfigProvider, useEnviveConfig };

package/dist/contexts/enviveCssContext/index.cjs

@@ -0,0 +1,66 @@
+const require_chunk = require('../../chunk-CUT6urMc.cjs');
+require('../../types-BwNrLPSZ.cjs');
+require('../../logger-DQ0WfCcD.cjs');
+require('../../models-Ctn-pmug.cjs');
+require('../../featureGates-BY2Zy7x_.cjs');
+require('../../urlsParser-D1nsJgQG.cjs');
+require('../../graphql-xPDT7ZkK.cjs');
+require('../../utils-CsMbZmRw.cjs');
+require('../../api-DYjHj_hR.cjs');
+require('../../utilityTypes-xb8SjKSV.cjs');
+require('../../variantInfo-B7IwRpCg.cjs');
+require('../../localStorageContext-S38L0OSP.cjs');
+require('../../enviveConfig-DAA9sozZ.cjs');
+require('../../newOrgConfigAtom-D6R-7HCk.cjs');
+require('../../graphqlContext-B7PEKDJs.cjs');
+require('../../useGraphQLConfig-Dw8dDh3T.cjs');
+require('../../featureFlagServiceContext-Bcx5yh4S.cjs');
+require('../../newOrgConfigContext-D3WoaBVU.cjs');
+const require_NewOrgConfig = require('../../NewOrgConfig-DmidHiyj.cjs');
+let react = require("react");
+react = require_chunk.__toESM(react);
+let react_jsx_runtime = require("react/jsx-runtime");
+react_jsx_runtime = require_chunk.__toESM(react_jsx_runtime);
+
+//#region src/contexts/enviveCssContext/enviveCssContext.tsx
+const EnviveCssProvider = ({ children }) => {
+	const { colorsConfig, frontendConfig, loading } = require_NewOrgConfig.useNewOrgConfig();
+	let merchantThemeCss = `* {}`;
+	if (colorsConfig && !loading) merchantThemeCss = `
+* {
+  --spiffy-colors-text-primary: ${colorsConfig.textPrimary};
+  --spiffy-colors-text-secondary: ${colorsConfig.textSecondary};
+  --spiffy-colors-text-accent: ${colorsConfig.textAccent};
+  --spiffy-colors-text-link: ${colorsConfig.textLink};
+  --spiffy-colors-text-light: ${colorsConfig.textLight};
+  --spiffy-colors-background-primary: ${colorsConfig.backgroundPrimary};
+  --spiffy-colors-background-secondary: ${colorsConfig.backgroundSecondary};
+  --spiffy-colors-background-secondary-dark: ${colorsConfig.backgroundSecondaryDark};
+  --spiffy-colors-background-tertiary: ${colorsConfig.backgroundTertiary};
+  --spiffy-colors-background-dark: ${colorsConfig.backgroundDark};
+  --spiffy-colors-background-light: ${colorsConfig.backgroundLight};
+  --spiffy-colors-background-saturated: ${colorsConfig.backgroundSaturated};
+  --spiffy-colors-border-light: ${colorsConfig.borderLight};
+  --spiffy-colors-border-medium: ${colorsConfig.borderMedium};
+  --spiffy-colors-border-dark: ${colorsConfig.borderDark};
+  --spiffy-colors-border-outline: ${colorsConfig.borderOutline};
+  --spiffy-colors-accent-primary: ${colorsConfig.accentPrimary};
+  --spiffy-colors-accent-secondary: ${colorsConfig.accentSecondary};
+}`;
+	console.log(frontendConfig);
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(react_jsx_runtime.Fragment, { children: [
+		frontendConfig ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)("style", {
+			id: "merchant-css-overrides",
+			children: `${frontendConfig.merchantOverrideCss}`
+		}) : null,
+		colorsConfig ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)("style", {
+			id: "merchant-css-colors",
+			children: `${merchantThemeCss}`
+		}) : null,
+		children
+	] });
+};
+
+//#endregion
+exports.EnviveCssProvider = EnviveCssProvider;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/contexts/enviveCssContext/index.d.cts

@@ -0,0 +1,10 @@
+import React, { ReactNode } from "react";
+
+//#region src/contexts/enviveCssContext/enviveCssContext.d.ts
+interface EnviveCssProviderProps {
+  children: ReactNode;
+}
+declare const EnviveCssProvider: React.FC<EnviveCssProviderProps>;
+//#endregion
+export { EnviveCssProvider };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC5jdHMiLCJuYW1lcyI6W10sInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2NvbnRleHRzL2Vudml2ZUNzc0NvbnRleHQvZW52aXZlQ3NzQ29udGV4dC5kLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCBSZWFjdCwgeyBSZWFjdE5vZGUgfSBmcm9tIFwicmVhY3RcIjtcbmludGVyZmFjZSBFbnZpdmVDc3NQcm92aWRlclByb3BzIHtcbiAgICBjaGlsZHJlbjogUmVhY3ROb2RlO1xufVxuZXhwb3J0IGRlY2xhcmUgY29uc3QgRW52aXZlQ3NzUHJvdmlkZXI6IFJlYWN0LkZDPEVudml2ZUNzc1Byb3ZpZGVyUHJvcHM+O1xuZXhwb3J0IHt9O1xuIl0sIm1hcHBpbmdzIjoiOzs7QUFDQSxJQUFJLHlCQUF5QixDQUFDLFdBQUcsVUFBQTtBQUNqQyxJQUFXLG9CQUFZO0NBQUE7T0FBQTtPQUFBLE1BQUE7Q0FBQSJ9

package/dist/contexts/enviveCssContext/index.d.ts

@@ -0,0 +1,10 @@
+import React, { ReactNode } from "react";
+
+//#region src/contexts/enviveCssContext/enviveCssContext.d.ts
+interface EnviveCssProviderProps {
+  children: ReactNode;
+}
+declare const EnviveCssProvider: React.FC<EnviveCssProviderProps>;
+//#endregion
+export { EnviveCssProvider };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsIm5hbWVzIjpbXSwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvY29udGV4dHMvZW52aXZlQ3NzQ29udGV4dC9lbnZpdmVDc3NDb250ZXh0LmQudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IFJlYWN0LCB7IFJlYWN0Tm9kZSB9IGZyb20gXCJyZWFjdFwiO1xuaW50ZXJmYWNlIEVudml2ZUNzc1Byb3ZpZGVyUHJvcHMge1xuICAgIGNoaWxkcmVuOiBSZWFjdE5vZGU7XG59XG5leHBvcnQgZGVjbGFyZSBjb25zdCBFbnZpdmVDc3NQcm92aWRlcjogUmVhY3QuRkM8RW52aXZlQ3NzUHJvdmlkZXJQcm9wcz47XG5leHBvcnQge307XG4iXSwibWFwcGluZ3MiOiI7OztBQUNBLElBQUkseUJBQXlCLENBQUMsV0FBRyxVQUFBO0FBQ2pDLElBQVcsb0JBQVk7Q0FBQTtPQUFBO09BQUEsTUFBQTtDQUFBIn0=

package/dist/contexts/enviveCssContext/index.js

@@ -0,0 +1,63 @@
+import "../../types-D3uOF0Oy.js";
+import "../../logger-CkhQayOW.js";
+import "../../models-C48U9q70.js";
+import "../../featureGates-2Zea2D2S.js";
+import "../../urlsParser-DzEetiey.js";
+import "../../graphql-DRLWdYEk.js";
+import "../../utils-CEKzBcN2.js";
+import "../../api-d5uWvb3-.js";
+import "../../utilityTypes-DynzxjK3.js";
+import "../../variantInfo-BtOYUGWa.js";
+import "../../localStorageContext-DiTziaPa.js";
+import "../../enviveConfig-BQB14yuH.js";
+import "../../newOrgConfigAtom-bn1lnljf.js";
+import "../../graphqlContext-B-9g2vOb.js";
+import "../../useGraphQLConfig-DZ0ZannB.js";
+import "../../featureFlagServiceContext-_tXX5iro.js";
+import "../../newOrgConfigContext-rWOYz0E8.js";
+import { useNewOrgConfig } from "../../NewOrgConfig-BU6uJT74.js";
+import React from "react";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+
+//#region src/contexts/enviveCssContext/enviveCssContext.tsx
+const EnviveCssProvider = ({ children }) => {
+	const { colorsConfig, frontendConfig, loading } = useNewOrgConfig();
+	let merchantThemeCss = `* {}`;
+	if (colorsConfig && !loading) merchantThemeCss = `
+* {
+  --spiffy-colors-text-primary: ${colorsConfig.textPrimary};
+  --spiffy-colors-text-secondary: ${colorsConfig.textSecondary};
+  --spiffy-colors-text-accent: ${colorsConfig.textAccent};
+  --spiffy-colors-text-link: ${colorsConfig.textLink};
+  --spiffy-colors-text-light: ${colorsConfig.textLight};
+  --spiffy-colors-background-primary: ${colorsConfig.backgroundPrimary};
+  --spiffy-colors-background-secondary: ${colorsConfig.backgroundSecondary};
+  --spiffy-colors-background-secondary-dark: ${colorsConfig.backgroundSecondaryDark};
+  --spiffy-colors-background-tertiary: ${colorsConfig.backgroundTertiary};
+  --spiffy-colors-background-dark: ${colorsConfig.backgroundDark};
+  --spiffy-colors-background-light: ${colorsConfig.backgroundLight};
+  --spiffy-colors-background-saturated: ${colorsConfig.backgroundSaturated};
+  --spiffy-colors-border-light: ${colorsConfig.borderLight};
+  --spiffy-colors-border-medium: ${colorsConfig.borderMedium};
+  --spiffy-colors-border-dark: ${colorsConfig.borderDark};
+  --spiffy-colors-border-outline: ${colorsConfig.borderOutline};
+  --spiffy-colors-accent-primary: ${colorsConfig.accentPrimary};
+  --spiffy-colors-accent-secondary: ${colorsConfig.accentSecondary};
+}`;
+	console.log(frontendConfig);
+	return /* @__PURE__ */ jsxs(Fragment, { children: [
+		frontendConfig ? /* @__PURE__ */ jsx("style", {
+			id: "merchant-css-overrides",
+			children: `${frontendConfig.merchantOverrideCss}`
+		}) : null,
+		colorsConfig ? /* @__PURE__ */ jsx("style", {
+			id: "merchant-css-colors",
+			children: `${merchantThemeCss}`
+		}) : null,
+		children
+	] });
+};
+
+//#endregion
+export { EnviveCssProvider };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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