@envive-ai/react-hooks 0.1.5 → 0.1.6

package/dist/contexts-DGlr7M1o.js

@@ -0,0 +1,2596 @@
+import { FeatureGates, MessageRole, MessageType, ProductExperiment, SpiffyWidgets, getMerchantOrgIdQuery, transformSnakeToCamel, validateGraphQLOrgId, validateOrgConfigResults, validateResponse, validateSuggestion, validateUserEvent } from "./models-UZ6HszfZ.js";
+import { OrgShortName, getOrgInfo } from "./types--pr1GQQx.js";
+import { configVersion, parseHref } from "./graphql-CjB8wHzm.js";
+import { logger_default } from "./api-DjeZXxl_.js";
+import { LocalStorageKeys, baseUrlAtom, cdnUrlAtom, contextSourceAtom, envAtom, orgLevelApiKeyAtom, orgShortNameAtom, reactAppNameAtom, useLocalStorage } from "./enviveConfig-CzhTz8Aa.js";
+import { getAtomStore } from "./atomStore-D8pjE1vL.js";
+import { chatIdAtom, hasParsedVariantInfoAtom, supportedEventAtom, userIdAtom, variantInfoAtom } from "./app-CjsQ2_n-.js";
+import { SpiffyMetricsEventName, useAmplitude, useEnviveConfig } from "./amplitudeContext-hY3caPC6.js";
+import { DOMObserver, coreSupportedEventRequestToApiRequest, messageFromFormSubmittedEvent, messageFromQueryEvent, messageFromResponse, messageFromSuggestionEvent, messageRequestToCommerceMessageRequest } from "./utils-C9ZSCx12.js";
+import { featureFlagServiceAtom, orgIdAtom } from "./graphqlConfig-CYt6tWII.js";
+import { PerfMetricsEvents, chatAtom, chatOnToggleAtom, clearUserEventAtom, createResponsePayload, logPerfMetricAtom, messagesAtom, processUserEventAtom, requestFailureAtom, responseStreamingAtom, suggestionsAtom, suggestionsLoadingAtom, userEventQueueAtom, userEventsAtom, userHasRepliedAtom, userQueueEventCountAtom } from "./chat-hcRc4RRd.js";
+import { newOrgConfigAtom } from "./org-xMytX--e.js";
+import { ProductSorting, addSearchFilterAtom, chatSearchIsLoadingAtom, chatSearchProductSortingAtom, chatSearchProducts, chatSearchStateAtom, clearSearchFiltersAtom, clearSearchServiceFunction, createFilterOption, filteredSearchProductsAtom, formatFilterDisplayName, handleSearchResultsAtom, performSearchAtom, removeSearchFilterAtom, searchAtom, searchFiltersAtom, searchParamsAtom, searchProductSortingAtom, searchSelectedFiltersAtom, setSearchServiceFunction } from "./search-BMOAmrmY.js";
+import { autocompleteStateAtom, isFilterOpenAtom } from "./globalSearch-B6THR7Jx.js";
+import { useMessageInterceptor } from "./useMessageInterceptor-Bb7YRaWk.js";
+import React, { createContext, useCallback, useContext, useEffect, useMemo, useRef, useState } from "react";
+import { useAtom, useAtomValue, useSetAtom } from "jotai";
+import { Configuration, ContextEnvEnum, ContextSourceEnum, CustomerServiceApi, DefaultApi, FormType, InferenceApi, PLPAttributeCategory, ResponseCategory, ResponseError, SearchApi, UserEventCategory, V1OrgConfigGetSourceEnum } from "@spiffy-ai/commerce-api-client";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { v4 } from "uuid";
+import UAParser from "ua-parser-js";
+
+//#region src/contexts/cdnContext.tsx
+const CdnContext = createContext(null);
+const CdnProvider = ({ children }) => {
+	const cdnUrl = useAtomValue(cdnUrlAtom) || "https://cdn.spiffy.ai/other";
+	const getCdnBasePath = useCallback(() => {
+		return cdnUrl;
+	}, [cdnUrl]);
+	const getAssetURL = useCallback((assetName, orgShortName) => {
+		return `${getCdnBasePath()}/assets/${orgShortName}/${assetName}`;
+	}, [getCdnBasePath]);
+	const value = useMemo(() => ({
+		cdnUrl,
+		getCdnBasePath,
+		getAssetURL
+	}), [
+		cdnUrl,
+		getCdnBasePath,
+		getAssetURL
+	]);
+	return /* @__PURE__ */ jsx(CdnContext.Provider, {
+		value,
+		children
+	});
+};
+const useCdn = () => {
+	const context = useContext(CdnContext);
+	if (!context) throw new Error("useCdn must be used within a CdnProvider");
+	return context;
+};
+
+//#endregion
+//#region src/types/exceptions/sessionExceptions.ts
+var SessionRestartRequired = class extends Error {
+	constructor() {
+		super("Session restart required");
+		this.name = "SessionRestartRequired";
+	}
+};
+
+//#endregion
+//#region src/types/exceptions/unsupportedProductExceptions.ts
+var UnsupportedProductException = class extends Error {
+	constructor() {
+		super("Unsupported product");
+		this.name = "UnsupportedProduct";
+	}
+};
+
+//#endregion
+//#region src/application/commerce-api.ts
+async function errorResponseBody$1(error) {
+	try {
+		return await error.response.json();
+	} catch {
+		return {};
+	}
+}
+async function throwSessionRestartRequiredIf$1(errorMsg, error) {
+	if (!(error instanceof ResponseError)) {
+		logger_default.logInfo(errorMsg, error);
+		throw error;
+	}
+	const errorResponse = await errorResponseBody$1(error);
+	if (errorResponse?.message?.toLowerCase() === "unsupported product" || errorResponse?.app_code?.toUpperCase() === "PRODUCT_NOT_FOUND") throw new UnsupportedProductException();
+	else if (errorResponse?.app_code?.toUpperCase() === "RESTART_SESSION" || errorResponse?.sub_code?.toUpperCase() === "NOT_FOUND") {
+		logger_default.logInfo("Session does not exist. Re-start session", error, error.response, errorResponse);
+		throw new SessionRestartRequired();
+	}
+	logger_default.logInfo(errorMsg, error);
+	throw error;
+}
+var CommerceApiClient = class CommerceApiClient {
+	static {
+		this.getInstance = () => {
+			if (!CommerceApiClient.instance) CommerceApiClient.instance = new CommerceApiClient();
+			return CommerceApiClient.instance;
+		};
+	}
+	constructor(basePath) {
+		this.suggestionsAbortController = new AbortController();
+		this.responsesAbortController = new AbortController();
+		const baseUrl = getAtomStore().get(baseUrlAtom);
+		const config = new Configuration({
+			basePath: basePath || baseUrl,
+			headers: {
+				"Content-Type": "application/json",
+				Accept: "application/json"
+			}
+		});
+		this.defaultApi = new DefaultApi(config);
+		this.inferenceApi = new InferenceApi(config);
+		this.customerServiceApi = new CustomerServiceApi(config);
+	}
+	static {
+		this.resolveUrl = async (url) => {
+			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 = {
+				user_id: userId ?? "",
+				org_id: orgId ?? "",
+				org_short_name: orgShortName ?? "",
+				chat_id: chatId ?? "",
+				source: source ?? ContextSourceEnum.App,
+				env: env ?? ContextEnvEnum.Dev
+			};
+			const featureGates = featureFlagService?.featureFlagService?.getFeatureFlags() || {};
+			const urlResolvingRequest = {
+				url,
+				context,
+				feature_gates: featureGates
+			};
+			return await (await CommerceApiClient.getInstance().inferenceApi.v1UrlResolvingPostRaw({ UrlResolvingRequest: urlResolvingRequest })).raw.json();
+		};
+	}
+	static {
+		this.reportSession = async (reportRequest) => {
+			await CommerceApiClient.getInstance().defaultApi.v1ChatsReportSessionIdPost({ ReportSessionRequest: reportRequest });
+		};
+	}
+	static {
+		this.getNextResponses = async (payload) => {
+			try {
+				return (await CommerceApiClient.getInstance().inferenceApi.v1NextResponsesPost({ NextMessageRequest: messageRequestToCommerceMessageRequest(payload) })).map((resp) => validateResponse(resp)).map((resp) => messageFromResponse(resp)).filter((m) => m != null);
+			} catch (err) {
+				logger_default.logInfo("Failed to get next responses", err, {
+					payloadContext: payload?.context,
+					userEvents: payload?.userEvents
+				});
+				await throwSessionRestartRequiredIf$1("Failed to get next responses", err);
+				return [];
+			}
+		};
+	}
+	static {
+		this.getNextResponseStreaming = (payload) => {
+			async function* generate(inferenceApi, abortController) {
+				try {
+					const response = await inferenceApi.v1NextResponsesPostRaw({ NextMessageRequest: messageRequestToCommerceMessageRequest(payload) }, { signal: abortController.signal });
+					if (!response.raw.body) {
+						logger_default.logError("[spiffy-ai] No body in the streamed response", void 0, { response: response.raw });
+						return;
+					}
+					const reader = response.raw.body.getReader();
+					const decoder = new TextDecoder("utf-8");
+					let partial = "";
+					const safeParse = (line) => {
+						try {
+							return JSON.parse(line);
+						} catch (err) {
+							logger_default.logError("[spiffy-ai] Error parsing streamed line", err, {
+								line,
+								partial
+							});
+							partial = line;
+							return partial;
+						}
+					};
+					const processChunk = (chunk) => {
+						return `${partial}${chunk}`.split("\n").map((line) => line.replace(/^data: /, "").trim()).filter((line) => line !== "" && line !== "[DONE]").map(safeParse).filter((v) => v);
+					};
+					while (true) {
+						const { done, value } = await reader.read();
+						if (done) break;
+						const chunk = decoder.decode(value);
+						const parsedLines = processChunk(chunk);
+						for (const parsedLine of parsedLines) {
+							const validatedResponse = validateResponse(parsedLine);
+							if (validatedResponse) yield validatedResponse;
+						}
+					}
+				} catch (error) {
+					logger_default.logError("[spiffy-ai] Failed to get next streaming responses", error, {
+						payloadContext: payload?.context,
+						userEvents: payload?.userEvents
+					});
+					await throwSessionRestartRequiredIf$1("Failed to get next streaming responses", error);
+				}
+			}
+			CommerceApiClient.getInstance().responsesAbortController.abort();
+			CommerceApiClient.getInstance().responsesAbortController = new AbortController();
+			return generate(CommerceApiClient.getInstance().inferenceApi, CommerceApiClient.getInstance().responsesAbortController);
+		};
+	}
+	static {
+		this.getNextSuggestions = async (payload) => {
+			try {
+				CommerceApiClient.getInstance().suggestionsAbortController.abort();
+				CommerceApiClient.getInstance().suggestionsAbortController = new AbortController();
+				return (await CommerceApiClient.getInstance().inferenceApi.v1NextSuggestionsPost({ NextMessageRequest: messageRequestToCommerceMessageRequest(payload) }, { signal: CommerceApiClient.getInstance().suggestionsAbortController.signal })).map((resp) => validateSuggestion(resp)).filter((suggestion) => suggestion != null);
+			} catch (error) {
+				logger_default.logInfo("Failed to get suggestions", error, {
+					payloadContext: payload?.context,
+					userEvents: payload?.userEvents
+				});
+				await throwSessionRestartRequiredIf$1("Failed to get suggestions", error);
+				return [];
+			}
+		};
+	}
+	static {
+		this.getResponses = async (orgId, chatId, userId) => {
+			let data = {
+				responses: [],
+				suggestions: [],
+				user_events: []
+			};
+			const request = {
+				org_id: orgId,
+				chat_id: chatId,
+				user_id: userId
+			};
+			try {
+				data = await CommerceApiClient.getInstance().defaultApi.v1GetSessionMessages(request);
+			} catch (error) {
+				await throwSessionRestartRequiredIf$1("Failed to get chat responses", error);
+			}
+			const responses = data?.responses?.map((turn) => turn.map((response) => validateResponse(response)).filter((response) => response != null));
+			const suggestions = data?.suggestions.map((suggestion) => validateSuggestion(suggestion)).filter((suggestion) => suggestion != null);
+			const userEvents = data?.user_events.map((event) => validateUserEvent(event)).filter((event) => event != null);
+			const formSubmittedUserEventsFormIds = userEvents.filter((event) => event.category === UserEventCategory.FormSubmitted).map((event) => event.attributes.formResponseId);
+			const assistantMessages = responses.map((turn) => turn.filter((response) => !(response.category === ResponseCategory.Form && formSubmittedUserEventsFormIds.includes(response.id))).map((response) => messageFromResponse(response)).filter((message) => message != null)).filter((turn) => turn.length > 0);
+			const userMessages = userEvents.map((event) => {
+				if ([UserEventCategory.QueryTyped, UserEventCategory.Search].includes(event.category)) return [messageFromQueryEvent(event)];
+				if (event.category === UserEventCategory.SuggestionClicked) return [messageFromSuggestionEvent(event, suggestions)];
+				if (event.category === UserEventCategory.FormSubmitted) {
+					const formResponse = responses.flat().find((response) => response.id === event.attributes.formResponseId && event.attributes.formType !== FormType.Escalation);
+					if (formResponse && formResponse.category === ResponseCategory.Form) return [messageFromFormSubmittedEvent(event, formResponse.attributes)];
+				}
+				return [];
+			}).filter((message) => message.length > 0);
+			const sortedMessages = [...assistantMessages, ...userMessages].sort((a, b) => new Date(a[0].createdAt).getTime() - new Date(b[0].createdAt).getTime());
+			return {
+				responses,
+				userEvents,
+				suggestions,
+				messages: sortedMessages
+			};
+		};
+	}
+	static {
+		this.isSupportedEvent = async (payload) => {
+			try {
+				const httpResponseText = await (await CommerceApiClient.getInstance().inferenceApi.v1SupportedEventPostRaw({ SupportedEventRequest: coreSupportedEventRequestToApiRequest(payload) })).raw.text();
+				const httpResponseJson = JSON.parse(httpResponseText);
+				return {
+					...httpResponseJson,
+					numberOfReviews: httpResponseJson.num_of_reviews,
+					merchant_tags: httpResponseJson.merchant_tags || []
+				};
+			} catch (err) {
+				logger_default.logError("Failed to get response for v1SupportedEventPost", { err });
+				return {
+					supported: false,
+					ready: false,
+					category: void 0,
+					collections: [],
+					numberOfReviews: void 0,
+					top_category: void 0,
+					merchant_tags: []
+				};
+			}
+		};
+	}
+	static {
+		this.identifyUser = async (spiffyUserId, merchantUserId, uaDetails) => {
+			try {
+				await CommerceApiClient.getInstance().defaultApi.v1AnalyticsIdentifyPost({ AnalyticsIdentifyRequest: {
+					user_id: spiffyUserId,
+					os_name: uaDetails.os,
+					os_version: uaDetails.osVersion,
+					platform: uaDetails.os,
+					device_id: uaDetails.deviceModel,
+					device_brand: uaDetails.deviceBrand,
+					device_manufacturer: uaDetails.deviceManufacturer,
+					device_model: uaDetails.deviceModel,
+					user_properties: {
+						cdp_user_id: merchantUserId,
+						browser: uaDetails.browser,
+						browser_version: uaDetails.browserVersion,
+						user_agent: uaDetails.userAgent
+					}
+				} });
+			} catch (err) {
+				logger_default.logError("Failed to identify user", err);
+			}
+		};
+	}
+	static {
+		this.mapContextSourceToV1OrgConfigGetSource = (source) => {
+			if (source === void 0) return void 0;
+			switch (source) {
+				case ContextSourceEnum.Fork: return V1OrgConfigGetSourceEnum.Fork;
+				case ContextSourceEnum.Playground: return V1OrgConfigGetSourceEnum.Playground;
+				case ContextSourceEnum.App: return V1OrgConfigGetSourceEnum.App;
+				case ContextSourceEnum.Test: return V1OrgConfigGetSourceEnum.Test;
+				default: return source;
+			}
+		};
+	}
+	static {
+		this.getOrgConfig = async (user_id) => {
+			try {
+				const atomStore = getAtomStore();
+				const reactAppName = atomStore.get(reactAppNameAtom);
+				const contextSource = atomStore.get(contextSourceAtom);
+				const featureFlagService = atomStore.get(featureFlagServiceAtom);
+				const request = {
+					namespace: reactAppName,
+					user_id,
+					source: this.mapContextSourceToV1OrgConfigGetSource(contextSource),
+					include_experiments: Object.values(ProductExperiment),
+					include_feature_gates: Object.entries(featureFlagService?.featureFlagService?.getFeatureFlags() || {}).filter(([, isEnabled]) => isEnabled).map(([featureGateName]) => featureGateName)
+				};
+				const response = await CommerceApiClient.getInstance().defaultApi.v1OrgConfigGet(request);
+				return validateOrgConfigResults(response);
+			} catch (err) {
+				logger_default.logError(`Failed to get org config`, err, { err });
+				return;
+			}
+		};
+	}
+	static {
+		this.addNoteToLatestConversation = async (spiffyUserId, email, customerServiceProvider) => {
+			logger_default.logInfo(`addNoteToLatestConversation - user_id=${spiffyUserId} email=${email} customer_service_provider=${customerServiceProvider}`);
+			try {
+				await CommerceApiClient.getInstance().customerServiceApi.v1CustserviceAddNoteToLatestConversationPost({ AddNoteToLatestConversationRequest: {
+					spiffy_user_id: spiffyUserId,
+					email,
+					customer_service_provider: customerServiceProvider
+				} });
+			} catch (err) {
+				logger_default.logError("Failed to add note to latest conversation", { err });
+			}
+		};
+	}
+	static {
+		this.getCustomerServiceApi = () => CommerceApiClient.getInstance().customerServiceApi;
+	}
+};
+var commerce_api_default = CommerceApiClient;
+
+//#endregion
+//#region src/hooks/useAmplitudeOperations.ts
+const useAmplitudeTracking = () => {
+	const { trackEvent, isReady } = useAmplitude();
+	const [loading, setLoading] = useState(false);
+	const [error, setError] = useState(null);
+	return {
+		track: useCallback(async (eventName, eventProps) => {
+			if (!isReady) return;
+			setLoading(true);
+			setError(null);
+			try {
+				await trackEvent({
+					eventName,
+					eventProps
+				});
+			} catch (err) {
+				setError(err instanceof Error ? err : /* @__PURE__ */ new Error("Tracking failed"));
+				throw err;
+			} finally {
+				setLoading(false);
+			}
+		}, [trackEvent, isReady]),
+		loading,
+		error,
+		isReady
+	};
+};
+
+//#endregion
+//#region src/hooks/useBlockBackButton.ts
+const useBlockBackButton = (enabled, callback) => {
+	useEffect(() => {
+		if (enabled && window) {
+			if (window.history.scrollRestoration) window.history.scrollRestoration = "manual";
+			window.history.pushState(null, document.title, window.location.href);
+			window.onpopstate = (e) => {
+				e.preventDefault();
+				window.history.pushState(null, document.title, window.location.href);
+				callback?.();
+			};
+		}
+		return () => {
+			if (enabled && window) {
+				window.history.back();
+				window.onpopstate = null;
+				window.history.scrollRestoration = "auto";
+			}
+		};
+	}, [enabled]);
+};
+
+//#endregion
+//#region src/hooks/useCdnOperations.ts
+const useCdnUrl = () => {
+	const { cdnUrl } = useCdn();
+	return cdnUrl;
+};
+const useCdnBasePath = () => {
+	const { getCdnBasePath } = useCdn();
+	return getCdnBasePath();
+};
+const useAssetUrl = (assetName, orgShortName) => {
+	const { getAssetURL } = useCdn();
+	return getAssetURL(assetName, orgShortName);
+};
+
+//#endregion
+//#region src/hooks/useChatToggle.ts
+const useChatToggle = () => {
+	const onToggle = useSetAtom(chatOnToggleAtom);
+	const { isOpen } = useAtomValue(chatAtom);
+	const { trackEvent } = useAmplitude();
+	const toggle = (triggerLocation, triggerId) => {
+		if (!isOpen) trackEvent({
+			eventName: SpiffyMetricsEventName.ChatComponentExpanded,
+			eventProps: { message_metadata: {
+				trigger_location: triggerLocation,
+				trigger_id: triggerId
+			} }
+		});
+		else trackEvent({
+			eventName: SpiffyMetricsEventName.ChatComponentCollapsed,
+			eventProps: { message_metadata: {
+				trigger_location: triggerLocation,
+				trigger_id: triggerId
+			} }
+		});
+		onToggle();
+	};
+	const openChat = (triggerLocation, triggerId) => {
+		if (!isOpen) toggle(triggerLocation, triggerId);
+	};
+	const closeChat = (triggerLocation, triggerId) => {
+		if (isOpen) toggle(triggerLocation, triggerId);
+	};
+	return {
+		toggle,
+		isOpen,
+		openChat,
+		closeChat
+	};
+};
+
+//#endregion
+//#region src/hooks/useChatToggleAnalytics.ts
+const useChatToggleAnalytics = () => {
+	const setChatOnToggle = useSetAtom(chatOnToggleAtom);
+	const { track } = useAmplitudeTracking();
+	const toggleChat = (triggerLocation) => {
+		setChatOnToggle(triggerLocation, track);
+	};
+	return { toggleChat };
+};
+
+//#endregion
+//#region src/hooks/useCustomerSupportHandoff.ts
+/**
+* Hook to call the `click` method of the merchant's customer support chat widget.
+*
+* @param onSwitchToAgent a function to override the function returned by the hook. This is mainly to
+* preserve backward compatibility for merchants not using Kustomer and will be removed when all
+* CS integrations are handled.
+*
+* @returns a function that searches for the customer support chat widget and calls the `click` method.
+*/
+const useCustomerSupportHandoff = (onSwitchToAgent) => {
+	const onKustomerSwitch = useCallback(() => {
+		const kustomerElement = document.getElementById("kustomer-ui-sdk-iframe");
+		if (kustomerElement == null || !(kustomerElement instanceof HTMLIFrameElement)) {
+			logger_default.logError("[spiffy-ai] Kustomer iFrame element not found", void 0);
+			return;
+		}
+		const kustomerButton = kustomerElement.contentWindow?.document?.getElementById("rootChatIcon");
+		if (kustomerButton == null) {
+			logger_default.logError("[spiffy-ai] Kustomer button not found", void 0);
+			return;
+		}
+		kustomerButton.click();
+	}, []);
+	if (onSwitchToAgent != null) return { onSwitch: onSwitchToAgent };
+	return { onSwitch: onKustomerSwitch };
+};
+
+//#endregion
+//#region src/hooks/useDebounce.ts
+function useDebounce(value, delay) {
+	const [debouncedValue, setDebouncedValue] = useState(value);
+	useEffect(() => {
+		const handler = setTimeout(() => {
+			setDebouncedValue(value);
+		}, delay);
+		return () => {
+			clearTimeout(handler);
+		};
+	}, [value, delay]);
+	return debouncedValue;
+}
+
+//#endregion
+//#region src/hooks/useElementObserver.ts
+const useElementObserver = (selector) => {
+	const INITIAL_RENDER_STATE = true;
+	const eoRef = useRef(DOMObserver.add(selector));
+	const [renderBlocked, setRenderBlocked] = useState(INITIAL_RENDER_STATE);
+	/**
+	* Fired every time the HTML element changes.
+	*
+	* @param fn
+	*/
+	const onChange = (fn) => {
+		eoRef.current?.registerOnChange(fn);
+	};
+	/**
+	* Fired when the HTML element is added to the DOM.
+	*
+	* @param fn
+	*/
+	const onAdd = (fn) => {
+		eoRef.current?.registerOnAdd(fn);
+	};
+	/**
+	* Fired when the HTML element is removed from the DOM.
+	*
+	* @param fn
+	*/
+	const onRemove = (fn) => {
+		eoRef.current?.registerOnRemove(fn);
+	};
+	/**
+	* Fired when the class of the HTML element changes.
+	*
+	* @param fn
+	*/
+	const onClassChange = (fn) => {
+		eoRef.current?.registerOnclassChange(fn);
+	};
+	/**
+	* Fired when a class is added to the HTML element.
+	*
+	* @param className
+	* @param fn
+	*/
+	const onClassAdded = (className, fn) => {
+		eoRef.current?.registerOnClassAdded(className, fn);
+	};
+	/**
+	* Fired when a class is removed from the HTML element.
+	*
+	* @param className
+	* @param fn
+	*/
+	const onClassRemoved = (className, fn) => {
+		eoRef.current?.registerOnClassRemoved(className, fn);
+	};
+	/**
+	* Fired when a child element is added to the HTML element.
+	*
+	* @param fn
+	*/
+	const onAddChild = (fn) => {
+		eoRef.current?.registerOnAddChild(fn);
+	};
+	/**
+	* Fired when a child element is removed from the HTML element.
+	*
+	* @param fn
+	*/
+	const onRemoveChild = (fn) => {
+		eoRef.current?.registerOnRemoveChild(fn);
+	};
+	/**
+	* Allows hooking event listeners to the HTML element, such as `focus`, `blur`, etc.
+	*
+	* @param event
+	* @param fn
+	*/
+	const onEvent = (event, fn) => {
+		eoRef.current.registerEvent(event, fn);
+	};
+	/**
+	* Useful when rendering a React.js component inside the HTML element.
+	*
+	* @param fn
+	* @returns
+	*/
+	const render = (fn) => {
+		if (!renderBlocked) return eoRef.current.render(fn);
+	};
+	/**
+	* Checks if the element exists in the DOM.
+	*
+	* @returns
+	*/
+	const exists = () => !!eoRef.current.getNode();
+	/**
+	* Checks if rendering is unblocked.
+	*
+	* @returns
+	*/
+	const isRendered = () => !renderBlocked;
+	/**
+	* Triggers an event for the HTML element.
+	*
+	* @param event
+	*/
+	const fire = (event) => {
+		eoRef.current.fire(event);
+	};
+	/**
+	* Shows the HTML element.
+	*
+	* @returns
+	*/
+	const show = () => eoRef.current.show();
+	/**
+	* Hides the HTML element.
+	*
+	* @returns
+	*/
+	const hide = () => eoRef.current.hide();
+	/**
+	* Blocks the rendering of elements.
+	*
+	* @returns
+	*/
+	const blockRendering = () => setRenderBlocked(true);
+	/**
+	* Unblocks the rendering of elements.
+	*
+	* @returns
+	*/
+	const unblockRendering = () => setRenderBlocked(false);
+	/**
+	* Applies CSS styles to the HTML element.
+	*
+	* @param styles
+	*/
+	const applyStyle = (styles) => {
+		const node = eoRef?.current?.getNode();
+		node && Object.assign(node.style, styles);
+	};
+	useEffect(() => {
+		eoRef.current.init();
+		eoRef.current.registerOnReset(() => setRenderBlocked(INITIAL_RENDER_STATE));
+		DOMObserver.observe();
+		return () => DOMObserver.remove(selector);
+	}, [selector.getPattern()]);
+	return {
+		targetNode: eoRef.current.getNode(),
+		onChange,
+		onAdd,
+		onRemove,
+		onClassChange,
+		onClassAdded,
+		onClassRemoved,
+		onAddChild,
+		onRemoveChild,
+		onEvent,
+		blockRendering,
+		unblockRendering,
+		exists,
+		isRendered,
+		render,
+		fire,
+		show,
+		hide,
+		applyStyle
+	};
+};
+
+//#endregion
+//#region src/hooks/useGrabAndScroll.ts
+const animateHorizontalScroll = ({ element, duration, targetScroll, multiply = 1, direction, callback, offset = 0 }) => {
+	const start = element.scrollLeft;
+	const distance = (targetScroll - start) * multiply;
+	const startTime = performance.now();
+	function easeOutSine(x) {
+		return Math.sin(x * Math.PI / 2);
+	}
+	function scrollStep(currentTime) {
+		const timeElapsed = currentTime - startTime;
+		const progress = Math.min(timeElapsed / duration, 1);
+		const easing = easeOutSine(progress);
+		const step = start + distance * easing;
+		const canScroll = (direction === "rt" ? element.scrollLeft < step : element.scrollLeft > step) || !direction;
+		if (step > 0 && canScroll) element.scrollTo(step, 0);
+		if (timeElapsed < duration) requestAnimationFrame(scrollStep);
+		else if (element.scrollLeft + offset === element.scrollWidth) callback?.("rt");
+		else if (element.scrollLeft <= 1) callback?.("lt");
+		else callback?.("ct");
+	}
+	requestAnimationFrame(scrollStep);
+};
+const useGrabAndScroll = (enabled, chunkWidth, speed = 400, offset = 0) => {
+	const containerRef = useRef(null);
+	const [leftArrow, setLeftArrow] = useState(false);
+	const [rightArrow, setRightArrow] = useState(true);
+	const handleArrows = (position) => {
+		switch (position) {
+			case "lt":
+				setLeftArrow(false);
+				setRightArrow(true);
+				break;
+			case "rt":
+				setLeftArrow(true);
+				setRightArrow(false);
+				break;
+			default:
+				setLeftArrow(true);
+				setRightArrow(true);
+		}
+	};
+	const animationTrigger = () => {
+		if (enabled && containerRef.current) {
+			const dist = (containerRef?.current?.scrollLeft || 0) / chunkWidth;
+			const targetScroll = chunkWidth * (Math.floor(dist) + (dist % 1 > .5 ? 1 : 0));
+			animateHorizontalScroll({
+				element: containerRef.current,
+				targetScroll,
+				duration: speed,
+				offset,
+				callback: handleArrows
+			});
+		}
+	};
+	const onNext = (cardsToSlide) => {
+		if (containerRef.current) {
+			const targetScroll = containerRef.current.scrollLeft + chunkWidth;
+			animateHorizontalScroll({
+				element: containerRef.current,
+				targetScroll,
+				duration: speed,
+				direction: "rt",
+				multiply: cardsToSlide,
+				offset,
+				callback: handleArrows
+			});
+		}
+	};
+	const onPrevious = (cardsToSlide) => {
+		if (containerRef.current) {
+			const targetScroll = containerRef.current.scrollLeft - chunkWidth;
+			animateHorizontalScroll({
+				element: containerRef.current,
+				targetScroll,
+				duration: speed,
+				direction: "lt",
+				multiply: cardsToSlide,
+				offset,
+				callback: handleArrows
+			});
+		}
+	};
+	return {
+		containerRef,
+		leftArrow,
+		rightArrow,
+		animationTrigger,
+		onNext,
+		onPrevious
+	};
+};
+
+//#endregion
+//#region src/contexts/graphqlContext.tsx
+const GraphQLContext = createContext(null);
+const colorsAndFrontendConfigQuery = () => `
+  query ($version: String = "${configVersion()}") {
+    me {
+      getProductsConfigByVersion(version: $version) {
+        frontend { values }
+        colors { values }
+      }
+    }
+  }
+`;
+const GraphQLProvider = ({ children }) => {
+	const apiKey = useAtomValue(orgLevelApiKeyAtom);
+	const baseUrl = useAtomValue(baseUrlAtom);
+	const isReady = Boolean(apiKey && baseUrl);
+	const executeQuery = useCallback(async (query, variables) => {
+		if (!isReady) throw new Error("GraphQL client not ready - missing apiKey or baseUrl");
+		const response = await fetch(`${baseUrl}/v1/graphql`, {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/json",
+				Authorization: `Bearer ${apiKey}`
+			},
+			body: JSON.stringify({
+				query,
+				variables
+			})
+		});
+		if (!response.ok) throw new Error(`GraphQL request failed: ${response.statusText}`);
+		const result = await response.json();
+		if (result.errors) throw new Error(`GraphQL errors: ${JSON.stringify(result.errors)}`);
+		return result.data;
+	}, [
+		apiKey,
+		baseUrl,
+		isReady
+	]);
+	const getOrgId = useCallback(async () => {
+		const response = await executeQuery(getMerchantOrgIdQuery);
+		return validateGraphQLOrgId(response.me.org?.id);
+	}, [executeQuery]);
+	const getColorsAndFrontendConfig = useCallback(async () => {
+		try {
+			const query = await colorsAndFrontendConfigQuery();
+			if (!query) throw new Error("Colors and frontend config query is not defined");
+			const response = await executeQuery(query);
+			const colorsConfig = response.me.getProductsConfigByVersion?.colors?.values;
+			const frontendConfig = response.me.getProductsConfigByVersion?.frontend?.values;
+			const transformedColorConfig = transformSnakeToCamel(colorsConfig);
+			const transformedFrontendConfig = transformSnakeToCamel(frontendConfig);
+			return {
+				colorsConfig: transformedColorConfig,
+				frontendConfig: transformedFrontendConfig
+			};
+		} catch (err) {
+			logger_default.logError("Error fetching graphql colors and frontend config", err);
+			return {
+				colorsConfig: void 0,
+				frontendConfig: void 0
+			};
+		}
+	}, [executeQuery]);
+	const value = useMemo(() => ({
+		executeQuery,
+		getOrgId,
+		getColorsAndFrontendConfig,
+		isReady
+	}), [
+		executeQuery,
+		getOrgId,
+		getColorsAndFrontendConfig,
+		isReady
+	]);
+	return /* @__PURE__ */ jsx(GraphQLContext.Provider, {
+		value,
+		children
+	});
+};
+const useGraphQLClient = () => {
+	const context = useContext(GraphQLContext);
+	if (!context) throw new Error("useGraphQLClient must be used within a GraphQLProvider");
+	return context;
+};
+
+//#endregion
+//#region src/hooks/useGraphQLConfig.ts
+const useColorsAndFrontendConfig = () => {
+	const { getColorsAndFrontendConfig, isReady } = useGraphQLClient();
+	const [data, setData] = useState({});
+	const [loading, setLoading] = useState(false);
+	const [error, setError] = useState(null);
+	const fetchConfig = useCallback(async () => {
+		if (!isReady) return;
+		setLoading(true);
+		setError(null);
+		try {
+			const result = await getColorsAndFrontendConfig();
+			setData(result);
+		} catch (err) {
+			setError(err instanceof Error ? err : /* @__PURE__ */ new Error("Unknown error"));
+		} finally {
+			setLoading(false);
+		}
+	}, [getColorsAndFrontendConfig, isReady]);
+	useEffect(() => {
+		fetchConfig();
+	}, [fetchConfig]);
+	return {
+		data,
+		loading,
+		error,
+		refetch: fetchConfig
+	};
+};
+const useOrgId = () => {
+	const { getOrgId, isReady } = useGraphQLClient();
+	const [orgId, setOrgId] = useState();
+	const [loading, setLoading] = useState(false);
+	const [error, setError] = useState(null);
+	useEffect(() => {
+		if (!isReady) return;
+		const fetchOrgId = async () => {
+			setLoading(true);
+			setError(null);
+			try {
+				const id = await getOrgId();
+				setOrgId(id);
+			} catch (err) {
+				setError(err instanceof Error ? err : /* @__PURE__ */ new Error("Unknown error"));
+			} finally {
+				setLoading(false);
+			}
+		};
+		fetchOrgId();
+	}, [getOrgId, isReady]);
+	return {
+		orgId,
+		loading,
+		error
+	};
+};
+
+//#endregion
+//#region src/contexts/userIdentityContext.tsx
+const getUserAgentDetails = () => {
+	const result = new UAParser().getResult();
+	return {
+		os: result?.os?.name,
+		osVersion: result?.os?.version,
+		deviceBrand: result?.device?.vendor,
+		deviceManufacturer: result?.device?.vendor,
+		deviceModel: result?.device?.model,
+		browser: result?.browser?.name,
+		browserVersion: result?.browser?.version,
+		userAgent: result?.ua
+	};
+};
+const UserIdentityContext = createContext(void 0);
+const UserIdentityProvider = ({ children }) => {
+	const { getItem, setItem, isAvailable: localStorageIsReady } = useLocalStorage();
+	const [isReady, setIsReady] = useState(false);
+	useEffect(() => {
+		setIsReady(localStorageIsReady);
+	}, [localStorageIsReady]);
+	const USER_ID_OVERRIDE_KEY = "v1-spiffy-user-id-override";
+	const USER_ID_DEFAULT_KEY = "v1-spiffy-user-id-default";
+	const getUserIdOverrideFromLocalStorage = useCallback(() => {
+		return getItem(USER_ID_OVERRIDE_KEY) ?? void 0;
+	}, [getItem]);
+	const getUserIdDefaultFromLocalStorage = useCallback(() => {
+		return getItem(USER_ID_DEFAULT_KEY) ?? void 0;
+	}, [getItem]);
+	const setUserIdDefaultInLocalStorage = useCallback((userId) => {
+		logger_default.logInfo(`setUserIdDefaultInLocalStorage - Setting user_id=${userId}`);
+		setItem(USER_ID_DEFAULT_KEY, userId);
+		return userId;
+	}, [setItem, USER_ID_DEFAULT_KEY]);
+	const setUserIdOverrideInLocalStorage = useCallback((userId) => {
+		logger_default.logInfo(`setUserIdOverrideInLocalStorage - Setting user_id=${userId}`);
+		setItem(USER_ID_OVERRIDE_KEY, userId);
+		return userId;
+	}, [setItem, USER_ID_OVERRIDE_KEY]);
+	const clearUserIdOverrideInLocalStorage = useCallback(() => {
+		logger_default.logInfo(`clearUserIdOverrideInLocalStorage - Clearing user_id`);
+		setItem(USER_ID_OVERRIDE_KEY, "");
+	}, [setItem, USER_ID_OVERRIDE_KEY]);
+	const getUserIdOrDefault = useCallback(() => {
+		const userIdOverride = getUserIdOverrideFromLocalStorage();
+		if (userIdOverride) return userIdOverride;
+		const defaultUserId = getUserIdDefaultFromLocalStorage();
+		if (defaultUserId) return defaultUserId;
+		return setUserIdDefaultInLocalStorage(`spiffy-user-id-${v4()}`);
+	}, [
+		getUserIdOverrideFromLocalStorage,
+		getUserIdDefaultFromLocalStorage,
+		setUserIdDefaultInLocalStorage
+	]);
+	const identifyUser = useCallback(async () => {
+		if (!isReady) {
+			logger_default.logWarn("[UserIdentityContext] Context not ready, skipping identifyUser", void 0);
+			return;
+		}
+		try {
+			const cdpUserId = "UNKNOWN_CDP_USER_ID";
+			const userId = getUserIdOrDefault();
+			const userAgentDetails = getUserAgentDetails();
+			await commerce_api_default.identifyUser(userId, cdpUserId, userAgentDetails);
+		} catch (error) {
+			logger_default.logError("[spiffy-ai] Error identifying user", error);
+		}
+	}, [isReady, getUserIdOrDefault]);
+	const value = useMemo(() => ({
+		identifyUser,
+		getUserIdOrDefault,
+		getUserIdOverrideFromLocalStorage,
+		getUserIdDefaultFromLocalStorage,
+		setUserIdDefaultInLocalStorage,
+		setUserIdOverrideInLocalStorage,
+		clearUserIdOverrideInLocalStorage,
+		isReady
+	}), [
+		identifyUser,
+		getUserIdOrDefault,
+		getUserIdOverrideFromLocalStorage,
+		getUserIdDefaultFromLocalStorage,
+		setUserIdDefaultInLocalStorage,
+		setUserIdOverrideInLocalStorage,
+		clearUserIdOverrideInLocalStorage,
+		isReady
+	]);
+	return /* @__PURE__ */ jsx(UserIdentityContext.Provider, {
+		value,
+		children
+	});
+};
+const useUserIdentity = () => {
+	const context = useContext(UserIdentityContext);
+	if (!context) throw new Error("useUserIdentity must be used within a UserIdentityProvider");
+	return context;
+};
+
+//#endregion
+//#region src/hooks/useIdentifyUser.ts
+const useIdentifyUser = () => {
+	const { identifyUser, isReady } = useUserIdentity();
+	const [loading, setLoading] = useState(false);
+	const [error, setError] = useState(null);
+	const executeIdentifyUser = useCallback(async () => {
+		if (!isReady) {
+			setError(/* @__PURE__ */ new Error("UserIdentityContext not ready."));
+			return;
+		}
+		setLoading(true);
+		setError(null);
+		try {
+			await identifyUser();
+		} catch (err) {
+			setError(err instanceof Error ? err : /* @__PURE__ */ new Error("Unknown error during user identification."));
+			throw err;
+		} finally {
+			setLoading(false);
+		}
+	}, [identifyUser, isReady]);
+	return {
+		loading,
+		error,
+		executeIdentifyUser,
+		isReady
+	};
+};
+
+//#endregion
+//#region src/hooks/useImageResolver.ts
+var ImageResolver = class {};
+var MerchantImageResolver = class {
+	static {
+		this.imageResolverMap = /* @__PURE__ */ new Map();
+	}
+	static loadMapping() {
+		if (this.imageResolverMap.size === 0) {
+			this.imageResolverMap.set(OrgShortName.Spanx, new ShopifyImageResolver());
+			this.imageResolverMap.set(OrgShortName.SpanxStaging, new ShopifyImageResolver());
+			this.imageResolverMap.set(OrgShortName.UniqueVintage, new ShopifyImageResolver());
+		}
+		return this.imageResolverMap;
+	}
+	static get(name) {
+		return this.loadMapping().get(name);
+	}
+};
+var ShopifyImageResolver = class extends ImageResolver {
+	resolve(url, size) {
+		const pattern = /_\d+x\.jpg/;
+		const urlHasPrefix = pattern.test(url);
+		const newSizePrefix = `_${size}x.jpg`;
+		if (urlHasPrefix) return url.replace(pattern, newSizePrefix);
+		return url.replace(".jpg", newSizePrefix);
+	}
+};
+const useImageResolver = () => {
+	const orgShortName = useAtomValue(orgShortNameAtom);
+	const resolve = (image, size) => {
+		if (image && size && orgShortName) return MerchantImageResolver.get(orgShortName)?.resolve(image, size) || image;
+		return image;
+	};
+	return { resolve };
+};
+
+//#endregion
+//#region src/hooks/useIntersection.ts
+const useIntersection = (element, rootMargin) => {
+	const [isVisible, setIsVisible] = useState(false);
+	useEffect(() => {
+		const current = element?.current;
+		const observer = new IntersectionObserver(([entry]) => {
+			setIsVisible(entry.isIntersecting);
+		}, { rootMargin });
+		if (current) observer?.observe(current);
+		return () => {
+			if (current) observer.unobserve(current);
+		};
+	}, []);
+	return isVisible;
+};
+
+//#endregion
+//#region src/hooks/useIsSmallScreen.ts
+const useIsSmallScreen = () => {
+	const [isSmall, setIsSmall] = useState(false);
+	useEffect(() => {
+		const mediaQuery = window.matchMedia("(max-width: 479px)");
+		setIsSmall(mediaQuery.matches);
+		const handleResize = (event) => {
+			setIsSmall(event.matches);
+		};
+		mediaQuery.addEventListener("change", handleResize);
+		return () => mediaQuery.removeEventListener("change", handleResize);
+	}, []);
+	return isSmall;
+};
+
+//#endregion
+//#region src/hooks/useLocalStorageOperations.ts
+const useLocalStorageValue = (key) => {
+	const { getItem, setItem, attachListener, detachListener } = useLocalStorage();
+	const [value, setValue] = useState(() => getItem(key));
+	useEffect(() => {
+		const listener = {
+			storageKey: key,
+			listener: (event) => {
+				setValue(event.newValue);
+			}
+		};
+		attachListener(listener);
+		return () => detachListener(listener);
+	}, [
+		key,
+		attachListener,
+		detachListener
+	]);
+	const updateValue = useCallback((newValue) => {
+		setItem(key, newValue);
+		setValue(newValue);
+	}, [key, setItem]);
+	return {
+		value,
+		setValue: updateValue
+	};
+};
+const useSpiffyFeatureFlag = () => {
+	const { setSpiffyOnFeatureFlag } = useLocalStorage();
+	const { value } = useLocalStorageValue(LocalStorageKeys.SpiffyOnOverride);
+	const setFlag = useCallback((flag) => {
+		setSpiffyOnFeatureFlag(flag);
+	}, [setSpiffyOnFeatureFlag]);
+	return {
+		value: value === "true" ? true : value === "false" ? false : null,
+		setFlag
+	};
+};
+const useEnviveFeatureFlag = () => {
+	const { setItem, getItem } = useLocalStorage();
+	const { value } = useLocalStorageValue(LocalStorageKeys.EnviveOnOverride);
+	const setFlag = useCallback((flag) => {
+		if (flag === true) setItem(LocalStorageKeys.EnviveOnOverride, "true");
+		else if (flag === false) setItem(LocalStorageKeys.EnviveOnOverride, "false");
+	}, [setItem]);
+	return {
+		value: value === "true" ? true : value === "false" ? false : null,
+		setFlag
+	};
+};
+const useLocalStorageListener = (key, callback) => {
+	const { attachListener, detachListener } = useLocalStorage();
+	useEffect(() => {
+		const listener = {
+			storageKey: key,
+			listener: callback
+		};
+		attachListener(listener);
+		return () => detachListener(listener);
+	}, [
+		key,
+		callback,
+		attachListener,
+		detachListener
+	]);
+};
+
+//#endregion
+//#region src/hooks/useMessageFilter.ts
+const useMessageFilter = () => {
+	const findMessageIndex = ({ msgs, type, role }) => {
+		let lastIndex = -1;
+		msgs.forEach((subArray, index) => {
+			subArray.forEach((obj) => {
+				if (obj.type === type || obj.role === role) lastIndex = index;
+			});
+		});
+		return lastIndex;
+	};
+	const removePreviousDiscussions = (msgs, index) => {
+		if (index > -1) {
+			const lastMessages = msgs.slice(index);
+			return lastMessages.length > 0 ? lastMessages : msgs;
+		}
+		return msgs;
+	};
+	const getFilteredMessages = (msgs, skipFilter) => {
+		const messageMap = msgs.reduce((acc, msg) => {
+			acc[msg[0].id] = msg;
+			return acc;
+		}, {});
+		const deduplicatedMsgs = Object.values(messageMap);
+		if (!skipFilter) {
+			const idx = findMessageIndex({
+				msgs: deduplicatedMsgs,
+				type: MessageType.Separator
+			});
+			return removePreviousDiscussions(deduplicatedMsgs, idx);
+		}
+		return deduplicatedMsgs;
+	};
+	return {
+		findMessageIndex,
+		removePreviousDiscussions,
+		getFilteredMessages
+	};
+};
+
+//#endregion
+//#region src/hooks/useMessageScrollObserver.ts
+const useMessageScrollObserver = (boxRef, scrollRef, onScrollChange) => {
+	const calculateScrollHeight = () => {
+		const boxHeight = boxRef?.current?.getBoundingClientRect().height || 0;
+		const scrollHeight = scrollRef?.current?.getBoundingClientRect().height || 0;
+		return boxHeight - scrollHeight;
+	};
+	const updateState = () => {
+		const scrollHeight = calculateScrollHeight();
+		if (scrollHeight > 0) onScrollChange(scrollHeight);
+	};
+	useEffect(() => {
+		let boxRO = null;
+		let scrollRO = null;
+		if (scrollRef?.current) {
+			boxRO = new ResizeObserver(updateState);
+			boxRO.observe(scrollRef?.current);
+		}
+		if (boxRef?.current) {
+			scrollRO = new ResizeObserver(updateState);
+			scrollRO.observe(boxRef?.current);
+		}
+		return () => {
+			if (scrollRef?.current && boxRO) boxRO.unobserve(scrollRef?.current);
+			if (scrollRO && boxRef?.current) scrollRO?.unobserve(boxRef?.current);
+		};
+	}, []);
+};
+
+//#endregion
+//#region src/contexts/featureFlagServiceContext.tsx
+var FeatureFlagService = class {
+	constructor(featureGates) {
+		this.isFeatureGateEnabled = (featureGate) => {
+			const gateValue = this.featureGates.find((gate) => gate.name === featureGate);
+			if (gateValue == null || gateValue.value == null) {
+				logger_default.logDebug(`[spiffy-ai] isFeatureGateEnabled featureGate:${featureGate} value is undefined - returning false`);
+				return false;
+			}
+			return gateValue.value;
+		};
+		this.isClientSessionEnabled = () => {
+			return this.featureGates.filter((gate) => gate.name === FeatureGates.IsClientSessionEnabled && gate.value === true).length > 0;
+		};
+		this.getFeatureFlags = () => {
+			return Object.fromEntries(Object.values(FeatureGates).map((featureGate) => [featureGate, this.isFeatureGateEnabled(featureGate)]));
+		};
+		this.featureGates = featureGates;
+	}
+};
+const FeatureFlagServiceContext = createContext(void 0);
+const FeatureFlagServiceProvider = ({ featureGates, children }) => {
+	const featureFlagService = useMemo(() => new FeatureFlagService(featureGates), [featureGates]);
+	return /* @__PURE__ */ jsx(FeatureFlagServiceContext.Provider, {
+		value: { featureFlagService },
+		children
+	});
+};
+const useFeatureFlagService = () => {
+	const context = useContext(FeatureFlagServiceContext);
+	if (context === void 0) throw new Error("useFeatureFlagService must be used within a FeatureFlagServiceProvider");
+	return context;
+};
+
+//#endregion
+//#region src/contexts/newOrgConfigContext.tsx
+const NewOrgConfigContext = createContext(void 0);
+const NewOrgConfigProvider = ({ children }) => {
+	const [oldConfig, setOldConfig] = useState();
+	const orgShortName = useAtomValue(orgShortNameAtom);
+	const setNewOrgConfig = useSetAtom(newOrgConfigAtom);
+	const { data: newConfig, loading, error } = useColorsAndFrontendConfig();
+	useEffect(() => {
+		if (orgShortName) getOrgInfo(orgShortName).then(setOldConfig);
+	}, [orgShortName]);
+	const combinedConfig = useMemo(() => {
+		if (!oldConfig || !newConfig) return null;
+		return {
+			...oldConfig,
+			...newConfig
+		};
+	}, [oldConfig, newConfig]);
+	useEffect(() => {
+		const atomStore = getAtomStore();
+		if (combinedConfig) {
+			atomStore.set(orgIdAtom, "mock-org-id");
+			setNewOrgConfig(combinedConfig);
+		}
+	}, [combinedConfig, setNewOrgConfig]);
+	const contextValue = useMemo(() => {
+		if (!orgShortName || loading && !oldConfig) return {
+			combinedConfig: null,
+			loading: true,
+			error: null
+		};
+		if (error) return {
+			combinedConfig: null,
+			loading: false,
+			error
+		};
+		return {
+			combinedConfig,
+			loading: false,
+			error: null
+		};
+	}, [
+		orgShortName,
+		loading,
+		error,
+		oldConfig,
+		combinedConfig
+	]);
+	return /* @__PURE__ */ jsx(NewOrgConfigContext.Provider, {
+		value: contextValue,
+		children: /* @__PURE__ */ jsx(FeatureFlagServiceProvider, {
+			featureGates: [],
+			children
+		})
+	});
+};
+const useNewOrgConfigContext = () => {
+	const context = useContext(NewOrgConfigContext);
+	if (context === void 0) throw new Error("useNewOrgConfigContext must be used within a NewOrgConfigProvider");
+	return context;
+};
+
+//#endregion
+//#region src/hooks/useNewOrgConfig.ts
+const useNewOrgConfig = () => {
+	const { combinedConfig, loading, error } = useNewOrgConfigContext();
+	return {
+		...combinedConfig,
+		loading,
+		error
+	};
+};
+
+//#endregion
+//#region src/hooks/utils.ts
+const isElementPartiallyVisible = (el) => {
+	if (!el) return false;
+	const rect = el.getBoundingClientRect();
+	const windowHeight = window.innerHeight || document.documentElement.clientHeight;
+	const windowWidth = window.innerWidth || document.documentElement.clientWidth;
+	const verticallyVisible = Math.round(rect.top) < windowHeight && Math.round(rect.bottom) > 0;
+	const horizontallyVisible = Math.round(rect.left) < windowWidth && Math.round(rect.right) > 0;
+	return verticallyVisible && horizontallyVisible;
+};
+const createAppLoadedEvent = () => ({
+	eventId: v4(),
+	createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+	category: UserEventCategory.AppLoaded
+});
+const createVisitUserEvent = ({ variantInfo }) => {
+	if (variantInfo.variant === "pdp" && variantInfo.productId != null) return {
+		eventId: v4(),
+		createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+		category: UserEventCategory.PdpVisit,
+		attributes: {
+			productId: variantInfo.productId,
+			parentProductId: variantInfo.parentProductId ?? "",
+			url: variantInfo.url ?? ""
+		}
+	};
+	if (variantInfo.variant === "plp" && variantInfo.plpId != null) return {
+		eventId: v4(),
+		createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+		category: UserEventCategory.PlpVisit,
+		attributes: {
+			category: PLPAttributeCategory.Id,
+			attributes: { id: variantInfo.plpId }
+		}
+	};
+	if (variantInfo.variant === "page_visit") return {
+		eventId: v4(),
+		createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+		category: UserEventCategory.PageVisit,
+		attributes: {
+			url: variantInfo.url,
+			pageVisitCategory: variantInfo.pageVisitCategory
+		}
+	};
+};
+const parseTime = (time, timeZone) => {
+	const times = time.match(/^([0-1]?\d):([0-5]\d)(AM|PM)$/i);
+	const hours = times?.[1];
+	const minutes = times?.[2];
+	const period = times?.[3];
+	if (hours && minutes && period) {
+		const date = /* @__PURE__ */ new Date();
+		let adjustedHours = 0;
+		if (period.toUpperCase() === "PM" && hours !== "12") adjustedHours = parseInt(hours) + 12;
+		if (period.toUpperCase() === "AM" && hours !== "12") adjustedHours = parseInt(hours);
+		const formattedDate = `${date.toISOString().split("T")[0]}T${String(adjustedHours).padStart(2, "0")}:${minutes}:00`;
+		return /* @__PURE__ */ new Date(`${formattedDate}${timeZone}`);
+	}
+};
+const isWithinBusinessHours = (startTime, endTime, timeZone) => {
+	const start = parseTime(startTime, timeZone);
+	let end = parseTime(endTime, timeZone);
+	if (!start || !end) return false;
+	let now = /* @__PURE__ */ new Date();
+	if (end < start) {
+		end = new Date(end.getTime() + 1440 * 60 * 1e3);
+		now = new Date(now.getTime() + 1440 * 60 * 1e3);
+	}
+	if (end.getUTCDate() > start.getUTCDate()) {
+		const crossingMidnight = new Date(now.getTime() + 1440 * 60 * 1e3);
+		return start <= now || crossingMidnight <= end;
+	}
+	return now >= start && now <= end;
+};
+let SearchResultsState = /* @__PURE__ */ function(SearchResultsState$1) {
+	SearchResultsState$1[SearchResultsState$1["Loading"] = 0] = "Loading";
+	SearchResultsState$1[SearchResultsState$1["Results"] = 1] = "Results";
+	SearchResultsState$1[SearchResultsState$1["NoResults"] = 2] = "NoResults";
+	return SearchResultsState$1;
+}({});
+const getSearchResultsState = (isLoadingSearch, searchData) => {
+	if (isLoadingSearch) return SearchResultsState.Loading;
+	if (searchData) return SearchResultsState.Results;
+	return SearchResultsState.NoResults;
+};
+
+//#endregion
+//#region src/hooks/useSearch.tsx
+const useSearch = () => {
+	const config = useNewOrgConfig();
+	const orgShortName = useAtomValue(orgShortNameAtom);
+	const { data: searchData, loading: isLoadingSearch } = useAtomValue(searchAtom);
+	const productList = useAtomValue(filteredSearchProductsAtom);
+	const performSearch = useSetAtom(performSearchAtom);
+	const [{ results: autocompleteResults, isLoading: isLoadingAutocomplete }, setAutocompleteState] = useAtom(autocompleteStateAtom);
+	const [{ query }] = useAtom(searchParamsAtom);
+	const [isFilterOpen, setIsFilterOpen] = useAtom(isFilterOpenAtom);
+	const [selectedFilterOptions] = useAtom(searchSelectedFiltersAtom);
+	const addFilter = useSetAtom(addSearchFilterAtom);
+	const removeFilter = useSetAtom(removeSearchFilterAtom);
+	const [productSorting, setProductSorting] = useAtom(searchProductSortingAtom);
+	const clearFilters = useSetAtom(clearSearchFiltersAtom);
+	const searchFilters = useAtomValue(searchFiltersAtom);
+	const [isDirty, setIsDirty] = useState(true);
+	const [focusedIndex, setFocusedIndex] = useState(-1);
+	const [focusedOptionId, setFocusedOptionId] = useState(void 0);
+	const [searchText, setSearchText] = useState(query || "");
+	const searchResultsRef = useRef(null);
+	const debouncedSearchText = useDebounce(searchText, 200);
+	const searchResultsState = getSearchResultsState(isLoadingSearch, searchData);
+	const dynamicFilters = searchData?.filters || [];
+	const safeProductCardConfig = config?.frontendConfig?.uiConfigs?.productCardConfig || {
+		variant: "minimal",
+		hoverVariant: "none",
+		layoutVariant: "square"
+	};
+	const safeMerchantShortName = orgShortName || "";
+	const availableDynamicFilters = useMemo(() => {
+		return dynamicFilters.filter((dynamicFilterName) => !selectedFilterOptions.some((option) => option.id === `dynamic:${dynamicFilterName}`)).map((dynamicFilterName) => ({
+			name: dynamicFilterName,
+			displayName: formatFilterDisplayName(dynamicFilterName)
+		}));
+	}, [dynamicFilters, selectedFilterOptions]);
+	const filters = useMemo(() => {
+		return [{
+			filterId: "sort",
+			displayName: "SORT",
+			items: [
+				{
+					filterItemId: String(ProductSorting.FEATURED),
+					displayName: "Relevance",
+					productCount: 0,
+					isSelected: productSorting === ProductSorting.FEATURED
+				},
+				{
+					filterItemId: String(ProductSorting.PRICE_ASC),
+					displayName: "Price: Low to High",
+					productCount: 0,
+					isSelected: productSorting === ProductSorting.PRICE_ASC
+				},
+				{
+					filterItemId: String(ProductSorting.PRICE_DESC),
+					displayName: "Price: High to Low",
+					productCount: 0,
+					isSelected: productSorting === ProductSorting.PRICE_DESC
+				}
+			]
+		}, ...searchFilters];
+	}, [productSorting, searchFilters]);
+	const filterButtonText = useMemo(() => {
+		const selectedCount = filters.reduce((acc, filter) => {
+			if (filter.filterId === "sort") return acc;
+			return acc + filter.items.filter((item) => item.isSelected).length;
+		}, 0);
+		if (selectedCount === 0) return "Filter & Sort";
+		return `Filter & Sort (${selectedCount})`;
+	}, [filters]);
+	const { trackEvent } = useAmplitude();
+	const handleToggleDynamicFilter = useCallback(({ filter, dynamicFilterDisplayName }) => {
+		trackEvent({
+			eventName: SpiffyMetricsEventName.SearchFilterClicked,
+			eventProps: {
+				filterType: "Dynamic",
+				filterValue: filter,
+				queryText: searchText
+			}
+		});
+		addFilter(createFilterOption("dynamic", filter, dynamicFilterDisplayName));
+	}, [
+		addFilter,
+		searchText,
+		trackEvent
+	]);
+	const handleRemoveFilter = useCallback((filter) => {
+		removeFilter(filter.id);
+	}, [removeFilter]);
+	const handleSubmitSearch = useCallback(async () => {
+		if (searchText.trim()) {
+			trackEvent({
+				eventName: SpiffyMetricsEventName.SearchQuerySubmitted,
+				eventProps: {
+					searchOrigin: SpiffyWidgets.SearchResults,
+					queryText: searchText.trim()
+				},
+				alsoSendToGoogleAnalytics: true
+			});
+			const url = new URL(window.location.href);
+			url.searchParams.set("esq", searchText.trim());
+			window.history.pushState({}, "", url);
+			performSearch({ query: searchText.trim() });
+		}
+	}, [
+		performSearch,
+		searchText,
+		trackEvent
+	]);
+	const handleAutocompleteSelect = useCallback((suggestion) => {
+		setSearchText(suggestion);
+		handleSubmitSearch();
+	}, [handleSubmitSearch, setSearchText]);
+	const handleKeyDown = useCallback((event) => {
+		if (event.key === "ArrowDown") {
+			event.preventDefault();
+			const newIndex = (focusedIndex + 1) % autocompleteResults.length;
+			setFocusedIndex(newIndex);
+			setFocusedOptionId(`option-${newIndex}`);
+		} else if (event.key === "ArrowUp") {
+			event.preventDefault();
+			const newIndex = (focusedIndex - 1 + autocompleteResults.length) % autocompleteResults.length;
+			setFocusedIndex(newIndex);
+			setFocusedOptionId(`option-${newIndex}`);
+		} else if (event.key === "Enter") if (focusedIndex === -1) {
+			event.preventDefault();
+			handleSubmitSearch();
+		} else {
+			event.preventDefault();
+			const suggestionText = autocompleteResults[focusedIndex];
+			handleAutocompleteSelect(suggestionText);
+		}
+		else if (event.key === "Escape") {
+			event.preventDefault();
+			setFocusedIndex(-1);
+			setFocusedOptionId(void 0);
+		}
+	}, [
+		autocompleteResults,
+		focusedIndex,
+		handleAutocompleteSelect,
+		handleSubmitSearch
+	]);
+	const handleSearchInputChange = (newValue) => {
+		if (newValue.length === 1) trackEvent({
+			eventName: SpiffyMetricsEventName.SearchInputStarted,
+			eventProps: { searchOrigin: SpiffyWidgets.SearchResults }
+		});
+		setSearchText(newValue);
+		setIsDirty(true);
+	};
+	const handleSelectFilterItem = useCallback(({ filterId, filterItemId, isSelected, displayName }) => {
+		if (filterId === "sort") {
+			const newSort = filterItemId;
+			trackEvent({
+				eventName: SpiffyMetricsEventName.SearchSortClicked,
+				eventProps: {
+					sortType: newSort,
+					queryText: searchText
+				}
+			});
+			setProductSorting(newSort);
+		} else if (!isSelected) removeFilter(`${filterId}:${filterItemId}`);
+		else {
+			trackEvent({
+				eventName: SpiffyMetricsEventName.SearchFilterClicked,
+				eventProps: {
+					filterType: "Static",
+					filterCategory: filterId,
+					filterValue: filterItemId,
+					queryText: searchText
+				}
+			});
+			addFilter(createFilterOption(filterId, filterItemId, displayName));
+		}
+	}, [
+		addFilter,
+		removeFilter,
+		setProductSorting,
+		searchText,
+		trackEvent
+	]);
+	const handleClearAllFilters = useCallback(() => {
+		setProductSorting(ProductSorting.FEATURED);
+		clearFilters();
+	}, [setProductSorting, clearFilters]);
+	useTrackComponentVisibleEvent(SpiffyWidgets.SearchResults, searchResultsRef, {}, SpiffyMetricsEventName.SearchComponentVisible);
+	useEffect(() => {
+		if (productList.length > 0) trackEvent({
+			eventName: SpiffyMetricsEventName.SearchResultsViewed,
+			eventProps: {
+				queryText: searchText,
+				resultsCount: productList.length
+			}
+		});
+	}, [
+		productList.length,
+		searchText,
+		trackEvent
+	]);
+	useEffect(() => {
+		if (query && query !== searchText) setSearchText(query);
+	}, [query]);
+	useEffect(() => {
+		const esq = new URLSearchParams(window.location.search).get("esq");
+		if (esq) {
+			setSearchText(esq);
+			performSearch({ query: esq });
+		}
+	}, [performSearch]);
+	const fetchAutocompleteSuggestions = (_query) => {
+		return Promise.resolve([]);
+	};
+	useEffect(() => {
+		if (fetchAutocompleteSuggestions === void 0) return;
+		if (!isDirty || debouncedSearchText.length <= 2) {
+			setAutocompleteState({
+				results: [],
+				isLoading: false
+			});
+			return;
+		}
+		setAutocompleteState((prev) => ({
+			...prev,
+			isLoading: true
+		}));
+		const fetchData = async () => {
+			try {
+				const results = await fetchAutocompleteSuggestions?.(debouncedSearchText);
+				setAutocompleteState({
+					results: results ?? [],
+					isLoading: false
+				});
+			} catch (error) {
+				logger_default.logError("Failed to fetch autocomplete suggestions:", error);
+				setAutocompleteState({
+					results: [],
+					isLoading: false
+				});
+			}
+		};
+		fetchData();
+	}, [
+		debouncedSearchText,
+		isDirty,
+		setAutocompleteState
+	]);
+	return {
+		searchData,
+		searchResponseId: searchData?.searchResponseId ?? "",
+		merchantShortName: safeMerchantShortName,
+		productCardConfig: safeProductCardConfig,
+		productList,
+		autocompleteResults,
+		searchFilters: filters,
+		availableDynamicFilters,
+		selectedFilterOptions,
+		searchText,
+		searchResultsState,
+		isLoadingAutocomplete,
+		isLoadingSearch,
+		isFilterOpen,
+		isDirty,
+		focusedIndex,
+		focusedOptionId,
+		filterButtonText,
+		onSearchInputChange: handleSearchInputChange,
+		onSubmitSearch: handleSubmitSearch,
+		onAutocompleteSelect: handleAutocompleteSelect,
+		onKeyDown: handleKeyDown,
+		onToggleDynamicFilter: handleToggleDynamicFilter,
+		onSelectFilterItem: handleSelectFilterItem,
+		onRemoveFilter: handleRemoveFilter,
+		onClearAllFilters: handleClearAllFilters,
+		setIsFilterOpen,
+		searchResultsRef
+	};
+};
+
+//#endregion
+//#region src/hooks/useAppDetails.ts
+const useAppDetails = () => {
+	const { orgId: fetchedOrgId } = useOrgId();
+	const orgId = fetchedOrgId ?? "";
+	const orgShortName = useAtomValue(orgShortNameAtom) ?? "spiffy-ai";
+	const chatId = useAtomValue(chatIdAtom);
+	const userId = useAtomValue(userIdAtom);
+	const source = useAtomValue(contextSourceAtom) ?? ContextSourceEnum.App;
+	const env = useAtomValue(envAtom) ?? ContextEnvEnum.Dev;
+	const variantInfo = useAtomValue(variantInfoAtom);
+	return {
+		orgId,
+		orgShortName,
+		chatId,
+		userId,
+		source,
+		env,
+		variantInfo
+	};
+};
+
+//#endregion
+//#region src/contexts/searchContext.tsx
+const transformProductResponses = (products) => products.map((data) => ({
+	id: data.id,
+	responseId: data.response_id,
+	category: ResponseCategory.Product,
+	description: data.description,
+	imageUrl: data.image_url,
+	imageUrls: data.image_urls,
+	title: data.title,
+	url: data.url,
+	originalPrice: data.original_price,
+	salePrice: data.sale_price,
+	averageRating: data.average_rating,
+	numberReviews: data.number_reviews,
+	metadata: data.metadata,
+	isForGrid: data.is_for_grid,
+	colors: data.colors,
+	sizes: data.sizes,
+	filters: data.filters
+}));
+async function errorResponseBody(error) {
+	try {
+		return await error.response.json();
+	} catch {
+		return {};
+	}
+}
+async function throwSessionRestartRequiredIf(errorMsg, error) {
+	if (!(error instanceof ResponseError)) {
+		logger_default.logInfo(errorMsg, error);
+		throw error;
+	}
+	const errorResponse = await errorResponseBody(error);
+	if (errorResponse?.message?.toLowerCase() === "unsupported product" || errorResponse?.app_code?.toUpperCase() === "PRODUCT_NOT_FOUND") throw new UnsupportedProductException();
+	else if (errorResponse?.app_code?.toUpperCase() === "RESTART_SESSION" || errorResponse?.sub_code?.toUpperCase() === "NOT_FOUND") {
+		logger_default.logInfo("Session does not exist. Re-start session", error, error.response, errorResponse);
+		throw new SessionRestartRequired();
+	}
+	logger_default.logInfo(errorMsg, error);
+	throw error;
+}
+const SearchContext = createContext(void 0);
+const SearchProvider = ({ children }) => {
+	const { orgLevelApiKey, publicKey } = useEnviveConfig();
+	const apiKey = orgLevelApiKey || publicKey;
+	const appDetails = useAppDetails();
+	const baseUrl = useAtomValue(baseUrlAtom);
+	const isReady = Boolean(apiKey && appDetails && baseUrl);
+	const searchApi = useMemo(() => {
+		if (!isReady) return null;
+		const config = new Configuration({
+			accessToken: apiKey,
+			basePath: baseUrl,
+			headers: {
+				"Content-Type": "application/json",
+				Accept: "application/json"
+			}
+		});
+		return new SearchApi(config);
+	}, [
+		apiKey,
+		baseUrl,
+		isReady
+	]);
+	const searchProducts = useCallback(async (params) => {
+		if (!isReady || !searchApi) throw new Error("SearchService not ready - missing dependencies");
+		try {
+			const { products, filters, search_response_id: searchResponseId } = await searchApi.v1SearchQueryGet({
+				query: params.query,
+				limit: params.limit,
+				org_id: appDetails.orgId,
+				user_id: appDetails.userId
+			});
+			return {
+				products: transformProductResponses(products) || [],
+				filters: filters || [],
+				totalProductCount: products?.length || 0,
+				searchResponseId: searchResponseId || ""
+			};
+		} catch (error) {
+			await throwSessionRestartRequiredIf("Failed to search products", error);
+			return {
+				products: [],
+				filters: [],
+				totalProductCount: 0,
+				searchResponseId: ""
+			};
+		}
+	}, [
+		searchApi,
+		isReady,
+		appDetails
+	]);
+	useEffect(() => {
+		if (isReady) setSearchServiceFunction(searchProducts);
+		else clearSearchServiceFunction();
+		return () => {
+			clearSearchServiceFunction();
+		};
+	}, [searchProducts, isReady]);
+	const value = useMemo(() => ({
+		searchProducts,
+		isReady
+	}), [searchProducts, isReady]);
+	return /* @__PURE__ */ jsx(SearchContext.Provider, {
+		value,
+		children
+	});
+};
+const useSearchService = () => {
+	const context = useContext(SearchContext);
+	if (!context) throw new Error("useSearchService must be used within a SearchProvider");
+	return context;
+};
+
+//#endregion
+//#region src/hooks/useSearchOperations.ts
+const useProductSearch = () => {
+	const { searchProducts, isReady } = useSearchService();
+	const [data, setData] = useState();
+	const [loading, setLoading] = useState(false);
+	const [error, setError] = useState(null);
+	const search = useCallback(async (params) => {
+		if (!isReady) {
+			setError(/* @__PURE__ */ new Error("Search service not ready - missing dependencies"));
+			return;
+		}
+		setLoading(true);
+		setError(null);
+		try {
+			const result = await searchProducts(params);
+			setData(result);
+		} catch (err) {
+			setError(err instanceof Error ? err : /* @__PURE__ */ new Error("Unknown search error"));
+		} finally {
+			setLoading(false);
+		}
+	}, [searchProducts, isReady]);
+	const reset = useCallback(() => {
+		setData(void 0);
+		setError(null);
+		setLoading(false);
+	}, []);
+	return {
+		data,
+		loading,
+		error,
+		search,
+		reset,
+		isReady
+	};
+};
+const useSearchWithQuery = (params) => {
+	const { searchProducts, isReady } = useSearchService();
+	const [data, setData] = useState();
+	const [loading, setLoading] = useState(false);
+	const [error, setError] = useState(null);
+	const executeSearch = useCallback(async (searchParams) => {
+		if (!isReady) return;
+		setLoading(true);
+		setError(null);
+		try {
+			const result = await searchProducts(searchParams);
+			setData(result);
+		} catch (err) {
+			setError(err instanceof Error ? err : /* @__PURE__ */ new Error("Unknown search error"));
+		} finally {
+			setLoading(false);
+		}
+	}, [searchProducts, isReady]);
+	useEffect(() => {
+		if (params && isReady) executeSearch(params);
+	}, [
+		params,
+		isReady,
+		executeSearch
+	]);
+	const refetch = useCallback(() => {
+		if (params) executeSearch(params);
+	}, [params, executeSearch]);
+	return {
+		data,
+		loading,
+		error,
+		refetch,
+		isReady
+	};
+};
+
+//#endregion
+//#region src/contexts/sessionStorageContext.tsx
+const SessionStorageContext = createContext(null);
+const SessionStorageProvider = ({ children }) => {
+	const isAvailable = useMemo(() => {
+		try {
+			return typeof window !== "undefined" && !!window.sessionStorage;
+		} catch {
+			return false;
+		}
+	}, []);
+	useEffect(() => {
+		if (!isAvailable) logger_default.logError("sessionStorage is not available", void 0);
+	}, [isAvailable]);
+	const setItem = useCallback((key, value$1) => {
+		if (!isAvailable) return;
+		sessionStorage.setItem(key, value$1);
+		window.dispatchEvent(new StorageEvent("storage", {
+			key,
+			newValue: value$1
+		}));
+	}, [isAvailable]);
+	const getItem = useCallback((key) => {
+		if (!isAvailable) return null;
+		return sessionStorage.getItem(key);
+	}, [isAvailable]);
+	const value = useMemo(() => ({
+		setItem,
+		getItem,
+		isAvailable
+	}), [
+		setItem,
+		getItem,
+		isAvailable
+	]);
+	return /* @__PURE__ */ jsx(SessionStorageContext.Provider, {
+		value,
+		children
+	});
+};
+const useSessionStorage = () => {
+	const context = useContext(SessionStorageContext);
+	if (!context) throw new Error("useSessionStorage must be used within a SessionStorageProvider");
+	return context;
+};
+
+//#endregion
+//#region src/hooks/useSessionStorageOperations.ts
+const useSessionStorageValue = (key) => {
+	const { getItem, setItem } = useSessionStorage();
+	const [value, setValue] = useState(() => getItem(key));
+	useEffect(() => {
+		const handleStorageChange = (event) => {
+			if (event.key === key) setValue(event.newValue);
+		};
+		window.addEventListener("storage", handleStorageChange);
+		return () => window.removeEventListener("storage", handleStorageChange);
+	}, [key, getItem]);
+	const updateValue = useCallback((newValue) => {
+		setItem(key, newValue);
+		setValue(newValue);
+	}, [key, setItem]);
+	return {
+		value,
+		setValue: updateValue
+	};
+};
+
+//#endregion
+//#region src/contexts/shopifyUrlContext.tsx
+const ShopifyUrlContext = createContext(void 0);
+const ShopifyUrlProvider = ({ children }) => {
+	const isReady = true;
+	const getTrimmedPathName = useCallback(() => {
+		let { pathname } = window.location;
+		pathname = pathname.replace("/proxy", "");
+		pathname = pathname.replace(/#.*$/, "");
+		pathname = pathname.replace(/\/$/, "");
+		if (pathname === void 0 || pathname === null || pathname.length === 0) return null;
+		return pathname;
+	}, []);
+	const getPlpOrPdpId = useCallback((extractor) => {
+		if (extractor === "shopify-product-variant-id") {
+			const variantId = parseHref(window.location.href)?.urlSearchParams?.get("variant");
+			if (!variantId) return getPlpOrPdpId("shopify-product-id");
+			return variantId;
+		}
+		const pathSegment = extractor === "shopify-product-id" ? "products" : "collections";
+		const tokens = getTrimmedPathName()?.split("/");
+		const idIndex = tokens?.findIndex((token) => token === pathSegment);
+		if (idIndex !== void 0 && idIndex >= 0 && tokens) return decodeURIComponent(tokens[idIndex + 1]);
+		return null;
+	}, [getTrimmedPathName]);
+	const isOnPdpPage = useCallback(() => {
+		return getTrimmedPathName()?.includes("/products") ?? false;
+	}, [getTrimmedPathName]);
+	const isOnPlpPage = useCallback(() => {
+		return (getTrimmedPathName()?.includes("/collections") && !getTrimmedPathName()?.includes("/products")) ?? false;
+	}, [getTrimmedPathName]);
+	const value = useMemo(() => ({
+		getTrimmedPathName,
+		getPlpOrPdpId,
+		isOnPdpPage,
+		isOnPlpPage,
+		isReady
+	}), [
+		getTrimmedPathName,
+		getPlpOrPdpId,
+		isOnPdpPage,
+		isOnPlpPage,
+		isReady
+	]);
+	return /* @__PURE__ */ jsx(ShopifyUrlContext.Provider, {
+		value,
+		children
+	});
+};
+const useShopifyUrl = () => {
+	const context = useContext(ShopifyUrlContext);
+	if (!context) throw new Error("useShopifyUrl must be used within a ShopifyUrlProvider");
+	return context;
+};
+
+//#endregion
+//#region src/hooks/useShopifyUrlOperations.ts
+const useShopifyUrlOperations = () => {
+	const { getTrimmedPathName, getPlpOrPdpId, isOnPdpPage, isOnPlpPage, isReady } = useShopifyUrl();
+	return {
+		getTrimmedPathName,
+		getPlpOrPdpId,
+		isOnPdpPage,
+		isOnPlpPage,
+		isReady
+	};
+};
+const useCurrentPageType = () => {
+	const { isOnPdpPage, isOnPlpPage, isReady } = useShopifyUrl();
+	return {
+		getPageType: useCallback(() => {
+			if (!isReady) return "unknown";
+			if (isOnPdpPage()) return "pdp";
+			if (isOnPlpPage()) return "plp";
+			return "other";
+		}, [
+			isReady,
+			isOnPdpPage,
+			isOnPlpPage
+		]),
+		isReady
+	};
+};
+const useProductId = (extractor) => {
+	const { getPlpOrPdpId, isReady } = useShopifyUrl();
+	return {
+		productId: useCallback(() => {
+			if (!isReady) return null;
+			return getPlpOrPdpId(extractor);
+		}, [
+			isReady,
+			getPlpOrPdpId,
+			extractor
+		]),
+		isReady
+	};
+};
+
+//#endregion
+//#region src/hooks/useSnapCalculator.ts
+const useSnapCalculator = (snaps, maxHeight, unit) => {
+	const viewportHeightPx = document.documentElement.clientHeight;
+	const swipeviewHeightPx = unit === "percent" ? Math.floor(viewportHeightPx * (maxHeight / 100)) : maxHeight;
+	const snapsToPixels = useMemo(() => snaps?.map((snap) => Math.abs((unit === "percent" ? Math.floor(swipeviewHeightPx * (snap / 100)) : snap) - swipeviewHeightPx)), [viewportHeightPx]);
+	const getPixelToSnap = (pixels) => {
+		const snapIdx = snapsToPixels?.indexOf(pixels) || 0;
+		return snaps?.[snapIdx] || 0;
+	};
+	const getSnapToPixel = (snap) => {
+		const snapIdx = snaps?.indexOf(snap) || 0;
+		return snapsToPixels?.[snapIdx] || 0;
+	};
+	return {
+		viewportHeightPx,
+		snapsToPixels,
+		swipeviewHeightPx,
+		getPixelToSnap,
+		getSnapToPixel
+	};
+};
+
+//#endregion
+//#region src/hooks/useSystemSettingsContext.ts
+const useSystemSettingsContext = () => {
+	const context = useContext(SystemSettingsContext);
+	if (!context) throw new Error("useSystemSettingsContext must be used within a SystemSettingsContextProvider");
+	return { ...context };
+};
+
+//#endregion
+//#region src/hooks/useTrackComponentVisibleEvent.ts
+/**
+* Tracks a component and logs an event to Amplitude when the component is visible.
+*
+* @param component - The component to track.
+* @param element - The element to track visibility of.
+* @param eventProps - Additional properties to include with the event.
+* @param eventName - The Amplitude event name to track (defaults to ChatComponentVisible).
+*/
+const useTrackComponentVisibleEvent = (component, element, eventProps, eventName = SpiffyMetricsEventName.ChatComponentVisible) => {
+	const isVisible = useIntersection(element, "0px");
+	const hasTrackedEvent = useRef(false);
+	const { trackEvent } = useAmplitude();
+	const componentProps = (() => {
+		if (eventName === SpiffyMetricsEventName.ChatComponentVisible) return {
+			chat_component: component,
+			...eventProps
+		};
+		if (eventName === SpiffyMetricsEventName.SearchComponentVisible) return {
+			search_component: component,
+			...eventProps
+		};
+		return {
+			component,
+			...eventProps
+		};
+	})();
+	useEffect(() => {
+		if (isVisible && !hasTrackedEvent.current) {
+			trackEvent({
+				eventName,
+				eventProps: componentProps
+			});
+			hasTrackedEvent.current = true;
+		}
+	}, [
+		isVisible,
+		component,
+		eventProps,
+		eventName,
+		componentProps,
+		trackEvent
+	]);
+};
+
+//#endregion
+//#region src/hooks/useUpdateAnalyticsProps.ts
+/**
+* Updates the default analytics properties whenever the variant info changes. This hook also
+* triggers any events that should be sent once per page visit.
+*/
+const useUpdateAnalyticsProps = () => {
+	const variantInfo = useAtomValue(variantInfoAtom);
+	const hasInitialized = useRef(false);
+	const hasParsedVariantInfo = useAtomValue(hasParsedVariantInfoAtom);
+	const { trackEvent, setSupplementalDefaultProps } = useAmplitude();
+	useEffect(() => {
+		const variantInfoWithPrefix = Object.fromEntries(Object.entries(variantInfo).map(([key, value]) => [`variantInfo.${key}`, value]));
+		const defaultEventProperties = {
+			page_variant: variantInfo.variant,
+			...variantInfoWithPrefix
+		};
+		if (variantInfo.variant === "pdp") defaultEventProperties.product_id = variantInfo.productId;
+		if (variantInfo.variant === "plp") defaultEventProperties.plp_id = variantInfo.plpId;
+		if (variantInfo.variant === "page_visit") {
+			defaultEventProperties.page_visit_category = variantInfo.pageVisitCategory;
+			defaultEventProperties.page_visit_url = variantInfo.url;
+		}
+		setSupplementalDefaultProps(defaultEventProperties);
+		if (!hasInitialized.current && hasParsedVariantInfo) {
+			trackEvent({ eventName: SpiffyMetricsEventName.BundleLoaded });
+			hasInitialized.current = true;
+		}
+	}, [
+		variantInfo,
+		hasParsedVariantInfo,
+		trackEvent,
+		setSupplementalDefaultProps
+	]);
+};
+
+//#endregion
+//#region src/contexts/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
+//#region src/contexts/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
+//#region src/contexts/systemSettingsContext.tsx
+const getChatModelName = () => {
+	const urlObj = new URL(window.location.href);
+	const params = new URLSearchParams(urlObj.search);
+	return Object.fromEntries(params.entries()).llm_model_name;
+};
+const defaultGenerationParams = {
+	stream: true,
+	numSuggestions: 3,
+	model: getChatModelName()
+};
+const SystemSettingsContext = createContext(void 0);
+const SystemSettingsContextProvider = ({ children, generationParams, showDebugBar }) => {
+	const [params, setParams] = useState(() => generationParams ?? defaultGenerationParams);
+	const endpointURL = useAtomValue(baseUrlAtom);
+	const settingsContextValues = useMemo(() => ({
+		generationParams: params,
+		showDebugBar,
+		setGenerationParams: setParams,
+		endpointURL
+	}), [
+		generationParams,
+		endpointURL,
+		showDebugBar
+	]);
+	return /* @__PURE__ */ jsx(SystemSettingsContext.Provider, {
+		value: settingsContextValues,
+		children
+	});
+};
+
+//#endregion
+export { CdnProvider, ChatContext, ChatContextProvider, EnviveCssProvider, FeatureFlagServiceProvider, GraphQLProvider, NewOrgConfigProvider, SearchProvider, SearchResultsState, SessionStorageProvider, ShopifyUrlProvider, SystemSettingsContext, SystemSettingsContextProvider, UserIdentityProvider, createAppLoadedEvent, createVisitUserEvent, defaultGenerationParams, getSearchResultsState, isElementPartiallyVisible, isWithinBusinessHours, useAmplitudeTracking, useAssetUrl, useBlockBackButton, useCdn, useCdnBasePath, useCdnUrl, useChatToggle, useChatToggleAnalytics, useColorsAndFrontendConfig, useCurrentPageType, useCustomerSupportHandoff, useDebounce, useElementObserver, useEnviveFeatureFlag, useFeatureFlagService, useGrabAndScroll, useGraphQLClient, useIdentifyUser, useImageResolver, useIntersection, useIsSmallScreen, useLocalStorageListener, useLocalStorageValue, useMessageFilter, useMessageScrollObserver, useNewOrgConfig, useNewOrgConfigContext, useOrgId, useProductId, useProductSearch, useSearch, useSearchService, useSearchWithQuery, useSessionStorage, useSessionStorageValue, useShopifyUrl, useShopifyUrlOperations, useSnapCalculator, useSpiffyFeatureFlag, useSystemSettingsContext, useTrackComponentVisibleEvent, useUpdateAnalyticsProps, useUserIdentity };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"contexts-DGlr7M1o.js","names":["CdnProvider: React.FC<{ children: React.ReactNode }>","errorResponseBody","throwSessionRestartRequiredIf","config: Configuration","context: Context","err: unknown","error: unknown","data: V1GetSessionMessages200Response","responses: Response[][]","suggestions: Suggestion[]","userEvents: UserEvent[]","assistantMessages: Message[][]","userMessages: Message[][]","request: V1OrgConfigGetRequest","UserIdentityProvider: React.FC<{ children: React.ReactNode }>","uuid","CommerceApiClient","listener: LocalStorageEventListener","FeatureFlagServiceProvider: React.FC<\n  FeatureFlagServiceProviderProps\n>","NewOrgConfigProvider: React.FC<NewOrgConfigProviderProps>","uuid","handleSelectFilterItem: SelectFilterItem","enviveOrgShortNameAtom","enviveEnvAtom","SearchProvider: React.FC<{ children: React.ReactNode }>","config: Configuration","SessionStorageProvider: React.FC<{\n  children: React.ReactNode;\n}>","value","ShopifyUrlProvider: React.FC<{ children: React.ReactNode }>","defaultEventProperties: Record<string, unknown>","userQueryProperty: string | undefined","eventProps: Record<string, unknown>","uuid","lastMessage: Message | undefined","error: unknown","CommerceApiClient","userEvents","EnviveCssProvider: React.FC<EnviveCssProviderProps>","defaultGenerationParams: GenerationParams"],"sources":["../src/contexts/cdnContext.tsx","../src/types/exceptions/sessionExceptions.ts","../src/types/exceptions/unsupportedProductExceptions.ts","../src/application/commerce-api.ts","../src/hooks/useAmplitudeOperations.ts","../src/hooks/useBlockBackButton.ts","../src/hooks/useCdnOperations.ts","../src/hooks/useChatToggle.ts","../src/hooks/useChatToggleAnalytics.ts","../src/hooks/useCustomerSupportHandoff.ts","../src/hooks/useDebounce.ts","../src/hooks/useElementObserver.ts","../src/hooks/useGrabAndScroll.ts","../src/contexts/graphqlContext.tsx","../src/hooks/useGraphQLConfig.ts","../src/contexts/userIdentityContext.tsx","../src/hooks/useIdentifyUser.ts","../src/hooks/useImageResolver.ts","../src/hooks/useIntersection.ts","../src/hooks/useIsSmallScreen.ts","../src/hooks/useLocalStorageOperations.ts","../src/hooks/useMessageFilter.ts","../src/hooks/useMessageScrollObserver.ts","../src/contexts/featureFlagServiceContext.tsx","../src/contexts/newOrgConfigContext.tsx","../src/hooks/useNewOrgConfig.ts","../src/hooks/utils.ts","../src/hooks/useSearch.tsx","../src/hooks/useAppDetails.ts","../src/contexts/searchContext.tsx","../src/hooks/useSearchOperations.ts","../src/contexts/sessionStorageContext.tsx","../src/hooks/useSessionStorageOperations.ts","../src/contexts/shopifyUrlContext.tsx","../src/hooks/useShopifyUrlOperations.ts","../src/hooks/useSnapCalculator.ts","../src/hooks/useSystemSettingsContext.ts","../src/hooks/useTrackComponentVisibleEvent.ts","../src/hooks/useUpdateAnalyticsProps.ts","../src/contexts/chatContext.tsx","../src/contexts/enviveCssContext.tsx","../src/contexts/systemSettingsContext.tsx"],"sourcesContent":["import React, { createContext, useContext, useCallback, useMemo } from \"react\";\nimport { useAtomValue } from \"jotai\";\nimport { cdnUrlAtom } from \"../atoms/envive/enviveConfig\";\n\ninterface CdnContextType {\n  cdnUrl: string;\n  getCdnBasePath: () => string;\n  getAssetURL: (assetName: string, orgShortName: string) => string;\n}\n\nconst CdnContext = createContext<CdnContextType | null>(null);\n\nexport const CdnProvider: React.FC<{ children: React.ReactNode }> = ({\n  children,\n}) => {\n  const cdnUrlAtomValue = useAtomValue(cdnUrlAtom);\n  const cdnUrl = cdnUrlAtomValue || \"https://cdn.spiffy.ai/other\";\n\n  const getCdnBasePath = useCallback(() => {\n    return cdnUrl;\n  }, [cdnUrl]);\n\n  const getAssetURL = useCallback(\n    (assetName: string, orgShortName: string) => {\n      return `${getCdnBasePath()}/assets/${orgShortName}/${assetName}`;\n    },\n    [getCdnBasePath]\n  );\n\n  const value = useMemo(\n    () => ({\n      cdnUrl,\n      getCdnBasePath,\n      getAssetURL,\n    }),\n    [cdnUrl, getCdnBasePath, getAssetURL]\n  );\n\n  return <CdnContext.Provider value={value}>{children}</CdnContext.Provider>;\n};\n\nexport const useCdn = () => {\n  const context = useContext(CdnContext);\n  if (!context) {\n    throw new Error(\"useCdn must be used within a CdnProvider\");\n  }\n  return context;\n};\n","export class SessionRestartRequired extends Error {\n  constructor() {\n    super('Session restart required');\n    this.name = 'SessionRestartRequired';\n  }\n}\n","export class UnsupportedProductException extends Error {\n  constructor() {\n    super('Unsupported product');\n    this.name = 'UnsupportedProduct';\n  }\n}","import Logger from \"src/application/logging/logger\";\nimport {\n  Configuration,\n  CustomerServiceApi,\n  DefaultApi,\n  InferenceApi,\n  ReportSessionRequest,\n  ResponseError,\n  UserEventCategory,\n  V1GetSessionMessages200Response,\n  V1OrgConfigGetRequest,\n  ContextSourceEnum,\n  V1OrgConfigGetSourceEnum,\n  CustomerServiceProvider,\n  ResponseCategory,\n  FormType,\n} from \"@spiffy-ai/commerce-api-client\";\nimport { validateSuggestion } from \"src/application/models/validators/validateSuggestion\";\nimport { validateUserEvent } from \"src/application/models/validators/validateUserEvent\";\nimport {\n  messageFromQueryEvent,\n  messageFromResponse,\n  messageFromSuggestionEvent,\n} from \"src/application/utils\";\nimport {\n  Message,\n  NextMessageRequest,\n  Response,\n  Suggestion,\n  SupportedEventRequest,\n  UserEvent,\n} from \"src/application/models\";\nimport { messageRequestToCommerceMessageRequest } from \"src/application/utils/nextMessageRequestToApiRequest\";\nimport { validateResponse } from \"src/application/models/validators/validateResponse\";\nimport { coreSupportedEventRequestToApiRequest } from \"src/application/utils/supportedEventRequestToApiRequest\";\nimport { SessionRestartRequired } from \"src/types/exceptions/sessionExceptions\";\nimport { UnsupportedProductException } from \"src/types/exceptions/unsupportedProductExceptions\";\nimport { ClientDetails } from \"src/application/models/clientDetails\";\nimport { getAtomStore } from \"src/atoms/atomStore/atomStore\";\nimport { ProductExperiment } from \"src/application/models/productExperiment\";\nimport { FeatureGates } from \"src/application/models/featureGates\";\nimport { validateOrgConfigResults } from \"src/application/models/validators/validateOrgConfigResults\";\nimport { OrgConfig } from \"src/application/models/api/orgConfigResults\";\nimport { SupportedEvent } from \"src/atoms/app/variant\";\nimport { messageFromFormSubmittedEvent } from \"src/application/utils/messageFromFormSubmittedEvent\";\nimport type { Context } from \"@spiffy-ai/commerce-api-client/dist/models/Context\";\nimport { ContextEnvEnum } from \"@spiffy-ai/commerce-api-client\"; // Import ContextEnvEnum\nimport {\n  baseUrlAtom,\n  reactAppNameAtom,\n  contextSourceAtom,\n  orgShortNameAtom,\n  envAtom, // Import envAtom\n} from \"src/atoms/envive/enviveConfig\";\nimport { userIdAtom, chatIdAtom } from \"src/atoms/app\"; // Import userIdAtom and chatIdAtom\nimport { orgIdAtom, featureFlagServiceAtom } from \"src/atoms/org/graphqlConfig\"; // Import new orgIdAtom and featureFlagServiceAtom\n\nasync function errorResponseBody(error: ResponseError) {\n  try {\n    return await error.response.json();\n  } catch {\n    return {};\n  }\n}\n\nasync function throwSessionRestartRequiredIf(errorMsg: string, error: unknown) {\n  if (!(error instanceof ResponseError)) {\n    Logger.logInfo(errorMsg, error);\n    throw error;\n  }\n\n  const errorResponse = await errorResponseBody(error);\n  if (\n    errorResponse?.message?.toLowerCase() === \"unsupported product\" || // for backward compatibility. newer versions of the API return sub_code instead of message\n    errorResponse?.app_code?.toUpperCase() === \"PRODUCT_NOT_FOUND\"\n  ) {\n    throw new UnsupportedProductException();\n  } else if (\n    errorResponse?.app_code?.toUpperCase() === \"RESTART_SESSION\" ||\n    errorResponse?.sub_code?.toUpperCase() === \"NOT_FOUND\" // for backward compatibility. new API responses will contain \"app_code\"\n  ) {\n    Logger.logInfo(\n      \"Session does not exist. Re-start session\",\n      error,\n      error.response,\n      errorResponse\n    );\n    throw new SessionRestartRequired();\n  }\n\n  Logger.logInfo(errorMsg, error);\n  throw error;\n}\n\nclass CommerceApiClient {\n  private readonly defaultApi: DefaultApi;\n\n  private readonly customerServiceApi: CustomerServiceApi;\n\n  private readonly inferenceApi: InferenceApi;\n\n  private static instance: CommerceApiClient | undefined;\n\n  private suggestionsAbortController = new AbortController();\n\n  private responsesAbortController = new AbortController();\n\n  private static getInstance = (): CommerceApiClient => {\n    if (!CommerceApiClient.instance) {\n      CommerceApiClient.instance = new CommerceApiClient();\n    }\n\n    return CommerceApiClient.instance;\n  };\n\n  private constructor(basePath?: string) {\n    const atomStore = getAtomStore();\n    const baseUrl = atomStore.get(baseUrlAtom);\n    const path = basePath || baseUrl;\n    // API Key is now handled at the EnviveConfigProvider level\n    const config: Configuration = new Configuration({\n      basePath: path,\n      headers: {\n        \"Content-Type\": \"application/json\",\n        Accept: \"application/json\",\n      },\n    });\n    this.defaultApi = new DefaultApi(config);\n    this.inferenceApi = new InferenceApi(config);\n    this.customerServiceApi = new CustomerServiceApi(config);\n  }\n\n  static resolveUrl = async (url: string) => {\n    const atomStore = getAtomStore();\n    const orgShortName = atomStore.get(orgShortNameAtom);\n    const orgId = atomStore.get(orgIdAtom);\n    const userId = atomStore.get(userIdAtom);\n    const chatId = atomStore.get(chatIdAtom);\n    const source = atomStore.get(contextSourceAtom);\n    const env = atomStore.get(envAtom);\n\n    const featureFlagService = atomStore.get(featureFlagServiceAtom);\n\n    const context: Context = {\n      user_id: userId ?? \"\",\n      org_id: orgId ?? \"\",\n      org_short_name: orgShortName ?? \"\",\n      chat_id: chatId ?? \"\",\n      source: source ?? ContextSourceEnum.App,\n      env: (env as ContextEnvEnum) ?? ContextEnvEnum.Dev, // Cast env to ContextEnvEnum\n    };\n\n    const featureGates =\n      featureFlagService?.featureFlagService?.getFeatureFlags() || {};\n    const urlResolvingRequest = {\n      url,\n      context,\n      feature_gates: featureGates,\n    };\n\n    const rawResponse =\n      await CommerceApiClient.getInstance().inferenceApi.v1UrlResolvingPostRaw({\n        UrlResolvingRequest: urlResolvingRequest,\n      });\n\n    const responseBody = await rawResponse.raw.json();\n\n    return responseBody;\n  };\n\n  static reportSession = async (\n    reportRequest: ReportSessionRequest\n  ): Promise<void> => {\n    await CommerceApiClient.getInstance().defaultApi.v1ChatsReportSessionIdPost(\n      {\n        ReportSessionRequest: reportRequest,\n      }\n    );\n  };\n\n  static getNextResponses = async (\n    payload: NextMessageRequest\n  ): Promise<Message[]> => {\n    try {\n      const response =\n        await CommerceApiClient.getInstance().inferenceApi.v1NextResponsesPost({\n          NextMessageRequest: messageRequestToCommerceMessageRequest(payload),\n        });\n      const messages = response\n        .map((resp) => validateResponse(resp))\n        .map((resp) => messageFromResponse(resp));\n\n      return messages.filter((m): m is Message => m != null);\n    } catch (err: unknown) {\n      Logger.logInfo(\"Failed to get next responses\", err, {\n        payloadContext: payload?.context,\n        userEvents: payload?.userEvents,\n      });\n      await throwSessionRestartRequiredIf(\"Failed to get next responses\", err);\n      return [];\n    }\n  };\n\n  static getNextResponseStreaming = (\n    payload: NextMessageRequest\n  ): AsyncGenerator<Response, void, unknown> => {\n    async function* generate(\n      inferenceApi: InferenceApi,\n      abortController: AbortController\n    ) {\n      // make sure streaming is enabled\n      try {\n        const response = await inferenceApi.v1NextResponsesPostRaw(\n          {\n            NextMessageRequest: messageRequestToCommerceMessageRequest(payload),\n          },\n          { signal: abortController.signal }\n        );\n\n        // Read the response as a stream of data\n        if (!response.raw.body) {\n          Logger.logError(\n            \"[spiffy-ai] No body in the streamed response\",\n            undefined,\n            {\n              response: response.raw,\n            }\n          );\n          return;\n        }\n\n        const reader = response.raw.body.getReader();\n        const decoder = new TextDecoder(\"utf-8\");\n\n        let partial = \"\";\n        // TODO this function is recreated every time new data comes from the stream - define it outside of the generator\n        const safeParse = (line: string): unknown => {\n          try {\n            return JSON.parse(line); // Parse the JSON string\n          } catch (err) {\n            Logger.logError(\"[spiffy-ai] Error parsing streamed line\", err, {\n              line,\n              partial,\n            });\n            // swallow the error and set the partial to our current chunk\n            partial = line;\n            return partial;\n          }\n        };\n\n        // TODO this function is recreated every time new data comes from the stream - define it outside of the generator\n        const processChunk = (chunk: string): unknown[] => {\n          // merge the partial with the incoming chunk\n          const lines = `${partial}${chunk}`.split(\"\\n\");\n\n          const parsedLines = lines\n            .map((line) => line.replace(/^data: /, \"\").trim()) // Remove the \"data: \" prefix\n            .filter((line) => line !== \"\" && line !== \"[DONE]\") // Remove empty lines and \"[DONE]\"\n            .map(safeParse)\n            .filter((v) => v); // and filter out the undefined values\n          return parsedLines;\n        };\n\n        while (true) {\n          // eslint-disable-next-line no-await-in-loop\n          const { done, value } = await reader.read();\n\n          if (done) {\n            break;\n          }\n\n          // Massage and parse the chunk of data\n          const chunk = decoder.decode(value);\n          const parsedLines = processChunk(chunk);\n\n          for (const parsedLine of parsedLines) {\n            const validatedResponse = validateResponse(parsedLine);\n\n            if (validatedResponse) {\n              yield validatedResponse;\n            }\n          }\n        }\n      } catch (error: unknown) {\n        Logger.logError(\n          \"[spiffy-ai] Failed to get next streaming responses\",\n          error,\n          {\n            payloadContext: payload?.context,\n            userEvents: payload?.userEvents,\n          }\n        );\n        await throwSessionRestartRequiredIf(\n          \"Failed to get next streaming responses\",\n          error\n        );\n      }\n    }\n\n    CommerceApiClient.getInstance().responsesAbortController.abort();\n    CommerceApiClient.getInstance().responsesAbortController =\n      new AbortController();\n\n    return generate(\n      CommerceApiClient.getInstance().inferenceApi,\n      CommerceApiClient.getInstance().responsesAbortController\n    );\n  };\n\n  static getNextSuggestions = async (\n    payload: NextMessageRequest\n  ): Promise<Suggestion[]> => {\n    try {\n      CommerceApiClient.getInstance().suggestionsAbortController.abort();\n      CommerceApiClient.getInstance().suggestionsAbortController =\n        new AbortController();\n\n      const response =\n        await CommerceApiClient.getInstance().inferenceApi.v1NextSuggestionsPost(\n          {\n            NextMessageRequest: messageRequestToCommerceMessageRequest(payload),\n          },\n          {\n            signal:\n              CommerceApiClient.getInstance().suggestionsAbortController.signal,\n          }\n        );\n\n      const suggestions = response\n        .map((resp) => validateSuggestion(resp))\n        .filter((suggestion): suggestion is Suggestion => suggestion != null);\n\n      return suggestions;\n    } catch (error: unknown) {\n      Logger.logInfo(\"Failed to get suggestions\", error, {\n        payloadContext: payload?.context,\n        userEvents: payload?.userEvents,\n      });\n\n      await throwSessionRestartRequiredIf(\"Failed to get suggestions\", error);\n      return [];\n    }\n  };\n\n  /**\n   * Fetches the existing chat data for a given session and transforms them to reconstruct the chat history.\n   *\n   * @param orgId The organization Id\n   * @param chatId The existing chat Id\n   * @param userId The user Id\n   *\n   * @returns A list of messages that were exchanged in the chat, throws an error if the chat session has expired.\n   */\n  static getResponses = async (\n    orgId: string,\n    chatId: string,\n    userId: string\n  ): Promise<{\n    responses: Response[][];\n    userEvents: UserEvent[];\n    suggestions: Suggestion[];\n    messages: Message[][];\n  }> => {\n    let data: V1GetSessionMessages200Response = {\n      responses: [],\n      suggestions: [],\n      user_events: [],\n    };\n    const request = {\n      org_id: orgId,\n      chat_id: chatId,\n      user_id: userId,\n    };\n    try {\n      data =\n        await CommerceApiClient.getInstance().defaultApi.v1GetSessionMessages(\n          request\n        );\n    } catch (error: unknown) {\n      await throwSessionRestartRequiredIf(\n        \"Failed to get chat responses\",\n        error\n      );\n    }\n\n    const responses: Response[][] = data?.responses?.map((turn) =>\n      turn\n        .map((response) => validateResponse(response))\n        .filter((response): response is Response => response != null)\n    );\n\n    const suggestions: Suggestion[] = data?.suggestions\n      .map((suggestion) => validateSuggestion(suggestion))\n      .filter((suggestion): suggestion is Suggestion => suggestion != null);\n\n    const userEvents: UserEvent[] = data?.user_events\n      .map((event) => validateUserEvent(event))\n      .filter((event): event is UserEvent => event != null);\n\n    // if a form has already been submitted, don't show it in the chat history\n    const formSubmittedUserEventsFormIds = userEvents\n      .filter((event) => event.category === UserEventCategory.FormSubmitted)\n      .map((event) => event.attributes.formResponseId);\n\n    const assistantMessages: Message[][] = responses\n      .map((turn) =>\n        turn\n          .filter(\n            (response) =>\n              !(\n                response.category === ResponseCategory.Form &&\n                formSubmittedUserEventsFormIds.includes(response.id)\n              )\n          )\n          .map((response) => messageFromResponse(response))\n          .filter((message): message is Message => message != null)\n      )\n      .filter((turn) => turn.length > 0);\n\n    const userMessages: Message[][] = userEvents\n      .map((event) => {\n        if (\n          [UserEventCategory.QueryTyped, UserEventCategory.Search].includes(\n            event.category\n          )\n        ) {\n          return [messageFromQueryEvent(event)];\n        }\n\n        if (event.category === UserEventCategory.SuggestionClicked) {\n          return [messageFromSuggestionEvent(event, suggestions)];\n        }\n\n        if (event.category === UserEventCategory.FormSubmitted) {\n          const formResponse = responses\n            .flat()\n            .find(\n              (response) =>\n                response.id === event.attributes.formResponseId &&\n                event.attributes.formType !== FormType.Escalation\n            );\n\n          if (formResponse && formResponse.category === ResponseCategory.Form) {\n            return [\n              messageFromFormSubmittedEvent(event, formResponse.attributes),\n            ];\n          }\n        }\n\n        return [];\n      })\n      .filter((message): message is Message[] => message.length > 0);\n\n    // Sort the messages chronologically to reconstruct the chat history\n    const sortedMessages = [...assistantMessages, ...userMessages].sort(\n      (a, b) =>\n        new Date(a[0].createdAt).getTime() - new Date(b[0].createdAt).getTime()\n    );\n\n    return { responses, userEvents, suggestions, messages: sortedMessages };\n  };\n\n  /**\n   *\n   * @param payload\n   * @returns\n   */\n  static isSupportedEvent = async (\n    payload: SupportedEventRequest\n  ): Promise<SupportedEvent> => {\n    try {\n      const rawResponse =\n        await CommerceApiClient.getInstance().inferenceApi.v1SupportedEventPostRaw(\n          {\n            SupportedEventRequest:\n              coreSupportedEventRequestToApiRequest(payload),\n          }\n        );\n\n      // Get the actual HTTP response JSON\n      const httpResponseText = await rawResponse.raw.text();\n      const httpResponseJson = JSON.parse(httpResponseText);\n\n      return {\n        ...httpResponseJson,\n        numberOfReviews: httpResponseJson.num_of_reviews,\n        merchant_tags: httpResponseJson.merchant_tags || [],\n      };\n    } catch (err) {\n      Logger.logError(\"Failed to get response for v1SupportedEventPost\", {\n        err,\n      });\n      return {\n        supported: false,\n        ready: false,\n        category: undefined,\n        collections: [],\n        numberOfReviews: undefined,\n        top_category: undefined,\n        merchant_tags: [],\n      };\n    }\n  };\n\n  static identifyUser = async (\n    spiffyUserId: string,\n    merchantUserId: string,\n    uaDetails: ClientDetails\n  ): Promise<void> => {\n    try {\n      await CommerceApiClient.getInstance().defaultApi.v1AnalyticsIdentifyPost({\n        AnalyticsIdentifyRequest: {\n          user_id: spiffyUserId,\n          os_name: uaDetails.os,\n          os_version: uaDetails.osVersion,\n          platform: uaDetails.os,\n          device_id: uaDetails.deviceModel,\n          device_brand: uaDetails.deviceBrand,\n          device_manufacturer: uaDetails.deviceManufacturer,\n          device_model: uaDetails.deviceModel,\n          user_properties: {\n            cdp_user_id: merchantUserId,\n            browser: uaDetails.browser,\n            browser_version: uaDetails.browserVersion,\n            user_agent: uaDetails.userAgent,\n          },\n        },\n      });\n    } catch (err) {\n      Logger.logError(\"Failed to identify user\", err);\n    }\n  };\n\n  private static mapContextSourceToV1OrgConfigGetSource = (\n    source: ContextSourceEnum | undefined\n  ): V1OrgConfigGetSourceEnum | undefined => {\n    if (source === undefined) return undefined;\n    switch (source) {\n      case ContextSourceEnum.Fork:\n        return V1OrgConfigGetSourceEnum.Fork;\n      case ContextSourceEnum.Playground:\n        return V1OrgConfigGetSourceEnum.Playground;\n      case ContextSourceEnum.App:\n        return V1OrgConfigGetSourceEnum.App;\n      case ContextSourceEnum.Test:\n        return V1OrgConfigGetSourceEnum.Test;\n      default: {\n        // This ensures that if new values are added to ContextSourceEnum, we catch it\n        const exhaustiveCheck: never = source;\n        return exhaustiveCheck;\n      }\n    }\n  };\n\n  static getOrgConfig = async (\n    user_id: string\n  ): Promise<OrgConfig | undefined> => {\n    try {\n      const atomStore = getAtomStore();\n      const reactAppName = atomStore.get(reactAppNameAtom);\n      const contextSource = atomStore.get(contextSourceAtom);\n      const featureFlagService = atomStore.get(featureFlagServiceAtom); // Get featureFlagService\n      const request: V1OrgConfigGetRequest = {\n        namespace: reactAppName,\n        user_id,\n        source: this.mapContextSourceToV1OrgConfigGetSource(contextSource),\n        include_experiments: Object.values(ProductExperiment),\n        include_feature_gates: Object.entries(\n          featureFlagService?.featureFlagService?.getFeatureFlags() || {}\n        )\n          .filter(([, isEnabled]) => isEnabled)\n          .map(([featureGateName]) => featureGateName), // Use featureFlagService\n      };\n      const response =\n        await CommerceApiClient.getInstance().defaultApi.v1OrgConfigGet(\n          request\n        );\n\n      return validateOrgConfigResults(response);\n    } catch (err) {\n      Logger.logError(`Failed to get org config`, err, { err });\n      return undefined;\n    }\n  };\n\n  static addNoteToLatestConversation = async (\n    spiffyUserId: string,\n    email: string,\n    customerServiceProvider: CustomerServiceProvider\n  ) => {\n    Logger.logInfo(\n      `addNoteToLatestConversation - user_id=${spiffyUserId} email=${email} customer_service_provider=${customerServiceProvider}`\n    );\n    try {\n      await CommerceApiClient.getInstance().customerServiceApi.v1CustserviceAddNoteToLatestConversationPost(\n        {\n          AddNoteToLatestConversationRequest: {\n            spiffy_user_id: spiffyUserId,\n            email,\n            customer_service_provider: customerServiceProvider,\n          },\n        }\n      );\n    } catch (err) {\n      Logger.logError(\"Failed to add note to latest conversation\", { err });\n    }\n  };\n\n  static getCustomerServiceApi = () =>\n    CommerceApiClient.getInstance().customerServiceApi;\n}\n\nexport default CommerceApiClient;\n","import { useState, useCallback } from \"react\";\nimport {\n  SpiffyMetricsEventName,\n  useAmplitude,\n} from \"src/contexts/amplitudeContext\";\n\nexport const useAmplitudeTracking = () => {\n  const { trackEvent, isReady } = useAmplitude();\n  const [loading, setLoading] = useState(false);\n  const [error, setError] = useState<Error | null>(null);\n\n  const track = useCallback(\n    async (\n      eventName: SpiffyMetricsEventName,\n      eventProps?: Record<string, unknown>\n    ) => {\n      if (!isReady) return;\n\n      setLoading(true);\n      setError(null);\n\n      try {\n        await trackEvent({ eventName, eventProps });\n      } catch (err) {\n        setError(err instanceof Error ? err : new Error(\"Tracking failed\"));\n        throw err;\n      } finally {\n        setLoading(false);\n      }\n    },\n    [trackEvent, isReady]\n  );\n\n  return { track, loading, error, isReady };\n};\n","import { useEffect } from \"react\";\n\nexport const useBlockBackButton = (enabled: boolean, callback: () => void) => {\n\n  useEffect(() => {\n    if (enabled && window) {\n\n      if (window.history.scrollRestoration) {\n        window.history.scrollRestoration = \"manual\"\n      }\n\n      window.history.pushState(null, document.title, window.location.href);\n      window.onpopstate = (e) => {\n        e.preventDefault();\n        window.history.pushState(null, document.title, window.location.href);\n        callback?.()\n      };\n    }\n\n    return () => {\n      if (enabled && window) {\n        window.history.back()\n        window.onpopstate = null\n        window.history.scrollRestoration = \"auto\";\n      }\n    }\n  }, [enabled])\n\n}","import { useCdn } from \"../contexts/cdnContext\";\n\nexport const useCdnUrl = () => {\n  const { cdnUrl } = useCdn();\n  return cdnUrl;\n};\n\nexport const useCdnBasePath = () => {\n  const { getCdnBasePath } = useCdn();\n  return getCdnBasePath();\n};\n\nexport const useAssetUrl = (assetName: string, orgShortName: string) => {\n  const { getAssetURL } = useCdn();\n  return getAssetURL(assetName, orgShortName);\n};\n","import { useAtomValue, useSetAtom } from \"jotai\";\nimport { ChatElementDisplayLocation } from \"src/application/models/chatElementDisplayLocation\";\nimport { chatAtom, chatOnToggleAtom } from \"src/atoms/chat\";\nimport {\n  SpiffyMetricsEventName,\n  useAmplitude,\n} from \"src/contexts/amplitudeContext\";\n\nexport const useChatToggle = () => {\n  const onToggle = useSetAtom(chatOnToggleAtom);\n  const { isOpen } = useAtomValue(chatAtom);\n  const { trackEvent } = useAmplitude();\n\n  const toggle = (\n    triggerLocation: ChatElementDisplayLocation,\n    triggerId?: string\n  ) => {\n    if (!isOpen) {\n      trackEvent({\n        eventName: SpiffyMetricsEventName.ChatComponentExpanded,\n        eventProps: {\n          message_metadata: {\n            trigger_location: triggerLocation,\n            trigger_id: triggerId,\n          },\n        },\n      });\n    } else {\n      trackEvent({\n        eventName: SpiffyMetricsEventName.ChatComponentCollapsed,\n        eventProps: {\n          message_metadata: {\n            trigger_location: triggerLocation,\n            trigger_id: triggerId,\n          },\n        },\n      });\n    }\n\n    onToggle();\n  };\n\n  const openChat = (\n    triggerLocation: ChatElementDisplayLocation,\n    triggerId?: string\n  ) => {\n    if (!isOpen) {\n      toggle(triggerLocation, triggerId);\n    }\n  };\n\n  const closeChat = (\n    triggerLocation: ChatElementDisplayLocation,\n    triggerId?: string\n  ) => {\n    if (isOpen) {\n      toggle(triggerLocation, triggerId);\n    }\n  };\n\n  return {\n    toggle,\n    isOpen,\n    openChat,\n    closeChat,\n  };\n};\n","import { useSetAtom } from \"jotai\";\nimport { chatOnToggleAtom } from \"src/atoms/chat/chatState\";\nimport { ChatElementDisplayLocation } from \"src/application/models/chatElementDisplayLocation\";\nimport { useAmplitudeTracking } from \"./useAmplitudeOperations\";\n\nexport const useChatToggleAnalytics = () => {\n  const setChatOnToggle = useSetAtom(chatOnToggleAtom);\n  const { track } = useAmplitudeTracking();\n\n  const toggleChat = (triggerLocation?: ChatElementDisplayLocation) => {\n    setChatOnToggle(triggerLocation, track);\n  };\n\n  return { toggleChat };\n};\n","import Logger from 'src/application/logging/logger';\nimport { useCallback } from 'react';\n\n/**\n * Hook to call the `click` method of the merchant's customer support chat widget.\n *\n * @param onSwitchToAgent a function to override the function returned by the hook. This is mainly to\n * preserve backward compatibility for merchants not using Kustomer and will be removed when all\n * CS integrations are handled.\n *\n * @returns a function that searches for the customer support chat widget and calls the `click` method.\n */\nexport const useCustomerSupportHandoff = (onSwitchToAgent?: () => void) => {\n  // TODO handle Gorgias\n\n  const onKustomerSwitch = useCallback(() => {\n    const kustomerElement = document.getElementById('kustomer-ui-sdk-iframe');\n\n    if (kustomerElement == null || !(kustomerElement instanceof HTMLIFrameElement)) {\n      Logger.logError('[spiffy-ai] Kustomer iFrame element not found', undefined);\n      return;\n    }\n\n    const kustomerButton = kustomerElement.contentWindow?.document?.getElementById('rootChatIcon');\n\n    if (kustomerButton == null) {\n      Logger.logError('[spiffy-ai] Kustomer button not found', undefined);\n      return;\n    }\n\n    kustomerButton.click();\n  }, []);\n\n  if (onSwitchToAgent != null) {\n    return { onSwitch: onSwitchToAgent };\n  }\n\n  return { onSwitch: onKustomerSwitch };\n};\n","import { useState, useEffect } from 'react';\n\nexport function useDebounce<T>(value: T, delay: number): T {\n  const [debouncedValue, setDebouncedValue] = useState<T>(value);\n\n  useEffect(() => {\n    const handler = setTimeout(() => {\n      setDebouncedValue(value);\n    }, delay);\n\n    return () => {\n      clearTimeout(handler);\n    };\n  }, [value, delay]);\n\n  return debouncedValue;\n}\n","import { ReactElement, useEffect, useRef, useState } from 'react';\nimport { DOMObserver } from 'src/application/utils/domObserver';\nimport { ElementObserver } from 'src/application/utils/elementObserver';\nimport { MouseEventTypes } from 'src/application/utils/mouseEventTypes';\nimport { NodeSelector } from 'src/application/utils/nodeSelector';\n\nexport interface ElementObserverUtility {\n  onChange: (fn: (el: HTMLElement | null) => void) => void;\n  onAdd: (fn: (el: HTMLElement | null) => void) => void;\n  onRemove: (fn: (el: HTMLElement | null) => void) => void;\n  onClassChange: (fn: (classes?: DOMTokenList) => void) => void;\n  onClassAdded: (className: string, fn: () => void) => void;\n  onClassRemoved: (className: string, fn: () => void) => void;\n  onAddChild: (fn: (nodes?: DOMTokenList) => void) => void;\n  onRemoveChild: (fn: (nodes?: DOMTokenList) => void) => void;\n  onEvent: <K extends keyof HTMLElementEventMap>(\n    event: K,\n    fn: EventListenerOrEventListenerObject,\n  ) => void;\n  blockRendering: () => void;\n  unblockRendering: () => void;\n  exists: () => boolean;\n  isRendered: () => boolean;\n  render: (fn: () => ReactElement) => ReactElement | undefined;\n  fire: (event: MouseEventTypes) => void;\n  show: () => void;\n  hide: () => void;\n  applyStyle: (styles: React.CSSProperties) => void;\n  targetNode: HTMLElement | null;\n}\n\n/*\n * This hook enables the connection between a `MutationObserver` and a React.js component.\n * It abstracts all the necessary validations and implementations to modify HTML elements,\n * monitor their changes, and interact with them. The only required input is the element's selector.\n *\n * How to use it:\n *\n * Let's assume we want to interact with the following element:\n * `<div id=\"awesome-content\"><content /></div>`\n *\n * To hook into that element, simply do the following:\n * `const element = useElementObserver(SelectorFactory.id(\"awesome-content\"))`\n *\n * With the `ElementObserver` instance in hand, we can interact with the HTML element without having\n * to manage its presence in the DOM. The `onAdd` and `onRemove` functions can be used to determine\n * whether the element is present in the DOM or not, and to ensure interaction occurs only when necessary.\n *\n * @param selector\n * @returns\n */\nexport const useElementObserver = (selector: NodeSelector): ElementObserverUtility => {\n  const INITIAL_RENDER_STATE = true;\n  const eoRef = useRef<ElementObserver>(DOMObserver.add(selector));\n  const [renderBlocked, setRenderBlocked] = useState(INITIAL_RENDER_STATE);\n\n  /**\n   * Fired every time the HTML element changes.\n   *\n   * @param fn\n   */\n  const onChange = (fn: (el: HTMLElement | null) => void) => {\n    eoRef.current?.registerOnChange(fn);\n  };\n\n  /**\n   * Fired when the HTML element is added to the DOM.\n   *\n   * @param fn\n   */\n  const onAdd = (fn: (el: HTMLElement | null) => void) => {\n    eoRef.current?.registerOnAdd(fn);\n  };\n\n  /**\n   * Fired when the HTML element is removed from the DOM.\n   *\n   * @param fn\n   */\n  const onRemove = (fn: (el: HTMLElement | null) => void) => {\n    eoRef.current?.registerOnRemove(fn);\n  };\n\n  /**\n   * Fired when the class of the HTML element changes.\n   *\n   * @param fn\n   */\n  const onClassChange = (fn: (classes?: DOMTokenList) => void) => {\n    eoRef.current?.registerOnclassChange(fn);\n  };\n\n  /**\n   * Fired when a class is added to the HTML element.\n   *\n   * @param className\n   * @param fn\n   */\n  const onClassAdded = (className: string, fn: () => void) => {\n    eoRef.current?.registerOnClassAdded(className, fn);\n  };\n\n  /**\n   * Fired when a class is removed from the HTML element.\n   *\n   * @param className\n   * @param fn\n   */\n  const onClassRemoved = (className: string, fn: () => void) => {\n    eoRef.current?.registerOnClassRemoved(className, fn);\n  };\n\n  /**\n   * Fired when a child element is added to the HTML element.\n   *\n   * @param fn\n   */\n  const onAddChild = (fn: (nodes?: DOMTokenList) => void) => {\n    eoRef.current?.registerOnAddChild(fn);\n  };\n\n  /**\n   * Fired when a child element is removed from the HTML element.\n   *\n   * @param fn\n   */\n  const onRemoveChild = (fn: (nodes?: DOMTokenList) => void) => {\n    eoRef.current?.registerOnRemoveChild(fn);\n  };\n\n  /**\n   * Allows hooking event listeners to the HTML element, such as `focus`, `blur`, etc.\n   *\n   * @param event\n   * @param fn\n   */\n  const onEvent = <K extends keyof HTMLElementEventMap>(\n    event: K,\n    fn: EventListenerOrEventListenerObject,\n  ) => {\n    eoRef.current.registerEvent(event, fn);\n  };\n\n  /**\n   * Useful when rendering a React.js component inside the HTML element.\n   *\n   * @param fn\n   * @returns\n   */\n  const render = (fn: () => ReactElement) => {\n    if (!renderBlocked) {\n      return eoRef.current.render(fn);\n    }\n  };\n\n  /**\n   * Checks if the element exists in the DOM.\n   *\n   * @returns\n   */\n  const exists = () => !!eoRef.current.getNode();\n\n  /**\n   * Checks if rendering is unblocked.\n   *\n   * @returns\n   */\n  const isRendered = () => !renderBlocked;\n\n  /**\n   * Triggers an event for the HTML element.\n   *\n   * @param event\n   */\n  const fire = (event: MouseEventTypes) => {\n    eoRef.current.fire(event);\n  };\n\n  /**\n   * Shows the HTML element.\n   *\n   * @returns\n   */\n  const show = () => eoRef.current.show();\n\n  /**\n   * Hides the HTML element.\n   *\n   * @returns\n   */\n  const hide = () => eoRef.current.hide();\n\n  /**\n   * Blocks the rendering of elements.\n   *\n   * @returns\n   */\n  const blockRendering = () => setRenderBlocked(true);\n\n  /**\n   * Unblocks the rendering of elements.\n   *\n   * @returns\n   */\n  const unblockRendering = () => setRenderBlocked(false);\n\n  /**\n   * Applies CSS styles to the HTML element.\n   *\n   * @param styles\n   */\n  const applyStyle = (styles: React.CSSProperties) => {\n    const node = eoRef?.current?.getNode();\n    node && Object.assign(node.style, styles);\n  };\n\n  useEffect(() => {\n    eoRef.current.init();\n    eoRef.current.registerOnReset(() => setRenderBlocked(INITIAL_RENDER_STATE));\n    DOMObserver.observe();\n    return () => DOMObserver.remove(selector);\n  }, [selector.getPattern()]);\n\n  return {\n    targetNode: eoRef.current.getNode(),\n    onChange,\n    onAdd,\n    onRemove,\n    onClassChange,\n    onClassAdded,\n    onClassRemoved,\n    onAddChild,\n    onRemoveChild,\n    onEvent,\n    blockRendering,\n    unblockRendering,\n    exists,\n    isRendered,\n    render,\n    fire,\n    show,\n    hide,\n    applyStyle,\n  } satisfies ElementObserverUtility;\n};\n","import { useRef, useState } from \"react\";\n\ntype ArrowPosition = 'lt' | 'ct' | 'rt'\n\ninterface AnimationProps {\n    element: HTMLElement\n    targetScroll: number \n    duration: number \n    direction?: 'lt' | 'rt' \n    multiply?: number \n    offset?: number\n    callback?: (position: ArrowPosition) => void\n}\n\nconst animateHorizontalScroll = ({ element, duration, targetScroll, multiply = 1, direction, callback, offset = 0 }: AnimationProps) => {\n    const start = element.scrollLeft\n    const distance = (targetScroll - start) * multiply;\n    const startTime = performance.now();\n\n    function easeOutSine(x: number): number {\n      return Math.sin((x * Math.PI) / 2);\n    }\n\n    function scrollStep(currentTime: number): void {\n        const timeElapsed = currentTime - startTime;\n        const progress = Math.min(timeElapsed / duration, 1);\n        const easing = easeOutSine(progress);\n        const step = start + (distance * easing)\n        const canScroll = (direction === 'rt' ? (element.scrollLeft < step) : (element.scrollLeft > step)) || !direction\n        \n        if (step > 0 && canScroll) {\n          element.scrollTo(step, 0)\n        }\n\n        if (timeElapsed < duration) {\n            requestAnimationFrame(scrollStep);\n        } \n\n        // End of scrolling container\n        else if ((element.scrollLeft + offset) === element.scrollWidth) {\n            callback?.('rt')\n        } \n        // Begin of scrolling container\n        else if (element.scrollLeft <= 1) {\n            callback?.('lt')\n        }\n        // Somewhere in the middle\n        else {\n            callback?.('ct')\n        }\n\n    }\n\n    requestAnimationFrame(scrollStep);\n}\n\n\nexport const useGrabAndScroll = (enabled: boolean, chunkWidth: number, speed: number = 400, offset: number = 0) => {\n    const containerRef = useRef<HTMLDivElement>(null)\n    const [ leftArrow, setLeftArrow ] = useState(false)\n    const [ rightArrow, setRightArrow ] = useState(true)\n\n    const handleArrows = (position: ArrowPosition) => {\n        switch (position) {\n            case 'lt':\n                setLeftArrow(false)\n                setRightArrow(true)\n                break\n\n            case 'rt':\n                setLeftArrow(true)\n                setRightArrow(false)\n                break\n\n            default:\n                setLeftArrow(true)\n                setRightArrow(true)\n        }\n    }\n\n    const animationTrigger = () => {\n        if (enabled && containerRef.current) {\n            const dist = (containerRef?.current?.scrollLeft || 0) / chunkWidth\n            const targetScroll = chunkWidth * (Math.floor(dist) + (dist % 1 > 0.5 ? 1 : 0))\n            animateHorizontalScroll({\n                element: containerRef.current, \n                targetScroll, \n                duration: speed,\n                offset,\n                callback: handleArrows\n            })\n        }\n    }\n\n    const onNext = (cardsToSlide: number) => {\n        if (containerRef.current) {\n            const targetScroll = containerRef.current.scrollLeft + chunkWidth\n            animateHorizontalScroll({\n                element: containerRef.current, \n                targetScroll, \n                duration: speed, \n                direction: 'rt', \n                multiply: cardsToSlide,\n                offset,\n                callback: handleArrows\n            })\n        }\n    }\n    \n    const onPrevious = (cardsToSlide: number) => {\n        if (containerRef.current) {\n            const targetScroll = containerRef.current.scrollLeft - chunkWidth\n            animateHorizontalScroll({\n                element: containerRef.current, \n                targetScroll, \n                duration: speed, \n                direction: 'lt', \n                multiply: cardsToSlide,\n                offset,\n                callback: handleArrows\n            })\n        }\n    }\n\n    return {\n        containerRef,\n        leftArrow,\n        rightArrow,\n        animationTrigger,\n        onNext,\n        onPrevious\n    }\n}","import React, {\n  createContext,\n  useContext,\n  useCallback,\n  useMemo,\n  ReactNode,\n} from \"react\";\nimport { useAtomValue } from \"jotai\";\nimport { baseUrlAtom, orgLevelApiKeyAtom } from \"src/atoms/envive/enviveConfig\";\nimport { getMerchantOrgIdQuery } from \"src/application/models/graphql/queries/getMerchantOrgIdQuery\";\nimport { validateGraphQLOrgId } from \"src/application/models/validators/validateGraphQLOrgId\";\nimport {\n  getMerchantColorsQuery,\n  GetMerchantColorsQueryData,\n  getMerchantFrontendConfigQuery,\n  GetMerchantFrontendConfigQueryData,\n} from \"src/application/models/graphql\";\nimport { validateGraphQLColorsConfig } from \"src/application/models/validators/validateGraphQLColorsConfig\";\nimport { validateGraphQLFrontendConfig } from \"src/application/models/validators/validateGraphQLFrontendConfig\";\nimport { ColorMapping } from \"src/application/models/colorsConfig\";\nimport { FrontendConfig } from \"src/application/models/frontendConfig\";\nimport Logger from \"src/application/logging/logger\";\nimport { configVersion } from \"src/types/config-versions\";\nimport {\n  CamelCasedPropertiesDeep,\n  transformSnakeToCamel,\n} from \"src/application/models\";\n\ninterface BaseMeConfigQueryResponse {\n  me: {\n    org?: {\n      id: string;\n    };\n    getProductsConfigByVersion?: {\n      frontend?: {\n        values: CamelCasedPropertiesDeep<GetMerchantFrontendConfigQueryData>;\n      };\n      colors?: { values: CamelCasedPropertiesDeep<GetMerchantColorsQueryData> };\n    };\n  };\n}\nexport type ColorsConfigResponse = CamelCasedPropertiesDeep<ColorMapping>;\nexport type FrontendConfigResponse = CamelCasedPropertiesDeep<FrontendConfig>;\n\nexport type GraphQlConfigValues = {\n  colorsConfig?: ColorsConfigResponse;\n  frontendConfig?: CamelCasedPropertiesDeep<FrontendConfig>;\n};\n\ninterface GraphQLContextValue {\n  executeQuery: <T>(\n    query: string,\n    variables?: Record<string, unknown>\n  ) => Promise<T>;\n  getOrgId: () => Promise<string | undefined>;\n  getColorsAndFrontendConfig: () => Promise<GraphQlConfigValues>;\n  isReady: boolean;\n}\n\nconst GraphQLContext = createContext<GraphQLContextValue | null>(null);\n\nconst colorsAndFrontendConfigQuery = () => `\n  query ($version: String = \"${configVersion()}\") {\n    me {\n      getProductsConfigByVersion(version: $version) {\n        frontend { values }\n        colors { values }\n      }\n    }\n  }\n`;\n\ntype GraphQLProviderProps = {\n  children: ReactNode;\n};\n\nexport const GraphQLProvider = ({ children }: GraphQLProviderProps) => {\n  const apiKey = useAtomValue(orgLevelApiKeyAtom);\n  const baseUrl = useAtomValue(baseUrlAtom);\n\n  const isReady = Boolean(apiKey && baseUrl);\n\n  const executeQuery = useCallback(\n    async (query: string, variables?: Record<string, unknown>) => {\n      if (!isReady) {\n        throw new Error(\"GraphQL client not ready - missing apiKey or baseUrl\");\n      }\n\n      const response = await fetch(`${baseUrl}/v1/graphql`, {\n        method: \"POST\",\n        headers: {\n          \"Content-Type\": \"application/json\",\n          Authorization: `Bearer ${apiKey}`,\n        },\n        body: JSON.stringify({ query, variables }),\n      });\n\n      if (!response.ok) {\n        throw new Error(`GraphQL request failed: ${response.statusText}`);\n      }\n\n      const result = await response.json();\n      if (result.errors) {\n        throw new Error(`GraphQL errors: ${JSON.stringify(result.errors)}`);\n      }\n\n      return result.data;\n    },\n    [apiKey, baseUrl, isReady]\n  );\n\n  const getOrgId = useCallback(async () => {\n    const response = await executeQuery(getMerchantOrgIdQuery);\n    return validateGraphQLOrgId(response.me.org?.id);\n  }, [executeQuery]);\n\n  const getColorsAndFrontendConfig =\n    useCallback(async (): Promise<GraphQlConfigValues> => {\n      try {\n        const query = await colorsAndFrontendConfigQuery();\n        if (!query) {\n          throw new Error(\"Colors and frontend config query is not defined\");\n        }\n        const response = await executeQuery(query);\n        const colorsConfig =\n          response.me.getProductsConfigByVersion?.colors?.values;\n        const frontendConfig =\n          response.me.getProductsConfigByVersion?.frontend?.values;\n        const transformedColorConfig = transformSnakeToCamel(colorsConfig);\n        const transformedFrontendConfig = transformSnakeToCamel(frontendConfig);\n        return {\n          colorsConfig: transformedColorConfig as ColorsConfigResponse,\n          frontendConfig: transformedFrontendConfig as FrontendConfigResponse,\n        };\n      } catch (err) {\n        Logger.logError(\n          \"Error fetching graphql colors and frontend config\",\n          err\n        );\n        return { colorsConfig: undefined, frontendConfig: undefined };\n      }\n    }, [executeQuery]);\n\n  const value = useMemo(\n    () => ({\n      executeQuery,\n      getOrgId,\n      getColorsAndFrontendConfig,\n      isReady,\n    }),\n    [executeQuery, getOrgId, getColorsAndFrontendConfig, isReady]\n  );\n\n  return (\n    <GraphQLContext.Provider value={value}>{children}</GraphQLContext.Provider>\n  );\n};\n\nexport const useGraphQLClient = () => {\n  const context = useContext(GraphQLContext);\n  if (!context) {\n    throw new Error(\"useGraphQLClient must be used within a GraphQLProvider\");\n  }\n  return context;\n};\n","import { useCallback, useEffect, useState } from \"react\";\nimport { useGraphQLClient } from \"src/contexts/graphqlContext\";\nimport { ColorMapping } from \"src/application/models/colorsConfig\";\nimport { FrontendConfig } from \"src/application/models/frontendConfig\";\nimport { transformSnakeToCamel } from \"src/application/models\";\n\nexport const useColorsAndFrontendConfig = () => {\n  const { getColorsAndFrontendConfig, isReady } = useGraphQLClient();\n  const [data, setData] = useState({});\n  const [loading, setLoading] = useState(false);\n  const [error, setError] = useState<Error | null>(null);\n\n  const fetchConfig = useCallback(async () => {\n    if (!isReady) return;\n\n    setLoading(true);\n    setError(null);\n\n    try {\n      const result = await getColorsAndFrontendConfig();\n      setData(result);\n    } catch (err) {\n      setError(err instanceof Error ? err : new Error(\"Unknown error\"));\n    } finally {\n      setLoading(false);\n    }\n  }, [getColorsAndFrontendConfig, isReady]);\n\n  useEffect(() => {\n    fetchConfig();\n  }, [fetchConfig]);\n\n  return { data, loading, error, refetch: fetchConfig };\n};\n\nexport const useOrgId = () => {\n  const { getOrgId, isReady } = useGraphQLClient();\n  const [orgId, setOrgId] = useState<string | undefined>();\n  const [loading, setLoading] = useState(false);\n  const [error, setError] = useState<Error | null>(null);\n\n  useEffect(() => {\n    if (!isReady) return;\n\n    const fetchOrgId = async () => {\n      setLoading(true);\n      setError(null);\n\n      try {\n        const id = await getOrgId();\n        setOrgId(id);\n      } catch (err) {\n        setError(err instanceof Error ? err : new Error(\"Unknown error\"));\n      } finally {\n        setLoading(false);\n      }\n    };\n\n    fetchOrgId();\n  }, [getOrgId, isReady]);\n\n  return { orgId, loading, error };\n};\n","import React, {\n  createContext,\n  useCallback,\n  useContext,\n  useMemo,\n  useState,\n  useEffect,\n} from \"react\";\nimport UAParser from \"ua-parser-js\";\nimport Logger from \"src/application/logging/logger\";\nimport CommerceApiClient from \"src/application/commerce-api\";\nimport { v4 as uuid } from \"uuid\";\nimport { ClientDetails } from \"src/application/models/clientDetails\";\nimport { useLocalStorage } from \"src/contexts/localStorageContext\";\n\n// Helper function from the original service\nconst getUserAgentDetails = (): ClientDetails => {\n  const uaParser = new UAParser();\n  const result = uaParser.getResult();\n\n  return {\n    os: result?.os?.name,\n    osVersion: result?.os?.version,\n    deviceBrand: result?.device?.vendor,\n    deviceManufacturer: result?.device?.vendor,\n    deviceModel: result?.device?.model,\n    browser: result?.browser?.name,\n    browserVersion: result?.browser?.version,\n    userAgent: result?.ua,\n  };\n};\n\nexport interface UserIdentityContextType {\n  identifyUser: () => Promise<void>;\n  getUserIdOrDefault: () => string;\n  getUserIdOverrideFromLocalStorage: () => string | undefined;\n  getUserIdDefaultFromLocalStorage: () => string | undefined;\n  setUserIdDefaultInLocalStorage: (userId: string) => string;\n  setUserIdOverrideInLocalStorage: (userId: string) => string;\n  clearUserIdOverrideInLocalStorage: () => void;\n  isReady: boolean;\n}\n\nconst UserIdentityContext = createContext<UserIdentityContextType | undefined>(\n  undefined\n);\n\nexport const UserIdentityProvider: React.FC<{ children: React.ReactNode }> = ({\n  children,\n}) => {\n  const {\n    getItem,\n    setItem,\n    isAvailable: localStorageIsReady,\n  } = useLocalStorage();\n\n  const [isReady, setIsReady] = useState(false);\n\n  useEffect(() => {\n    // Assuming CommerceApiClient and other dependencies are ready if localStorage is.\n    // In a more complex scenario, you might have more checks here.\n    setIsReady(localStorageIsReady);\n  }, [localStorageIsReady]);\n\n  const USER_ID_OVERRIDE_KEY = \"v1-spiffy-user-id-override\";\n  const USER_ID_DEFAULT_KEY = \"v1-spiffy-user-id-default\";\n\n  const getUserIdOverrideFromLocalStorage = useCallback(():\n    | string\n    | undefined => {\n    return getItem(USER_ID_OVERRIDE_KEY) ?? undefined;\n  }, [getItem]);\n\n  const getUserIdDefaultFromLocalStorage = useCallback(():\n    | string\n    | undefined => {\n    return getItem(USER_ID_DEFAULT_KEY) ?? undefined;\n  }, [getItem]);\n\n  const setUserIdDefaultInLocalStorage = useCallback(\n    (userId: string): string => {\n      Logger.logInfo(\n        `setUserIdDefaultInLocalStorage - Setting user_id=${userId}`\n      );\n      setItem(USER_ID_DEFAULT_KEY, userId);\n      // window.dispatchEvent is handled by useLocalStorage now\n      return userId;\n    },\n    [setItem, USER_ID_DEFAULT_KEY]\n  );\n\n  const setUserIdOverrideInLocalStorage = useCallback(\n    (userId: string): string => {\n      Logger.logInfo(\n        `setUserIdOverrideInLocalStorage - Setting user_id=${userId}`\n      );\n      setItem(USER_ID_OVERRIDE_KEY, userId);\n      // window.dispatchEvent is handled by useLocalStorage now\n      return userId;\n    },\n    [setItem, USER_ID_OVERRIDE_KEY]\n  );\n\n  const clearUserIdOverrideInLocalStorage = useCallback(() => {\n    Logger.logInfo(`clearUserIdOverrideInLocalStorage - Clearing user_id`);\n    // LocalStorageService.getLocalStorage()?.removeItem(USER_ID_OVERRIDE_KEY);\n    // window.dispatchEvent is handled by useLocalStorage now\n    setItem(USER_ID_OVERRIDE_KEY, \"\"); // Set to empty string to clear\n  }, [setItem, USER_ID_OVERRIDE_KEY]);\n\n  const getUserIdOrDefault = useCallback((): string => {\n    const userIdOverride = getUserIdOverrideFromLocalStorage();\n    if (userIdOverride) {\n      return userIdOverride;\n    }\n\n    const defaultUserId = getUserIdDefaultFromLocalStorage();\n    if (defaultUserId) {\n      return defaultUserId;\n    }\n\n    return setUserIdDefaultInLocalStorage(`spiffy-user-id-${uuid()}`);\n  }, [\n    getUserIdOverrideFromLocalStorage,\n    getUserIdDefaultFromLocalStorage,\n    setUserIdDefaultInLocalStorage,\n  ]);\n\n  const identifyUser = useCallback(async (): Promise<void> => {\n    if (!isReady) {\n      Logger.logWarn(\n        \"[UserIdentityContext] Context not ready, skipping identifyUser\",\n        undefined\n      );\n      return;\n    }\n\n    try {\n      // Temporarily commented out until WindowDataLayerService is resolved\n      // const cdpUserId = WindowDataLayerService.getGoogleAnalyticsClientId();\n      const cdpUserId = \"UNKNOWN_CDP_USER_ID\"; // Placeholder\n      const userId = getUserIdOrDefault();\n      const userAgentDetails = getUserAgentDetails();\n\n      if (!cdpUserId) {\n        Logger.logWarn(\n          \"[spiffy-ai] No GA Client ID found, skipping identifyUser\",\n          undefined\n        );\n        return;\n      }\n\n      await CommerceApiClient.identifyUser(userId, cdpUserId, userAgentDetails);\n    } catch (error) {\n      Logger.logError(\"[spiffy-ai] Error identifying user\", error);\n    }\n  }, [isReady, getUserIdOrDefault]);\n\n  const value = useMemo(\n    () => ({\n      identifyUser,\n      getUserIdOrDefault,\n      getUserIdOverrideFromLocalStorage,\n      getUserIdDefaultFromLocalStorage,\n      setUserIdDefaultInLocalStorage,\n      setUserIdOverrideInLocalStorage,\n      clearUserIdOverrideInLocalStorage,\n      isReady,\n    }),\n    [\n      identifyUser,\n      getUserIdOrDefault,\n      getUserIdOverrideFromLocalStorage,\n      getUserIdDefaultFromLocalStorage,\n      setUserIdDefaultInLocalStorage,\n      setUserIdOverrideInLocalStorage,\n      clearUserIdOverrideInLocalStorage,\n      isReady,\n    ]\n  );\n\n  return (\n    <UserIdentityContext.Provider value={value}>\n      {children}\n    </UserIdentityContext.Provider>\n  );\n};\n\nexport const useUserIdentity = () => {\n  const context = useContext(UserIdentityContext);\n  if (!context) {\n    throw new Error(\n      \"useUserIdentity must be used within a UserIdentityProvider\"\n    );\n  }\n  return context;\n};\n","import { useState, useCallback } from \"react\";\nimport { useUserIdentity } from \"src/contexts/userIdentityContext\";\n\nexport const useIdentifyUser = () => {\n  const { identifyUser, isReady } = useUserIdentity();\n  const [loading, setLoading] = useState(false);\n  const [error, setError] = useState<Error | null>(null);\n\n  const executeIdentifyUser = useCallback(async () => {\n    if (!isReady) {\n      setError(new Error(\"UserIdentityContext not ready.\"));\n      return;\n    }\n\n    setLoading(true);\n    setError(null);\n\n    try {\n      await identifyUser();\n    } catch (err) {\n      setError(\n        err instanceof Error\n          ? err\n          : new Error(\"Unknown error during user identification.\")\n      );\n      throw err;\n    } finally {\n      setLoading(false);\n    }\n  }, [identifyUser, isReady]);\n\n  return { loading, error, executeIdentifyUser, isReady };\n};\n","import { useAtomValue } from \"jotai\";\nimport { OrgShortName } from \"src/application/models\";\nimport { orgShortNameAtom } from \"src/atoms/envive/enviveConfig\";\nabstract class ImageResolver {\n  abstract resolve(url: string, size: number): string;\n}\n\nclass MerchantImageResolver {\n  private static imageResolverMap = new Map<string, ImageResolver>();\n\n  private static loadMapping() {\n    if (this.imageResolverMap.size === 0) {\n      this.imageResolverMap.set(OrgShortName.Spanx, new ShopifyImageResolver());\n      this.imageResolverMap.set(\n        OrgShortName.SpanxStaging,\n        new ShopifyImageResolver()\n      );\n      this.imageResolverMap.set(\n        OrgShortName.UniqueVintage,\n        new ShopifyImageResolver()\n      );\n    }\n    return this.imageResolverMap;\n  }\n\n  static get(name: string) {\n    return this.loadMapping().get(name);\n  }\n}\n\nclass ShopifyImageResolver extends ImageResolver {\n  resolve(url: string, size: number): string {\n    const pattern = /_\\d+x\\.jpg/;\n    const urlHasPrefix = pattern.test(url);\n    const newSizePrefix = `_${size}x.jpg`;\n    if (urlHasPrefix) {\n      return url.replace(pattern, newSizePrefix);\n    }\n    return url.replace(\".jpg\", newSizePrefix);\n  }\n}\n\nexport const useImageResolver = () => {\n  const orgShortName = useAtomValue(orgShortNameAtom);\n  const resolve = (image?: string, size?: number) => {\n    if (image && size && orgShortName) {\n      const newImagePath = MerchantImageResolver.get(orgShortName)?.resolve(\n        image,\n        size\n      );\n      return newImagePath || image;\n    }\n    return image;\n  };\n\n  return {\n    resolve,\n  };\n};\n","import { RefObject, useEffect, useState } from 'react';\n\n// https://rasilbaidar.medium.com/trigger-event-when-element-enters-viewport-the-react-way-168509da2e23\nexport const useIntersection = (element: RefObject<HTMLElement>, rootMargin: string) => {\n  const [isVisible, setIsVisible] = useState(false);\n\n  useEffect(() => {\n    const current = element?.current;\n    const observer = new IntersectionObserver(\n      ([entry]) => {\n        setIsVisible(entry.isIntersecting);\n      },\n      { rootMargin },\n    );\n\n    if (current) {\n      observer?.observe(current);\n    }\n\n    return () => {\n      if (current) {\n        observer.unobserve(current);\n      }\n    };\n  }, []);\n\n  return isVisible;\n};\n","import { useState, useEffect } from 'react';\n\nexport const useIsSmallScreen = () => {\n  const [isSmall, setIsSmall] = useState(false);\n\n  useEffect(() => {\n    const mediaQuery = window.matchMedia('(max-width: 479px)');\n\n    // Set initial value\n    setIsSmall(mediaQuery.matches);\n\n    // Update state when viewport changes\n    const handleResize = (event: MediaQueryListEvent) => {\n      setIsSmall(event.matches);\n    };\n\n    mediaQuery.addEventListener('change', handleResize);\n\n    return () => mediaQuery.removeEventListener('change', handleResize);\n  }, []);\n\n  return isSmall;\n};\n","import { useState, useEffect, useCallback } from \"react\";\nimport {\n  useLocalStorage,\n  LocalStorageKeys,\n} from \"../contexts/localStorageContext\";\nimport { LocalStorageEventListener } from \"../application/models/localStorageEventListener\";\n\n// Reactive localStorage value hook\nexport const useLocalStorageValue = (key: string) => {\n  const { getItem, setItem, attachListener, detachListener } =\n    useLocalStorage();\n  const [value, setValue] = useState<string | null>(() => getItem(key));\n\n  useEffect(() => {\n    const listener: LocalStorageEventListener = {\n      storageKey: key,\n      listener: (event: StorageEvent) => {\n        setValue(event.newValue);\n      },\n    };\n\n    attachListener(listener);\n    return () => detachListener(listener);\n  }, [key, attachListener, detachListener]);\n\n  const updateValue = useCallback(\n    (newValue: string) => {\n      setItem(key, newValue);\n      setValue(newValue);\n    },\n    [key, setItem]\n  );\n\n  return { value, setValue: updateValue };\n};\n\n// Feature flag hook for Spiffy\nexport const useSpiffyFeatureFlag = () => {\n  const { setSpiffyOnFeatureFlag } = useLocalStorage();\n  const { value } = useLocalStorageValue(LocalStorageKeys.SpiffyOnOverride);\n\n  const setFlag = useCallback(\n    (flag: boolean | null) => {\n      setSpiffyOnFeatureFlag(flag);\n    },\n    [setSpiffyOnFeatureFlag]\n  );\n\n  return {\n    value: value === \"true\" ? true : value === \"false\" ? false : null,\n    setFlag,\n  };\n};\n\n// Feature flag hook for Envive\nexport const useEnviveFeatureFlag = () => {\n  const { setItem, getItem } = useLocalStorage();\n  const { value } = useLocalStorageValue(LocalStorageKeys.EnviveOnOverride);\n\n  const setFlag = useCallback(\n    (flag: boolean | null) => {\n      if (flag === true) {\n        setItem(LocalStorageKeys.EnviveOnOverride, \"true\");\n      } else if (flag === false) {\n        setItem(LocalStorageKeys.EnviveOnOverride, \"false\");\n      }\n    },\n    [setItem]\n  );\n\n  return {\n    value: value === \"true\" ? true : value === \"false\" ? false : null,\n    setFlag,\n  };\n};\n\n// Storage listener hook\nexport const useLocalStorageListener = (\n  key: string,\n  callback: (event: StorageEvent) => void\n) => {\n  const { attachListener, detachListener } = useLocalStorage();\n\n  useEffect(() => {\n    const listener: LocalStorageEventListener = {\n      storageKey: key,\n      listener: callback,\n    };\n    attachListener(listener);\n    return () => detachListener(listener);\n  }, [key, callback, attachListener, detachListener]);\n};\n","import { Message, MessageRole, MessageType } from 'src/application/models';\n\ntype MessageFinder = {\n  msgs: Message[][];\n  type?: MessageType;\n  role?: MessageRole;\n};\n\nexport const useMessageFilter = () => {\n  const findMessageIndex = ({ msgs, type, role }: MessageFinder) => {\n    let lastIndex = -1;\n    msgs.forEach((subArray, index) => {\n      subArray.forEach((obj) => {\n        if (obj.type === type || obj.role === role) lastIndex = index;\n      });\n    });\n    return lastIndex;\n  };\n\n  const removePreviousDiscussions = (msgs: Message[][], index: number) => {\n    if (index > -1) {\n      const lastMessages = msgs.slice(index);\n      return lastMessages.length > 0 ? lastMessages : msgs;\n    }\n    return msgs;\n  };\n\n  const getFilteredMessages = (msgs: Message[][], skipFilter?: boolean) => {\n    const messageMap = msgs.reduce(\n      (acc, msg) => {\n        acc[msg[0].id] = msg;\n        return acc;\n      },\n      {} as Record<string, Message[]>,\n    );\n    const deduplicatedMsgs = Object.values(messageMap);\n    if (!skipFilter) {\n      const idx = findMessageIndex({ msgs: deduplicatedMsgs, type: MessageType.Separator });\n      return removePreviousDiscussions(deduplicatedMsgs, idx);\n    }\n    return deduplicatedMsgs;\n  };\n\n  return {\n    findMessageIndex,\n    removePreviousDiscussions,\n    getFilteredMessages,\n  };\n};\n","import { useEffect } from \"react\";\n\nexport const useMessageScrollObserver = (\n    boxRef: React.RefObject<HTMLDivElement>, \n    scrollRef: React.RefObject<HTMLDivElement>, \n    onScrollChange: (position: number) => void\n) => {\n\n    const calculateScrollHeight = () => {\n      const boxHeight = boxRef?.current?.getBoundingClientRect().height || 0\n      const scrollHeight = scrollRef?.current?.getBoundingClientRect().height || 0\n      return boxHeight - scrollHeight\n    }\n\n    const updateState = () => {\n      const scrollHeight = calculateScrollHeight()\n      if (scrollHeight > 0) {\n        onScrollChange(scrollHeight)\n      }\n    }\n\n    useEffect(() => {\n      let boxRO = null;\n      let scrollRO = null;\n\n      if (scrollRef?.current) {\n        boxRO = new ResizeObserver(updateState);\n        boxRO.observe(scrollRef?.current);\n      }\n      \n      if (boxRef?.current) {\n        scrollRO = new ResizeObserver(updateState);\n        scrollRO.observe(boxRef?.current);\n      }\n\n      return () => {\n        if (scrollRef?.current && boxRO) {\n          boxRO.unobserve(scrollRef?.current);\n        }\n\n        if (scrollRO && boxRef?.current) {\n          scrollRO?.unobserve(boxRef?.current)\n        }\n      };\n    }, []);\n\n}","import React, { createContext, useContext, useMemo, ReactNode } from \"react\";\nimport { OrgConfigFeatureGate } from \"src/application/models/api/orgConfigResults\";\nimport { FeatureGates } from \"src/application/models/featureGates\";\nimport Logger from \"src/application/logging/logger\";\n\n// This is the class that was previously implicitly used or defined elsewhere\nclass FeatureFlagService {\n  private featureGates: OrgConfigFeatureGate[];\n\n  constructor(featureGates: OrgConfigFeatureGate[]) {\n    this.featureGates = featureGates;\n  }\n\n  isFeatureGateEnabled = (featureGate: FeatureGates): boolean => {\n    const gateValue = this.featureGates.find(\n      (gate) => gate.name === featureGate\n    );\n\n    // TODO: Add logic for overrides (query params, window, stored) if needed, similar to the old FeatureFlagContext.tsx\n    // For now, direct value from config is used.\n\n    if (gateValue == null || gateValue.value == null) {\n      Logger.logDebug(\n        `[spiffy-ai] isFeatureGateEnabled featureGate:${featureGate} value is undefined - returning false`\n      );\n      return false;\n    }\n    return gateValue.value;\n  };\n\n  isClientSessionEnabled = (): boolean => {\n    const isEnabled =\n      this.featureGates.filter(\n        (gate) =>\n          gate.name === FeatureGates.IsClientSessionEnabled &&\n          gate.value === true\n      ).length > 0;\n    return isEnabled;\n  };\n\n  getFeatureFlags = (): Record<string, boolean> => {\n    return Object.fromEntries(\n      Object.values(FeatureGates).map((featureGate: FeatureGates) => [\n        featureGate,\n        this.isFeatureGateEnabled(featureGate),\n      ])\n    );\n  };\n}\n\nexport interface FeatureFlagContextType {\n  featureFlagService: FeatureFlagService | undefined;\n}\n\nconst FeatureFlagServiceContext = createContext<\n  FeatureFlagContextType | undefined\n>(undefined);\n\ninterface FeatureFlagServiceProviderProps {\n  featureGates: OrgConfigFeatureGate[];\n  children: ReactNode;\n}\n\nexport const FeatureFlagServiceProvider: React.FC<\n  FeatureFlagServiceProviderProps\n> = ({ featureGates, children }) => {\n  const featureFlagService = useMemo(\n    () => new FeatureFlagService(featureGates),\n    [featureGates]\n  );\n\n  return (\n    <FeatureFlagServiceContext.Provider value={{ featureFlagService }}>\n      {children}\n    </FeatureFlagServiceContext.Provider>\n  );\n};\n\nexport const useFeatureFlagService = () => {\n  const context = useContext(FeatureFlagServiceContext);\n  if (context === undefined) {\n    throw new Error(\n      \"useFeatureFlagService must be used within a FeatureFlagServiceProvider\"\n    );\n  }\n  return context;\n};\n","import React, {\n  createContext,\n  useContext,\n  ReactNode,\n  useState,\n  useEffect,\n  useMemo,\n} from \"react\";\nimport { useAtomValue, useSetAtom } from \"jotai\";\nimport {\n  BasicOrgInfoType,\n  getOrgInfo,\n} from \"src/application/models/supportedOrgs\";\nimport { useColorsAndFrontendConfig } from \"src/hooks/useGraphQLConfig\";\nimport { orgShortNameAtom } from \"src/atoms/envive/enviveConfig\";\nimport { getAtomStore } from \"src/atoms/atomStore/atomStore\"; // Import getAtomStore\nimport { orgIdAtom } from \"src/atoms/org/graphqlConfig\"; // Import new atoms\nimport { newOrgConfigAtom } from \"src/atoms/org/newOrgConfigAtom\"; // Import newOrgConfigAtom\nimport { OrgConfigFeatureGate } from \"src/application/models/api/orgConfigResults\"; // Import OrgConfigFeatureGate\nimport { FeatureFlagServiceProvider } from \"src/contexts/featureFlagServiceContext\"; // Import FeatureFlagServiceProvider\nimport { ColorsConfigResponse, FrontendConfigResponse } from \"./graphqlContext\";\n\nexport interface NewOrgConfigContextType {\n  combinedConfig?:\n    | (BasicOrgInfoType & {\n        colorsConfig?: ColorsConfigResponse;\n        frontendConfig?: FrontendConfigResponse;\n      })\n    | null;\n  loading: boolean;\n  error: Error | null;\n}\n\nconst NewOrgConfigContext = createContext<NewOrgConfigContextType | undefined>(\n  undefined\n);\n\ninterface NewOrgConfigProviderProps {\n  children: ReactNode;\n}\n\nexport const NewOrgConfigProvider: React.FC<NewOrgConfigProviderProps> = ({\n  children,\n}) => {\n  const [oldConfig, setOldConfig] = useState<BasicOrgInfoType | undefined>();\n  const orgShortName = useAtomValue(orgShortNameAtom);\n  const setNewOrgConfig = useSetAtom(newOrgConfigAtom);\n\n  const { data: newConfig, loading, error } = useColorsAndFrontendConfig();\n\n  useEffect(() => {\n    if (orgShortName) {\n      getOrgInfo(orgShortName).then(setOldConfig);\n    }\n  }, [orgShortName]);\n\n  const combinedConfig = useMemo(() => {\n    if (!oldConfig || !newConfig) return null;\n    return { ...oldConfig, ...newConfig };\n  }, [oldConfig, newConfig]);\n\n  useEffect(() => {\n    const atomStore = getAtomStore();\n    if (combinedConfig) {\n      // TODO: Replace with actual orgId when available in combinedConfig\n      atomStore.set(orgIdAtom, \"mock-org-id\");\n\n      setNewOrgConfig(combinedConfig);\n    }\n  }, [combinedConfig, setNewOrgConfig]);\n\n  const contextValue = useMemo(() => {\n    if (!orgShortName || (loading && !oldConfig)) {\n      return { combinedConfig: null, loading: true, error: null };\n    }\n\n    if (error) {\n      return { combinedConfig: null, loading: false, error };\n    }\n\n    return { combinedConfig, loading: false, error: null };\n  }, [orgShortName, loading, error, oldConfig, combinedConfig]);\n\n  // TODO: Provide actual featureGates when available in combinedConfig\n  const featureGates: OrgConfigFeatureGate[] = [];\n\n  return (\n    <NewOrgConfigContext.Provider value={contextValue}>\n      <FeatureFlagServiceProvider featureGates={featureGates}>\n        {children}\n      </FeatureFlagServiceProvider>\n    </NewOrgConfigContext.Provider>\n  );\n};\n\nexport const useNewOrgConfigContext = () => {\n  const context = useContext(NewOrgConfigContext);\n  if (context === undefined) {\n    throw new Error(\n      \"useNewOrgConfigContext must be used within a NewOrgConfigProvider\"\n    );\n  }\n  return context;\n};\n","import { useNewOrgConfigContext } from \"src/contexts/newOrgConfigContext\";\n\nexport const useNewOrgConfig = () => {\n  const { combinedConfig, loading, error } = useNewOrgConfigContext();\n\n  return { ...combinedConfig, loading, error };\n};\n","import {\n  PLPAttributeCategory,\n  UserEventCategory,\n} from \"@spiffy-ai/commerce-api-client\";\nimport { SearchResult } from \"src/application/models/api/search\";\nimport { UserEvent, VariantInfo } from \"src/application/models\";\nimport { v4 as uuid } from \"uuid\";\n\nexport const isElementPartiallyVisible = (el?: HTMLDivElement | null) => {\n  if (!el) return false;\n\n  const rect = el.getBoundingClientRect();\n  const windowHeight =\n    window.innerHeight || document.documentElement.clientHeight;\n  const windowWidth = window.innerWidth || document.documentElement.clientWidth;\n  const verticallyVisible =\n    Math.round(rect.top) < windowHeight && Math.round(rect.bottom) > 0;\n  const horizontallyVisible =\n    Math.round(rect.left) < windowWidth && Math.round(rect.right) > 0;\n  return verticallyVisible && horizontallyVisible;\n};\n\nexport const createAppLoadedEvent = (): UserEvent => ({\n  eventId: uuid(),\n  createdAt: new Date().toISOString(),\n  category: UserEventCategory.AppLoaded,\n});\n\nexport const createVisitUserEvent = ({\n  variantInfo,\n}: {\n  variantInfo: VariantInfo;\n}): UserEvent | undefined => {\n  // this is a pdp visit event\n  if (variantInfo.variant === \"pdp\" && variantInfo.productId != null) {\n    return {\n      eventId: uuid(),\n      createdAt: new Date().toISOString(),\n      category: UserEventCategory.PdpVisit,\n      attributes: {\n        productId: variantInfo.productId,\n        parentProductId: variantInfo.parentProductId ?? \"\",\n        url: variantInfo.url ?? \"\",\n      },\n    };\n  }\n\n  // this is a plp visit event\n  if (variantInfo.variant === \"plp\" && variantInfo.plpId != null) {\n    return {\n      eventId: uuid(),\n      createdAt: new Date().toISOString(),\n      category: UserEventCategory.PlpVisit,\n      attributes: {\n        category: PLPAttributeCategory.Id,\n        attributes: {\n          id: variantInfo.plpId,\n        },\n      },\n    };\n  }\n\n  if (variantInfo.variant === \"page_visit\") {\n    return {\n      eventId: uuid(),\n      createdAt: new Date().toISOString(),\n      category: UserEventCategory.PageVisit,\n      attributes: {\n        url: variantInfo.url,\n        pageVisitCategory: variantInfo.pageVisitCategory,\n      },\n    };\n  }\n  return undefined;\n};\n\nconst parseTime = (time: string, timeZone: string) => {\n  const times = time.match(/^([0-1]?\\d):([0-5]\\d)(AM|PM)$/i);\n  const hours = times?.[1];\n  const minutes = times?.[2];\n  const period = times?.[3];\n\n  if (hours && minutes && period) {\n    const date = new Date();\n\n    // Adjust hours for AM/PM\n    let adjustedHours = 0;\n    if (period.toUpperCase() === \"PM\" && hours !== \"12\") {\n      adjustedHours = parseInt(hours) + 12;\n    }\n\n    if (period.toUpperCase() === \"AM\" && hours !== \"12\") {\n      adjustedHours = parseInt(hours);\n    }\n\n    // Create the date string with time zone\n    const formattedDate = `${date.toISOString().split(\"T\")[0]}T${String(\n      adjustedHours\n    ).padStart(2, \"0\")}:${minutes}:00`;\n    return new Date(`${formattedDate}${timeZone}`);\n  }\n};\n\nexport const isWithinBusinessHours = (\n  startTime: string,\n  endTime: string,\n  timeZone: string\n) => {\n  // Parse start and end times\n  const start = parseTime(startTime, timeZone);\n  let end = parseTime(endTime, timeZone);\n\n  if (!start || !end) {\n    return false;\n  }\n\n  let now = new Date();\n\n  // If the end date is greater than the start date, add a day to both of them\n  // This handles configurations such as startTime = 10:00PM and endTime = 7:00AM\n  if (end < start) {\n    end = new Date(end.getTime() + 24 * 60 * 60 * 1000);\n    now = new Date(now.getTime() + 24 * 60 * 60 * 1000);\n  }\n\n  // If the date conversion shifts the end date to the next day, consider comparing it across midnight\n  if (end.getUTCDate() > start.getUTCDate()) {\n    const crossingMidnight = new Date(now.getTime() + 24 * 60 * 60 * 1000);\n    return start <= now || crossingMidnight <= end;\n  }\n\n  // Check if the current time falls between start and end\n  return now >= start && now <= end;\n};\n\nexport enum SearchResultsState {\n  Loading,\n  Results,\n  NoResults,\n}\n\nexport const getSearchResultsState = (\n  isLoadingSearch: boolean,\n  searchData: SearchResult | null\n): SearchResultsState => {\n  if (isLoadingSearch) {\n    return SearchResultsState.Loading;\n  }\n  if (searchData) {\n    return SearchResultsState.Results;\n  }\n  return SearchResultsState.NoResults;\n};\n","import { useAtom, useAtomValue, useSetAtom } from \"jotai\";\nimport { useCallback, useEffect, useMemo, useRef, useState } from \"react\";\nimport { useDebounce } from \"src/hooks/useDebounce\";\nimport { useNewOrgConfig, useTrackComponentVisibleEvent } from \"src/hooks\";\nimport {\n  addSearchFilterAtom,\n  clearSearchFiltersAtom,\n  createFilterOption,\n  filteredSearchProductsAtom,\n  performSearchAtom,\n  removeSearchFilterAtom,\n  searchAtom,\n  searchFiltersAtom,\n  searchParamsAtom,\n  searchProductSortingAtom,\n  searchSelectedFiltersAtom,\n  SelectedFilterOption,\n} from \"src/atoms/search\";\nimport {\n  autocompleteStateAtom,\n  isFilterOpenAtom,\n} from \"src/atoms/globalSearch/globalSearch\";\nimport { formatFilterDisplayName } from \"src/atoms/search/utils\";\nimport { ProductSorting } from \"src/atoms/search/types\";\nimport {\n  SpiffyMetricsEventName,\n  useAmplitude,\n} from \"src/contexts/amplitudeContext\";\nimport { SpiffyWidgets } from \"src/application/models/spiffyWidgets\";\nimport { ProductCardConfig } from \"src/contexts/types\";\nimport Logger from \"src/application/logging/logger\";\nimport { SearchResult } from \"src/application/models/api/search\";\nimport { SearchResponseProduct } from \"@spiffy-ai/commerce-api-client\";\nimport {\n  SearchFilterDatum,\n  SelectFilterItem,\n} from \"src/types/search-filter-types\";\nimport { getSearchResultsState, SearchResultsState } from \"./utils\";\nimport { orgShortNameAtom } from \"src/atoms/envive/enviveConfig\";\n\nexport interface SearchResultsHocProps {\n  // Data\n  searchData: SearchResult | null;\n  searchResponseId: string;\n  merchantShortName: string;\n  productCardConfig: ProductCardConfig;\n  productList: SearchResponseProduct[];\n  autocompleteResults: string[];\n  searchFilters: SearchFilterDatum[];\n  availableDynamicFilters: { name: string; displayName: string }[];\n  selectedFilterOptions: SelectedFilterOption[];\n\n  // State\n  searchText: string;\n  searchResultsState: SearchResultsState;\n  isLoadingAutocomplete: boolean;\n  isLoadingSearch: boolean;\n  isFilterOpen: boolean;\n  isDirty: boolean;\n  focusedIndex: number;\n  focusedOptionId: string | undefined;\n\n  // UI\n  filterButtonText: string;\n\n  // Event Handlers\n  onSearchInputChange: (value: string) => void;\n  onSubmitSearch: () => void;\n  onAutocompleteSelect: (suggestion: string) => void;\n  onKeyDown: (event: React.KeyboardEvent<HTMLInputElement>) => void;\n  onToggleDynamicFilter: ({\n    filter,\n    dynamicFilterDisplayName,\n  }: {\n    filter: string;\n    dynamicFilterDisplayName: string;\n  }) => void;\n  onSelectFilterItem: SelectFilterItem;\n  onRemoveFilter: (filter: SelectedFilterOption) => void;\n  onClearAllFilters: () => void;\n  setIsFilterOpen: (isFilterOpen: boolean) => void;\n\n  // Refs\n  searchResultsRef: React.RefObject<HTMLDivElement>;\n}\n\nexport const useSearch = (): SearchResultsHocProps => {\n  // Atoms\n  const config = useNewOrgConfig();\n  const orgShortName = useAtomValue(orgShortNameAtom);\n  const { data: searchData, loading: isLoadingSearch } =\n    useAtomValue(searchAtom);\n  const productList = useAtomValue(filteredSearchProductsAtom);\n  const performSearch = useSetAtom(performSearchAtom);\n  const [\n    { results: autocompleteResults, isLoading: isLoadingAutocomplete },\n    setAutocompleteState,\n  ] = useAtom(autocompleteStateAtom);\n  const [{ query }] = useAtom(searchParamsAtom);\n  const [isFilterOpen, setIsFilterOpen] = useAtom(isFilterOpenAtom);\n  const [selectedFilterOptions] = useAtom(searchSelectedFiltersAtom);\n  const addFilter = useSetAtom(addSearchFilterAtom);\n  const removeFilter = useSetAtom(removeSearchFilterAtom);\n  const [productSorting, setProductSorting] = useAtom(searchProductSortingAtom);\n  const clearFilters = useSetAtom(clearSearchFiltersAtom);\n  const searchFilters = useAtomValue(searchFiltersAtom);\n\n  // State\n  const [isDirty, setIsDirty] = useState(true);\n  const [focusedIndex, setFocusedIndex] = useState(-1);\n  const [focusedOptionId, setFocusedOptionId] = useState<string | undefined>(\n    undefined\n  );\n  const [searchText, setSearchText] = useState(query || \"\");\n\n  // Refs\n  const searchResultsRef = useRef<HTMLDivElement>(null);\n\n  // Derived State\n  const debouncedSearchText = useDebounce(searchText, 200);\n  const searchResultsState = getSearchResultsState(isLoadingSearch, searchData);\n\n  const dynamicFilters = searchData?.filters || [];\n\n  // Provide fallback values when orgUIConfig is not yet available\n  const safeProductCardConfig = config?.frontendConfig?.uiConfigs\n    ?.productCardConfig || {\n    variant: \"minimal\",\n    hoverVariant: \"none\",\n    layoutVariant: \"square\",\n  };\n  const safeMerchantShortName = orgShortName || \"\";\n\n  const availableDynamicFilters = useMemo(() => {\n    return dynamicFilters\n      .filter(\n        (dynamicFilterName) =>\n          !selectedFilterOptions.some(\n            (option) => option.id === `dynamic:${dynamicFilterName}`\n          )\n      )\n      .map((dynamicFilterName) => ({\n        name: dynamicFilterName,\n        displayName: formatFilterDisplayName(dynamicFilterName),\n      }));\n  }, [dynamicFilters, selectedFilterOptions]);\n\n  const filters = useMemo(() => {\n    const sortOptions = [\n      {\n        filterItemId: String(ProductSorting.FEATURED),\n        displayName: \"Relevance\",\n        productCount: 0,\n        isSelected: productSorting === ProductSorting.FEATURED,\n      },\n      {\n        filterItemId: String(ProductSorting.PRICE_ASC),\n        displayName: \"Price: Low to High\",\n        productCount: 0,\n        isSelected: productSorting === ProductSorting.PRICE_ASC,\n      },\n      {\n        filterItemId: String(ProductSorting.PRICE_DESC),\n        displayName: \"Price: High to Low\",\n        productCount: 0,\n        isSelected: productSorting === ProductSorting.PRICE_DESC,\n      },\n    ];\n\n    return [\n      { filterId: \"sort\", displayName: \"SORT\", items: sortOptions },\n      ...searchFilters,\n    ] as SearchFilterDatum[];\n  }, [productSorting, searchFilters]);\n\n  const filterButtonText = useMemo(() => {\n    const selectedCount = filters.reduce((acc: number, filter) => {\n      if (filter.filterId === \"sort\") {\n        return acc;\n      }\n      return acc + filter.items.filter((item) => item.isSelected).length;\n    }, 0);\n    if (selectedCount === 0) {\n      return \"Filter & Sort\";\n    }\n    return `Filter & Sort (${selectedCount})`;\n  }, [filters]);\n\n  // Callbacks\n  const { trackEvent } = useAmplitude();\n\n  const handleToggleDynamicFilter = useCallback(\n    ({\n      filter,\n      dynamicFilterDisplayName,\n    }: {\n      filter: string;\n      dynamicFilterDisplayName: string;\n    }) => {\n      trackEvent({\n        eventName: SpiffyMetricsEventName.SearchFilterClicked,\n        eventProps: {\n          filterType: \"Dynamic\",\n          filterValue: filter,\n          queryText: searchText,\n        },\n      });\n      addFilter(\n        createFilterOption(\"dynamic\", filter, dynamicFilterDisplayName)\n      );\n    },\n    [addFilter, searchText, trackEvent]\n  );\n\n  const handleRemoveFilter = useCallback(\n    (filter: SelectedFilterOption) => {\n      removeFilter(filter.id);\n    },\n    [removeFilter]\n  );\n\n  const handleSubmitSearch = useCallback(async () => {\n    if (searchText.trim()) {\n      trackEvent({\n        eventName: SpiffyMetricsEventName.SearchQuerySubmitted,\n        eventProps: {\n          searchOrigin: SpiffyWidgets.SearchResults,\n          queryText: searchText.trim(),\n        },\n        alsoSendToGoogleAnalytics: true,\n      });\n      const url = new URL(window.location.href);\n      url.searchParams.set(\"esq\", searchText.trim());\n      window.history.pushState({}, \"\", url);\n      performSearch({ query: searchText.trim() });\n    }\n  }, [performSearch, searchText, trackEvent]);\n\n  const handleAutocompleteSelect = useCallback(\n    (suggestion: string) => {\n      setSearchText(suggestion);\n      handleSubmitSearch();\n    },\n    [handleSubmitSearch, setSearchText]\n  );\n\n  const handleKeyDown = useCallback(\n    (event: React.KeyboardEvent<HTMLInputElement>) => {\n      if (event.key === \"ArrowDown\") {\n        event.preventDefault();\n        const newIndex = (focusedIndex + 1) % autocompleteResults.length;\n        setFocusedIndex(newIndex);\n        setFocusedOptionId(`option-${newIndex}`);\n      } else if (event.key === \"ArrowUp\") {\n        event.preventDefault();\n        const newIndex =\n          (focusedIndex - 1 + autocompleteResults.length) %\n          autocompleteResults.length;\n        setFocusedIndex(newIndex);\n        setFocusedOptionId(`option-${newIndex}`);\n      } else if (event.key === \"Enter\") {\n        if (focusedIndex === -1) {\n          event.preventDefault();\n          handleSubmitSearch();\n        } else {\n          event.preventDefault();\n          const suggestionText = autocompleteResults[focusedIndex];\n          handleAutocompleteSelect(suggestionText);\n        }\n      } else if (event.key === \"Escape\") {\n        event.preventDefault();\n        setFocusedIndex(-1);\n        setFocusedOptionId(undefined);\n      }\n    },\n    [\n      autocompleteResults,\n      focusedIndex,\n      handleAutocompleteSelect,\n      handleSubmitSearch,\n    ]\n  );\n\n  const handleSearchInputChange = (newValue: string) => {\n    if (newValue.length === 1) {\n      trackEvent({\n        eventName: SpiffyMetricsEventName.SearchInputStarted,\n        eventProps: {\n          searchOrigin: SpiffyWidgets.SearchResults,\n        },\n      });\n    }\n    setSearchText(newValue);\n    setIsDirty(true);\n  };\n\n  const handleSelectFilterItem: SelectFilterItem = useCallback(\n    ({\n      filterId,\n      filterItemId,\n      isSelected,\n      displayName,\n    }: {\n      filterId: string;\n      filterItemId: string;\n      isSelected: boolean;\n      displayName: string;\n    }) => {\n      if (filterId === \"sort\") {\n        const newSort = filterItemId as ProductSorting;\n        trackEvent({\n          eventName: SpiffyMetricsEventName.SearchSortClicked,\n          eventProps: {\n            sortType: newSort,\n            queryText: searchText,\n          },\n        });\n        setProductSorting(newSort);\n      } else if (!isSelected) {\n        removeFilter(`${filterId}:${filterItemId}`);\n      } else {\n        trackEvent({\n          eventName: SpiffyMetricsEventName.SearchFilterClicked,\n          eventProps: {\n            filterType: \"Static\",\n            filterCategory: filterId,\n            filterValue: filterItemId,\n            queryText: searchText,\n          },\n        });\n        addFilter(createFilterOption(filterId, filterItemId, displayName));\n      }\n    },\n    [addFilter, removeFilter, setProductSorting, searchText, trackEvent]\n  );\n\n  const handleClearAllFilters = useCallback(() => {\n    setProductSorting(ProductSorting.FEATURED);\n    clearFilters();\n  }, [setProductSorting, clearFilters]);\n\n  // Side Effects\n  useTrackComponentVisibleEvent(\n    SpiffyWidgets.SearchResults,\n    searchResultsRef,\n    {},\n    SpiffyMetricsEventName.SearchComponentVisible\n  );\n\n  useEffect(() => {\n    if (productList.length > 0) {\n      trackEvent({\n        eventName: SpiffyMetricsEventName.SearchResultsViewed,\n        eventProps: {\n          queryText: searchText,\n          resultsCount: productList.length,\n        },\n      });\n    }\n  }, [productList.length, searchText, trackEvent]);\n\n  useEffect(() => {\n    if (query && query !== searchText) {\n      setSearchText(query);\n    }\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [query]);\n\n  useEffect(() => {\n    const esq = new URLSearchParams(window.location.search).get(\"esq\");\n    if (esq) {\n      setSearchText(esq);\n      performSearch({ query: esq });\n    }\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [performSearch]);\n\n  const fetchAutocompleteSuggestions = (_query: string) => {\n    // TODO: implement autocomplete suggestions\n    return Promise.resolve([]);\n  };\n\n  useEffect(() => {\n    if (fetchAutocompleteSuggestions === undefined) {\n      return;\n    }\n\n    if (!isDirty || debouncedSearchText.length <= 2) {\n      setAutocompleteState({ results: [], isLoading: false });\n      return;\n    }\n\n    setAutocompleteState((prev) => ({ ...prev, isLoading: true }));\n\n    const fetchData = async () => {\n      try {\n        const results = await fetchAutocompleteSuggestions?.(\n          debouncedSearchText\n        );\n        setAutocompleteState({ results: results ?? [], isLoading: false });\n      } catch (error) {\n        Logger.logError(\"Failed to fetch autocomplete suggestions:\", error);\n        setAutocompleteState({ results: [], isLoading: false });\n      }\n    };\n\n    fetchData();\n  }, [debouncedSearchText, isDirty, setAutocompleteState]);\n\n  return {\n    searchData,\n    searchResponseId: searchData?.searchResponseId ?? \"\",\n    merchantShortName: safeMerchantShortName,\n    productCardConfig: safeProductCardConfig,\n    productList,\n    autocompleteResults,\n    searchFilters: filters,\n    availableDynamicFilters,\n    selectedFilterOptions,\n    searchText,\n    searchResultsState,\n    isLoadingAutocomplete,\n    isLoadingSearch,\n    isFilterOpen,\n    isDirty,\n    focusedIndex,\n    focusedOptionId,\n    filterButtonText,\n    onSearchInputChange: handleSearchInputChange,\n    onSubmitSearch: handleSubmitSearch,\n    onAutocompleteSelect: handleAutocompleteSelect,\n    onKeyDown: handleKeyDown,\n    onToggleDynamicFilter: handleToggleDynamicFilter,\n    onSelectFilterItem: handleSelectFilterItem,\n    onRemoveFilter: handleRemoveFilter,\n    onClearAllFilters: handleClearAllFilters,\n    setIsFilterOpen,\n    searchResultsRef,\n  };\n};\n","import { useAtomValue } from \"jotai\";\nimport {\n  ContextEnvEnum,\n  ContextSourceEnum,\n} from \"@spiffy-ai/commerce-api-client\";\nimport { VariantInfo } from \"src/application/models\";\nimport { UserIdentityContextType } from \"src/contexts/userIdentityContext\";\nimport { variantInfoAtom } from \"src/atoms/app/variant\";\nimport {\n  contextSourceAtom,\n  envAtom as enviveEnvAtom,\n  orgShortNameAtom as enviveOrgShortNameAtom,\n} from \"src/atoms/envive/enviveConfig\";\nimport { chatIdAtom, userIdAtom } from \"src/atoms/app/index\";\nimport { useNewOrgConfigContext } from \"src/contexts/newOrgConfigContext\";\nimport { useOrgId } from \"src/hooks/useGraphQLConfig\"; // Import useOrgId\n\nexport interface AppDetails {\n  orgId: string;\n  orgShortName: string;\n  chatId: string;\n  userId: string;\n  source: ContextSourceEnum;\n  env: ContextEnvEnum;\n  variantInfo: VariantInfo;\n}\n\nexport const useAppDetails = (): AppDetails => {\n  const { orgId: fetchedOrgId } = useOrgId(); // Get orgId from useOrgId hook\n  const orgId = fetchedOrgId ?? \"\"; // Provide a default empty string if undefined\n\n  const orgShortName = useAtomValue(enviveOrgShortNameAtom) ?? \"spiffy-ai\";\n  const chatId = useAtomValue(chatIdAtom);\n  const userId = useAtomValue(userIdAtom);\n  const source = useAtomValue(contextSourceAtom) ?? ContextSourceEnum.App;\n  const env =\n    (useAtomValue(enviveEnvAtom) as ContextEnvEnum) ?? ContextEnvEnum.Dev; // Cast to ContextEnvEnum\n  const variantInfo = useAtomValue(variantInfoAtom);\n\n  return {\n    orgId,\n    orgShortName,\n    chatId,\n    userId,\n    source,\n    env,\n    variantInfo,\n  };\n};\n","import React, {\n  createContext,\n  useContext,\n  useCallback,\n  useMemo,\n  useEffect,\n} from \"react\";\nimport { useAtomValue } from \"jotai\";\nimport {\n  Configuration,\n  ResponseCategory,\n  ResponseError,\n  SearchApi,\n} from \"@spiffy-ai/commerce-api-client\";\nimport { baseUrlAtom } from \"src/atoms/envive/enviveConfig\";\nimport Logger from \"src/application/logging/logger\";\nimport { useAppDetails } from \"src/hooks/useAppDetails\";\nimport { useEnviveConfig } from \"src/contexts/enviveConfigContext\";\nimport { SessionRestartRequired } from \"src/types/exceptions/sessionExceptions\";\nimport { UnsupportedProductException } from \"src/types/exceptions/unsupportedProductExceptions\";\nimport { SearchResult, SearchParams } from \"../application/models/api/search\";\nimport {\n  setSearchServiceFunction,\n  clearSearchServiceFunction,\n} from \"../atoms/search/searchServiceAdapter\";\n\nconst transformProductResponses = (products: SearchResult[\"products\"]) =>\n  products.map((data) => ({\n    id: data.id,\n    responseId: data.response_id,\n    category: ResponseCategory.Product,\n    description: data.description,\n    imageUrl: data.image_url,\n    imageUrls: data.image_urls,\n    title: data.title,\n    url: data.url,\n    originalPrice: data.original_price,\n    salePrice: data.sale_price,\n    averageRating: data.average_rating,\n    numberReviews: data.number_reviews,\n    metadata: data.metadata,\n    isForGrid: data.is_for_grid,\n    colors: data.colors,\n    sizes: data.sizes,\n    filters: data.filters,\n  }));\n\nasync function errorResponseBody(error: ResponseError) {\n  try {\n    return await error.response.json();\n  } catch {\n    return {};\n  }\n}\n\nasync function throwSessionRestartRequiredIf(errorMsg: string, error: unknown) {\n  if (!(error instanceof ResponseError)) {\n    Logger.logInfo(errorMsg, error);\n    throw error;\n  }\n\n  const errorResponse = await errorResponseBody(error);\n  if (\n    errorResponse?.message?.toLowerCase() === \"unsupported product\" ||\n    errorResponse?.app_code?.toUpperCase() === \"PRODUCT_NOT_FOUND\"\n  ) {\n    throw new UnsupportedProductException();\n  } else if (\n    errorResponse?.app_code?.toUpperCase() === \"RESTART_SESSION\" ||\n    errorResponse?.sub_code?.toUpperCase() === \"NOT_FOUND\"\n  ) {\n    Logger.logInfo(\n      \"Session does not exist. Re-start session\",\n      error,\n      error.response,\n      errorResponse\n    );\n    throw new SessionRestartRequired();\n  }\n\n  Logger.logInfo(errorMsg, error);\n  throw error;\n}\n\ninterface SearchContextValue {\n  searchProducts: (params: SearchParams) => Promise<SearchResult>;\n  isReady: boolean;\n}\n\nconst SearchContext = createContext<SearchContextValue | undefined>(undefined);\n\nexport const SearchProvider: React.FC<{ children: React.ReactNode }> = ({\n  children,\n}) => {\n  const { orgLevelApiKey, publicKey } = useEnviveConfig();\n  const apiKey = orgLevelApiKey || publicKey; // Replicate apiKeyAtom logic\n  const appDetails = useAppDetails();\n  const baseUrl = useAtomValue(baseUrlAtom);\n\n  const isReady = Boolean(apiKey && appDetails && baseUrl);\n\n  const searchApi = useMemo(() => {\n    if (!isReady) return null;\n\n    const config: Configuration = new Configuration({\n      accessToken: apiKey,\n      basePath: baseUrl,\n      headers: {\n        \"Content-Type\": \"application/json\",\n        Accept: \"application/json\",\n      },\n    });\n    return new SearchApi(config);\n  }, [apiKey, baseUrl, isReady]);\n\n  const searchProducts = useCallback(\n    async (params: SearchParams): Promise<SearchResult> => {\n      if (!isReady || !searchApi) {\n        throw new Error(\"SearchService not ready - missing dependencies\");\n      }\n\n      try {\n        const response = await searchApi.v1SearchQueryGet({\n          query: params.query,\n          limit: params.limit,\n          org_id: appDetails.orgId,\n          user_id: appDetails.userId,\n        });\n        const {\n          products,\n          filters,\n          search_response_id: searchResponseId,\n        } = response;\n\n        return {\n          products: transformProductResponses(products) || [],\n          filters: filters || [],\n          totalProductCount: products?.length || 0,\n          searchResponseId: searchResponseId || \"\",\n        };\n      } catch (error) {\n        await throwSessionRestartRequiredIf(\"Failed to search products\", error);\n        // This part will not be reached if an exception is thrown, but it's required for type safety\n        return {\n          products: [],\n          filters: [],\n          totalProductCount: 0,\n          searchResponseId: \"\",\n        };\n      }\n    },\n    [searchApi, isReady, appDetails]\n  );\n\n  // Register the search function with the adapter for use in atoms\n  useEffect(() => {\n    if (isReady) {\n      setSearchServiceFunction(searchProducts);\n    } else {\n      clearSearchServiceFunction();\n    }\n\n    return () => {\n      clearSearchServiceFunction();\n    };\n  }, [searchProducts, isReady]);\n\n  const value = useMemo(\n    () => ({\n      searchProducts,\n      isReady,\n    }),\n    [searchProducts, isReady]\n  );\n\n  return (\n    <SearchContext.Provider value={value}>{children}</SearchContext.Provider>\n  );\n};\n\nexport const useSearchService = () => {\n  const context = useContext(SearchContext);\n  if (!context) {\n    throw new Error(\"useSearchService must be used within a SearchProvider\");\n  }\n  return context;\n};\n","import { useState, useCallback, useEffect } from \"react\";\nimport { useSearchService } from \"src/contexts/searchContext\";\nimport { SearchResult, SearchParams } from \"src/application/models/api/search\";\n\nexport const useProductSearch = () => {\n  const { searchProducts, isReady } = useSearchService();\n  const [data, setData] = useState<SearchResult | undefined>();\n  const [loading, setLoading] = useState(false);\n  const [error, setError] = useState<Error | null>(null);\n\n  const search = useCallback(\n    async (params: SearchParams) => {\n      if (!isReady) {\n        setError(new Error(\"Search service not ready - missing dependencies\"));\n        return;\n      }\n\n      setLoading(true);\n      setError(null);\n\n      try {\n        const result = await searchProducts(params);\n        setData(result);\n      } catch (err) {\n        setError(\n          err instanceof Error ? err : new Error(\"Unknown search error\")\n        );\n      } finally {\n        setLoading(false);\n      }\n    },\n    [searchProducts, isReady]\n  );\n\n  const reset = useCallback(() => {\n    setData(undefined);\n    setError(null);\n    setLoading(false);\n  }, []);\n\n  return {\n    data,\n    loading,\n    error,\n    search,\n    reset,\n    isReady,\n  };\n};\n\nexport const useSearchWithQuery = (params: SearchParams | null) => {\n  const { searchProducts, isReady } = useSearchService();\n  const [data, setData] = useState<SearchResult | undefined>();\n  const [loading, setLoading] = useState(false);\n  const [error, setError] = useState<Error | null>(null);\n\n  const executeSearch = useCallback(\n    async (searchParams: SearchParams) => {\n      if (!isReady) return;\n\n      setLoading(true);\n      setError(null);\n\n      try {\n        const result = await searchProducts(searchParams);\n        setData(result);\n      } catch (err) {\n        setError(\n          err instanceof Error ? err : new Error(\"Unknown search error\")\n        );\n      } finally {\n        setLoading(false);\n      }\n    },\n    [searchProducts, isReady]\n  );\n\n  useEffect(() => {\n    if (params && isReady) {\n      executeSearch(params);\n    }\n  }, [params, isReady, executeSearch]);\n\n  const refetch = useCallback(() => {\n    if (params) {\n      executeSearch(params);\n    }\n  }, [params, executeSearch]);\n\n  return {\n    data,\n    loading,\n    error,\n    refetch,\n    isReady,\n  };\n};\n","import React, {\n  createContext,\n  useContext,\n  useCallback,\n  useMemo,\n  useEffect,\n} from \"react\";\nimport Logger from \"../application/logging/logger\";\n\ninterface SessionStorageContextType {\n  setItem: (key: string, value: string) => void;\n  getItem: (key: string) => string | null;\n  isAvailable: boolean;\n}\n\nconst SessionStorageContext = createContext<SessionStorageContextType | null>(\n  null\n);\n\nexport const SessionStorageProvider: React.FC<{\n  children: React.ReactNode;\n}> = ({ children }) => {\n  const isAvailable = useMemo(() => {\n    try {\n      return typeof window !== \"undefined\" && !!window.sessionStorage;\n    } catch {\n      return false;\n    }\n  }, []);\n\n  useEffect(() => {\n    if (!isAvailable) {\n      Logger.logError(\"sessionStorage is not available\", undefined);\n    }\n  }, [isAvailable]);\n\n  const setItem = useCallback(\n    (key: string, value: string) => {\n      if (!isAvailable) return;\n      sessionStorage.setItem(key, value);\n      window.dispatchEvent(\n        new StorageEvent(\"storage\", { key, newValue: value })\n      );\n    },\n    [isAvailable]\n  );\n\n  const getItem = useCallback(\n    (key: string) => {\n      if (!isAvailable) return null;\n      return sessionStorage.getItem(key);\n    },\n    [isAvailable]\n  );\n\n  const value = useMemo(\n    () => ({\n      setItem,\n      getItem,\n      isAvailable,\n    }),\n    [setItem, getItem, isAvailable]\n  );\n\n  return (\n    <SessionStorageContext.Provider value={value}>\n      {children}\n    </SessionStorageContext.Provider>\n  );\n};\n\nexport const useSessionStorage = () => {\n  const context = useContext(SessionStorageContext);\n  if (!context) {\n    throw new Error(\n      \"useSessionStorage must be used within a SessionStorageProvider\"\n    );\n  }\n  return context;\n};\n","import { useState, useEffect, useCallback } from \"react\";\nimport { useSessionStorage } from \"../contexts/sessionStorageContext\";\n\nexport const useSessionStorageValue = (key: string) => {\n  const { getItem, setItem } = useSessionStorage();\n  const [value, setValue] = useState<string | null>(() => getItem(key));\n\n  useEffect(() => {\n    const handleStorageChange = (event: StorageEvent) => {\n      if (event.key === key) {\n        setValue(event.newValue);\n      }\n    };\n\n    window.addEventListener(\"storage\", handleStorageChange);\n    return () => window.removeEventListener(\"storage\", handleStorageChange);\n  }, [key, getItem]);\n\n  const updateValue = useCallback(\n    (newValue: string) => {\n      setItem(key, newValue);\n      setValue(newValue);\n    },\n    [key, setItem]\n  );\n\n  return { value, setValue: updateValue };\n};\n","import React, { createContext, useCallback, useContext, useMemo } from \"react\";\nimport { IdExtractor } from \"src/contexts/types\";\nimport { parseHref } from \"src/application/utils/urlsParser\";\n\ninterface ShopifyUrlContextType {\n  getTrimmedPathName: () => string | null;\n  getPlpOrPdpId: (extractor: IdExtractor) => string | null;\n  isOnPdpPage: () => boolean;\n  isOnPlpPage: () => boolean;\n  isReady: boolean;\n}\n\nconst ShopifyUrlContext = createContext<ShopifyUrlContextType | undefined>(\n  undefined\n);\n\nexport const ShopifyUrlProvider: React.FC<{ children: React.ReactNode }> = ({\n  children,\n}) => {\n  const isReady = true; // No external dependencies, so always ready\n\n  const getTrimmedPathName = useCallback((): string | null => {\n    let { pathname } = window.location;\n    // strip out the proxy path so local dev still works\n    pathname = pathname.replace(\"/proxy\", \"\");\n    // remove trailing hash if it exists\n    pathname = pathname.replace(/#.*$/, \"\");\n    // remove trailing /, ie. some URLs can end with '/' like /collections/cast-iron/\n    pathname = pathname.replace(/\\/$/, \"\");\n\n    if (pathname === undefined || pathname === null || pathname.length === 0) {\n      return null;\n    }\n\n    return pathname;\n  }, []);\n\n  const getPlpOrPdpId = useCallback(\n    (extractor: IdExtractor): string | null => {\n      if (extractor === \"shopify-product-variant-id\") {\n        const parsedHref = parseHref(window.location.href);\n        const variantId = parsedHref?.urlSearchParams?.get(\"variant\");\n        if (!variantId) {\n          return getPlpOrPdpId(\"shopify-product-id\");\n        }\n        return variantId;\n      }\n\n      const pathSegment =\n        extractor === \"shopify-product-id\" ? \"products\" : \"collections\";\n      const tokens = getTrimmedPathName()?.split(\"/\");\n      const idIndex = tokens?.findIndex((token) => token === pathSegment);\n      if (idIndex !== undefined && idIndex >= 0 && tokens) {\n        return decodeURIComponent(tokens[idIndex + 1]);\n      }\n      return null;\n    },\n    [getTrimmedPathName]\n  );\n\n  const isOnPdpPage = useCallback((): boolean => {\n    return getTrimmedPathName()?.includes(\"/products\") ?? false;\n  }, [getTrimmedPathName]);\n\n  const isOnPlpPage = useCallback((): boolean => {\n    return (\n      (getTrimmedPathName()?.includes(\"/collections\") &&\n        !getTrimmedPathName()?.includes(\"/products\")) ??\n      false\n    );\n  }, [getTrimmedPathName]);\n\n  const value = useMemo(\n    () => ({\n      getTrimmedPathName,\n      getPlpOrPdpId,\n      isOnPdpPage,\n      isOnPlpPage,\n      isReady,\n    }),\n    [getTrimmedPathName, getPlpOrPdpId, isOnPdpPage, isOnPlpPage, isReady]\n  );\n\n  return (\n    <ShopifyUrlContext.Provider value={value}>\n      {children}\n    </ShopifyUrlContext.Provider>\n  );\n};\n\nexport const useShopifyUrl = () => {\n  const context = useContext(ShopifyUrlContext);\n  if (!context) {\n    throw new Error(\"useShopifyUrl must be used within a ShopifyUrlProvider\");\n  }\n  return context;\n};\n","import { useCallback } from \"react\";\nimport { useShopifyUrl } from \"src/contexts/shopifyUrlContext\";\nimport { IdExtractor } from \"src/contexts/types\";\n\nexport const useShopifyUrlOperations = () => {\n  const {\n    getTrimmedPathName,\n    getPlpOrPdpId,\n    isOnPdpPage,\n    isOnPlpPage,\n    isReady,\n  } = useShopifyUrl();\n\n  return {\n    getTrimmedPathName,\n    getPlpOrPdpId,\n    isOnPdpPage,\n    isOnPlpPage,\n    isReady,\n  };\n};\n\nexport const useCurrentPageType = () => {\n  const { isOnPdpPage, isOnPlpPage, isReady } = useShopifyUrl();\n\n  const getPageType = useCallback(() => {\n    if (!isReady) return \"unknown\";\n    if (isOnPdpPage()) return \"pdp\";\n    if (isOnPlpPage()) return \"plp\";\n    return \"other\";\n  }, [isReady, isOnPdpPage, isOnPlpPage]);\n\n  return { getPageType, isReady };\n};\n\nexport const useProductId = (extractor: IdExtractor) => {\n  const { getPlpOrPdpId, isReady } = useShopifyUrl();\n\n  const productId = useCallback(() => {\n    if (!isReady) return null;\n    return getPlpOrPdpId(extractor);\n  }, [isReady, getPlpOrPdpId, extractor]);\n\n  return { productId, isReady };\n};\n","import { useMemo } from 'react';\n\nexport type Unit = 'percent' | 'pixel';\n\nexport const useSnapCalculator = (snaps: number[], maxHeight: number, unit: Unit) => {\n  const viewportHeightPx = document.documentElement.clientHeight;\n  const swipeviewHeightPx =\n    unit === 'percent' ? Math.floor(viewportHeightPx * (maxHeight / 100)) : maxHeight;\n\n  const snapsToPixels = useMemo(\n    () =>\n      snaps?.map((snap) =>\n        Math.abs(\n          (unit === 'percent' ? Math.floor(swipeviewHeightPx * (snap / 100)) : snap) -\n            swipeviewHeightPx,\n        ),\n      ),\n    [viewportHeightPx],\n  );\n\n  const getPixelToSnap = (pixels: number) => {\n    const snapIdx = snapsToPixels?.indexOf(pixels) || 0;\n    return snaps?.[snapIdx] || 0;\n  };\n\n  const getSnapToPixel = (snap: number) => {\n    const snapIdx = snaps?.indexOf(snap) || 0;\n    return snapsToPixels?.[snapIdx] || 0;\n  };\n\n  return {\n    viewportHeightPx,\n    snapsToPixels,\n    swipeviewHeightPx,\n    getPixelToSnap,\n    getSnapToPixel,\n  };\n};\n","import { useContext } from 'react';\nimport { SystemSettingsContext } from 'src/contexts';\n\nexport const useSystemSettingsContext = () => {\n  const context = useContext(SystemSettingsContext);\n\n  if (!context) {\n    throw new Error('useSystemSettingsContext must be used within a SystemSettingsContextProvider');\n  }\n\n  return { ...context };\n};\n","import { RefObject, useEffect, useRef } from \"react\";\nimport { SpiffyWidgets } from \"src/application/models/spiffyWidgets\";\nimport { useIntersection } from \"src/hooks/useIntersection\";\nimport {\n  SpiffyMetricsEventName,\n  useAmplitude,\n} from \"src/contexts/amplitudeContext\";\n\n/**\n * Tracks a component and logs an event to Amplitude when the component is visible.\n *\n * @param component - The component to track.\n * @param element - The element to track visibility of.\n * @param eventProps - Additional properties to include with the event.\n * @param eventName - The Amplitude event name to track (defaults to ChatComponentVisible).\n */\nexport const useTrackComponentVisibleEvent = (\n  component: SpiffyWidgets,\n  element: RefObject<HTMLElement>,\n  eventProps?: Record<string, unknown>,\n  eventName: SpiffyMetricsEventName = SpiffyMetricsEventName.ChatComponentVisible\n) => {\n  const isVisible = useIntersection(element, \"0px\");\n  const hasTrackedEvent = useRef(false);\n  const { trackEvent } = useAmplitude();\n\n  const componentProps = (() => {\n    if (eventName === SpiffyMetricsEventName.ChatComponentVisible) {\n      return {\n        chat_component: component,\n        ...eventProps,\n      };\n    }\n    if (eventName === SpiffyMetricsEventName.SearchComponentVisible) {\n      return {\n        search_component: component,\n        ...eventProps,\n      };\n    }\n    // Default case for other event types\n    return {\n      component: component,\n      ...eventProps,\n    };\n  })();\n\n  useEffect(() => {\n    if (isVisible && !hasTrackedEvent.current) {\n      trackEvent({\n        eventName: eventName,\n        eventProps: componentProps,\n      });\n      hasTrackedEvent.current = true;\n    }\n  }, [isVisible, component, eventProps, eventName, componentProps, trackEvent]);\n};\n","import { useAtomValue } from \"jotai\";\nimport { useEffect, useRef } from \"react\";\nimport {\n  SpiffyMetricsEventName,\n  useAmplitude,\n} from \"src/contexts/amplitudeContext\";\nimport {\n  hasParsedVariantInfoAtom,\n  variantInfoAtom,\n} from \"src/atoms/app/variant\";\n\n/**\n * Updates the default analytics properties whenever the variant info changes. This hook also\n * triggers any events that should be sent once per page visit.\n */\nexport const useUpdateAnalyticsProps = () => {\n  const variantInfo = useAtomValue(variantInfoAtom);\n  const hasInitialized = useRef(false);\n  const hasParsedVariantInfo = useAtomValue(hasParsedVariantInfoAtom);\n  const { trackEvent, setSupplementalDefaultProps } = useAmplitude();\n\n  useEffect(() => {\n    const variantInfoWithPrefix = Object.fromEntries(\n      Object.entries(variantInfo).map(([key, value]) => [\n        `variantInfo.${key}`,\n        value,\n      ])\n    );\n\n    const defaultEventProperties: Record<string, unknown> = {\n      page_variant: variantInfo.variant, // TODO: should be removed over time, after migration\n      ...variantInfoWithPrefix,\n    };\n\n    // TODO: should be removed over time, after migration\n    if (variantInfo.variant === \"pdp\") {\n      defaultEventProperties.product_id = variantInfo.productId;\n    }\n\n    // TODO: should be removed over time, after migration\n    if (variantInfo.variant === \"plp\") {\n      defaultEventProperties.plp_id = variantInfo.plpId;\n    }\n\n    // TODO: should be removed over time, after migration\n    if (variantInfo.variant === \"page_visit\") {\n      defaultEventProperties.page_visit_category =\n        variantInfo.pageVisitCategory;\n      defaultEventProperties.page_visit_url = variantInfo.url;\n    }\n\n    setSupplementalDefaultProps(defaultEventProperties);\n\n    // put any events that should be sent once per page visit here\n    if (!hasInitialized.current && hasParsedVariantInfo) {\n      trackEvent({\n        eventName: SpiffyMetricsEventName.BundleLoaded,\n      });\n      hasInitialized.current = true;\n    }\n  }, [\n    variantInfo,\n    hasParsedVariantInfo,\n    trackEvent,\n    setSupplementalDefaultProps,\n  ]);\n};\n","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\";\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 { useSystemSettingsContext } from \"src/hooks\";\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/useAmplitudeOperations\";\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","import React, { ReactNode } from \"react\";\nimport { useNewOrgConfig } from \"src/hooks\";\n\ninterface EnviveCssProviderProps {\n  children: ReactNode;\n}\n\nexport const EnviveCssProvider: React.FC<EnviveCssProviderProps> = ({\n  children,\n}) => {\n  const { colorsConfig, frontendConfig, loading } = useNewOrgConfig();\n  let merchantThemeCss = `* {}`;\n  if (colorsConfig && !loading) {\n    merchantThemeCss = `\n* {\n  --spiffy-colors-text-primary: ${colorsConfig.textPrimary};\n  --spiffy-colors-text-secondary: ${colorsConfig.textSecondary};\n  --spiffy-colors-text-accent: ${colorsConfig.textAccent};\n  --spiffy-colors-text-link: ${colorsConfig.textLink};\n  --spiffy-colors-text-light: ${colorsConfig.textLight};\n  --spiffy-colors-background-primary: ${colorsConfig.backgroundPrimary};\n  --spiffy-colors-background-secondary: ${colorsConfig.backgroundSecondary};\n  --spiffy-colors-background-secondary-dark: ${colorsConfig.backgroundSecondaryDark};\n  --spiffy-colors-background-tertiary: ${colorsConfig.backgroundTertiary};\n  --spiffy-colors-background-dark: ${colorsConfig.backgroundDark};\n  --spiffy-colors-background-light: ${colorsConfig.backgroundLight};\n  --spiffy-colors-background-saturated: ${colorsConfig.backgroundSaturated};\n  --spiffy-colors-border-light: ${colorsConfig.borderLight};\n  --spiffy-colors-border-medium: ${colorsConfig.borderMedium};\n  --spiffy-colors-border-dark: ${colorsConfig.borderDark};\n  --spiffy-colors-border-outline: ${colorsConfig.borderOutline};\n  --spiffy-colors-accent-primary: ${colorsConfig.accentPrimary};\n  --spiffy-colors-accent-secondary: ${colorsConfig.accentSecondary};\n}`;\n  }\n  console.log(frontendConfig);\n  return (\n    <>\n      {frontendConfig ? (\n        <style id=\"merchant-css-overrides\">{`${frontendConfig.merchantOverrideCss}`}</style>\n      ) : null}\n      {colorsConfig ? (\n        <style id=\"merchant-css-colors\">{`${merchantThemeCss}`}</style>\n      ) : null}\n\n      {children}\n    </>\n  );\n};\n","import { useAtomValue } from \"jotai\";\nimport {\n  Dispatch,\n  ReactNode,\n  SetStateAction,\n  createContext,\n  useMemo,\n  useState,\n} from \"react\";\nimport { GenerationParams } from \"src/application/models\";\nimport { baseUrlAtom } from \"src/atoms/envive/enviveConfig\";\n\n// TODO: Refactor this to a common service that handles query params (and spiffy variables all together)\nconst getChatModelName = () => {\n  const urlObj = new URL(window.location.href);\n  const params = new URLSearchParams(urlObj.search);\n  const paramsObj = Object.fromEntries(params.entries());\n  return paramsObj.llm_model_name;\n};\n\nconst defaultGenerationParams: GenerationParams = {\n  stream: true,\n  numSuggestions: 3,\n  model: getChatModelName(),\n};\n\ninterface SystemSettingsContextParams {\n  generationParams?: GenerationParams;\n  showDebugBar?: boolean;\n  endpointURL?: string;\n  setGenerationParams: Dispatch<SetStateAction<GenerationParams | undefined>>;\n}\n\ninterface SystemSettingsContextProviderProps {\n  children: ReactNode;\n  generationParams?: GenerationParams;\n  showDebugBar?: boolean;\n}\n\nconst SystemSettingsContext = createContext<\n  SystemSettingsContextParams | undefined\n>(undefined);\n\nconst SystemSettingsContextProvider = ({\n  children,\n  generationParams,\n  showDebugBar,\n}: SystemSettingsContextProviderProps) => {\n  const [params, setParams] = useState<GenerationParams | undefined>(\n    () => generationParams ?? defaultGenerationParams\n  );\n  const endpointURL = useAtomValue(baseUrlAtom);\n  const settingsContextValues = useMemo(\n    () => ({\n      generationParams: params,\n      showDebugBar,\n      setGenerationParams: setParams,\n      endpointURL,\n    }),\n    [generationParams, endpointURL, showDebugBar]\n  );\n\n  return (\n    <SystemSettingsContext.Provider value={settingsContextValues}>\n      {children}\n    </SystemSettingsContext.Provider>\n  );\n};\n\nexport {\n  SystemSettingsContextProvider,\n  SystemSettingsContext,\n  defaultGenerationParams,\n};\n"],"mappings":"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"}