@envive-ai/react-hooks 0.2.6-alpha-marlo.0 → 0.2.6-alpha-arthur-3

package/dist/app-Di_sBmzj.cjs

@@ -0,0 +1,570 @@
+const require_chunk = require('./chunk-CUT6urMc.cjs');
+const require_exceptions = require('./exceptions-BjDgLzGi.cjs');
+const require_dist = require('./dist-VxRI6eQv.cjs');
+const require_models = require('./models-Dl0_Ujgj.cjs');
+const require_logger = require('./logger-BqHq67zN.cjs');
+const require_utils = require('./utils-D3MjNkd3.cjs');
+const require_atomStore = require('./atomStore-CZKe3itM.cjs');
+const require_enviveConfig = require('./enviveConfig-CHXb9xwk.cjs');
+const require_org = require('./org-BNs_maoW.cjs');
+const require_localStorageContext = require('./localStorageContext-CWc5xJ6U.cjs');
+let __spiffy_ai_commerce_api_client = require("@spiffy-ai/commerce-api-client");
+__spiffy_ai_commerce_api_client = require_chunk.__toESM(__spiffy_ai_commerce_api_client);
+let react = require("react");
+react = require_chunk.__toESM(react);
+let uuid = require("uuid");
+uuid = require_chunk.__toESM(uuid);
+let jotai = require("jotai");
+jotai = require_chunk.__toESM(jotai);
+let jotai_utils = require("jotai/utils");
+jotai_utils = require_chunk.__toESM(jotai_utils);
+let ua_parser_js = require("ua-parser-js");
+ua_parser_js = require_chunk.__toESM(ua_parser_js);
+let react_jsx_runtime = require("react/jsx-runtime");
+react_jsx_runtime = require_chunk.__toESM(react_jsx_runtime);
+
+//#region src/application/commerce-api.ts
+async function errorResponseBody(error) {
+	try {
+		return await error.response.json();
+	} catch {
+		return {};
+	}
+}
+async function throwSessionRestartRequiredIf(errorMsg, error) {
+	if (!(error instanceof __spiffy_ai_commerce_api_client.ResponseError)) {
+		require_logger.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 require_exceptions.UnsupportedProductException();
+	else if (errorResponse?.app_code?.toUpperCase() === "RESTART_SESSION" || errorResponse?.sub_code?.toUpperCase() === "NOT_FOUND") {
+		require_logger.logger_default.logInfo("Session does not exist. Re-start session", error, error.response, errorResponse);
+		throw new require_exceptions.SessionRestartRequired();
+	}
+	require_logger.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 = require_atomStore.getAtomStore().get(require_enviveConfig.baseUrlAtom);
+		const config = new __spiffy_ai_commerce_api_client.Configuration({
+			basePath: basePath || baseUrl,
+			headers: {
+				"Content-Type": "application/json",
+				Accept: "application/json"
+			}
+		});
+		this.defaultApi = new __spiffy_ai_commerce_api_client.DefaultApi(config);
+		this.inferenceApi = new __spiffy_ai_commerce_api_client.InferenceApi(config);
+		this.customerServiceApi = new __spiffy_ai_commerce_api_client.CustomerServiceApi(config);
+	}
+	static {
+		this.resolveUrl = async (url) => {
+			const atomStore = require_atomStore.getAtomStore();
+			const orgShortName = atomStore.get(require_enviveConfig.orgShortNameAtom);
+			const orgId = atomStore.get(require_org.orgIdAtom);
+			const userId = atomStore.get(userIdAtom);
+			const chatId = atomStore.get(chatIdAtom);
+			const source = atomStore.get(require_enviveConfig.contextSourceAtom);
+			const env = atomStore.get(require_enviveConfig.envAtom);
+			const featureFlagService = atomStore.get(require_org.featureFlagServiceAtom);
+			const context = {
+				user_id: userId ?? "",
+				org_id: orgId ?? "",
+				org_short_name: orgShortName ?? "",
+				chat_id: chatId ?? "",
+				source: source ?? __spiffy_ai_commerce_api_client.ContextSourceEnum.App,
+				env: env ?? __spiffy_ai_commerce_api_client.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: require_utils.messageRequestToCommerceMessageRequest(payload) })).map((resp) => require_models.validateResponse(resp)).map((resp) => require_utils.messageFromResponse(resp)).filter((m) => m != null);
+			} catch (err) {
+				require_logger.logger_default.logInfo("Failed to get next responses", err, {
+					payloadContext: payload?.context,
+					userEvents: payload?.userEvents
+				});
+				await throwSessionRestartRequiredIf("Failed to get next responses", err);
+				return [];
+			}
+		};
+	}
+	static {
+		this.getNextResponseStreaming = (payload) => {
+			async function* generate(inferenceApi, abortController) {
+				try {
+					const response = await inferenceApi.v1NextResponsesPostRaw({ NextMessageRequest: require_utils.messageRequestToCommerceMessageRequest(payload) }, { signal: abortController.signal });
+					if (!response.raw.body) {
+						require_logger.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) {
+							require_logger.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 = require_models.validateResponse(parsedLine);
+							if (validatedResponse) yield validatedResponse;
+						}
+					}
+				} catch (error) {
+					require_logger.logger_default.logError("[spiffy-ai] Failed to get next streaming responses", error, {
+						payloadContext: payload?.context,
+						userEvents: payload?.userEvents
+					});
+					await throwSessionRestartRequiredIf("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: require_utils.messageRequestToCommerceMessageRequest(payload) }, { signal: CommerceApiClient.getInstance().suggestionsAbortController.signal })).map((resp) => require_models.validateSuggestion(resp)).filter((suggestion) => suggestion != null);
+			} catch (error) {
+				require_logger.logger_default.logInfo("Failed to get suggestions", error, {
+					payloadContext: payload?.context,
+					userEvents: payload?.userEvents
+				});
+				await throwSessionRestartRequiredIf("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("Failed to get chat responses", error);
+			}
+			const responses = data?.responses?.map((turn) => turn.map((response) => require_models.validateResponse(response)).filter((response) => response != null));
+			const suggestions = data?.suggestions.map((suggestion) => require_models.validateSuggestion(suggestion)).filter((suggestion) => suggestion != null);
+			const userEvents = data?.user_events.map((event) => require_models.validateUserEvent(event)).filter((event) => event != null);
+			const formSubmittedUserEventsFormIds = userEvents.filter((event) => event.category === __spiffy_ai_commerce_api_client.UserEventCategory.FormSubmitted).map((event) => event.attributes.formResponseId);
+			const assistantMessages = responses.map((turn) => turn.filter((response) => !(response.category === __spiffy_ai_commerce_api_client.ResponseCategory.Form && formSubmittedUserEventsFormIds.includes(response.id))).map((response) => require_utils.messageFromResponse(response)).filter((message) => message != null)).filter((turn) => turn.length > 0);
+			const userMessages = userEvents.map((event) => {
+				if ([__spiffy_ai_commerce_api_client.UserEventCategory.QueryTyped, __spiffy_ai_commerce_api_client.UserEventCategory.Search].includes(event.category)) return [require_utils.messageFromQueryEvent(event)];
+				if (event.category === __spiffy_ai_commerce_api_client.UserEventCategory.SuggestionClicked) return [require_utils.messageFromSuggestionEvent(event, suggestions)];
+				if (event.category === __spiffy_ai_commerce_api_client.UserEventCategory.FormSubmitted) {
+					const formResponse = responses.flat().find((response) => response.id === event.attributes.formResponseId && event.attributes.formType !== __spiffy_ai_commerce_api_client.FormType.Escalation);
+					if (formResponse && formResponse.category === __spiffy_ai_commerce_api_client.ResponseCategory.Form) return [require_utils.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: require_utils.coreSupportedEventRequestToApiRequest(payload) })).raw.text();
+				const httpResponseJson = JSON.parse(httpResponseText);
+				return {
+					...httpResponseJson,
+					numberOfReviews: httpResponseJson.num_of_reviews,
+					merchant_tags: httpResponseJson.merchant_tags || []
+				};
+			} catch (err) {
+				require_logger.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) {
+				require_logger.logger_default.logError("Failed to identify user", err);
+			}
+		};
+	}
+	static {
+		this.mapContextSourceToV1OrgConfigGetSource = (source) => {
+			if (source === void 0) return void 0;
+			switch (source) {
+				case __spiffy_ai_commerce_api_client.ContextSourceEnum.Fork: return __spiffy_ai_commerce_api_client.V1OrgConfigGetSourceEnum.Fork;
+				case __spiffy_ai_commerce_api_client.ContextSourceEnum.Playground: return __spiffy_ai_commerce_api_client.V1OrgConfigGetSourceEnum.Playground;
+				case __spiffy_ai_commerce_api_client.ContextSourceEnum.App: return __spiffy_ai_commerce_api_client.V1OrgConfigGetSourceEnum.App;
+				case __spiffy_ai_commerce_api_client.ContextSourceEnum.Test: return __spiffy_ai_commerce_api_client.V1OrgConfigGetSourceEnum.Test;
+				case __spiffy_ai_commerce_api_client.ContextSourceEnum.Eval: return __spiffy_ai_commerce_api_client.V1OrgConfigGetSourceEnum.Test;
+				default: return source;
+			}
+		};
+	}
+	static {
+		this.getOrgConfig = async (user_id) => {
+			try {
+				const atomStore = require_atomStore.getAtomStore();
+				const reactAppName = atomStore.get(require_enviveConfig.reactAppNameAtom);
+				const contextSource = atomStore.get(require_enviveConfig.contextSourceAtom);
+				const featureFlagService = atomStore.get(require_org.featureFlagServiceAtom);
+				const request = {
+					namespace: reactAppName,
+					user_id,
+					source: this.mapContextSourceToV1OrgConfigGetSource(contextSource),
+					include_experiments: Object.values(require_dist.ProductExperiment),
+					include_feature_gates: Object.entries(featureFlagService?.featureFlagService?.getFeatureFlags() || {}).filter(([, isEnabled]) => isEnabled).map(([featureGateName]) => featureGateName)
+				};
+				const response = await CommerceApiClient.getInstance().defaultApi.v1OrgConfigGet(request);
+				return require_models.validateOrgConfigResults(response);
+			} catch (err) {
+				require_logger.logger_default.logError(`Failed to get org config`, err, { err });
+				return;
+			}
+		};
+	}
+	static {
+		this.addNoteToLatestConversation = async (spiffyUserId, email, customerServiceProvider) => {
+			require_logger.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) {
+				require_logger.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/contexts/userIdentityContext/userIdentityContext.tsx
+const getUserAgentDetails = () => {
+	const result = new ua_parser_js.default().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 = (0, react.createContext)(void 0);
+const UserIdentityProvider = ({ children }) => {
+	const { getItem, setItem, isAvailable: localStorageIsReady } = require_localStorageContext.useLocalStorage();
+	const [isReady, setIsReady] = (0, react.useState)(false);
+	(0, react.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 = (0, react.useCallback)(() => getItem(USER_ID_OVERRIDE_KEY) ?? void 0, [getItem]);
+	const getUserIdDefaultFromLocalStorage = (0, react.useCallback)(() => getItem(USER_ID_DEFAULT_KEY) ?? void 0, [getItem]);
+	const setUserIdDefaultInLocalStorage = (0, react.useCallback)((userId) => {
+		require_logger.logger_default.logInfo(`setUserIdDefaultInLocalStorage - Setting user_id=${userId}`);
+		setItem(USER_ID_DEFAULT_KEY, userId);
+		return userId;
+	}, [setItem, USER_ID_DEFAULT_KEY]);
+	const setUserIdOverrideInLocalStorage = (0, react.useCallback)((userId) => {
+		require_logger.logger_default.logInfo(`setUserIdOverrideInLocalStorage - Setting user_id=${userId}`);
+		setItem(USER_ID_OVERRIDE_KEY, userId);
+		return userId;
+	}, [setItem, USER_ID_OVERRIDE_KEY]);
+	const clearUserIdOverrideInLocalStorage = (0, react.useCallback)(() => {
+		require_logger.logger_default.logInfo(`clearUserIdOverrideInLocalStorage - Clearing user_id`);
+		setItem(USER_ID_OVERRIDE_KEY, "");
+	}, [setItem, USER_ID_OVERRIDE_KEY]);
+	const getUserIdOrDefault = (0, react.useCallback)(() => {
+		const userIdOverride = getUserIdOverrideFromLocalStorage();
+		if (userIdOverride) return userIdOverride;
+		const defaultUserId = getUserIdDefaultFromLocalStorage();
+		if (defaultUserId) return defaultUserId;
+		return setUserIdDefaultInLocalStorage(`spiffy-user-id-${(0, uuid.v4)()}`);
+	}, [
+		getUserIdOverrideFromLocalStorage,
+		getUserIdDefaultFromLocalStorage,
+		setUserIdDefaultInLocalStorage
+	]);
+	const identifyUser = (0, react.useCallback)(async () => {
+		if (!isReady) {
+			require_logger.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) {
+			require_logger.logger_default.logError("[spiffy-ai] Error identifying user", error);
+		}
+	}, [isReady, getUserIdOrDefault]);
+	const value = (0, react.useMemo)(() => ({
+		identifyUser,
+		getUserIdOrDefault,
+		getUserIdOverrideFromLocalStorage,
+		getUserIdDefaultFromLocalStorage,
+		setUserIdDefaultInLocalStorage,
+		setUserIdOverrideInLocalStorage,
+		clearUserIdOverrideInLocalStorage,
+		isReady
+	}), [
+		identifyUser,
+		getUserIdOrDefault,
+		getUserIdOverrideFromLocalStorage,
+		getUserIdDefaultFromLocalStorage,
+		setUserIdDefaultInLocalStorage,
+		setUserIdOverrideInLocalStorage,
+		clearUserIdOverrideInLocalStorage,
+		isReady
+	]);
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(UserIdentityContext.Provider, {
+		value,
+		children
+	});
+};
+const useUserIdentity = () => {
+	const context = (0, react.useContext)(UserIdentityContext);
+	if (!context) throw new Error("useUserIdentity must be used within a UserIdentityProvider");
+	return context;
+};
+
+//#endregion
+//#region src/atoms/app/variant.ts
+const internalStorageUrlResolverAtom = (0, jotai_utils.atomWithStorage)("spiffy-url-resolver", void 0, require_atomStore.sessionStorageUtil, { getOnInit: true });
+const urlResolverAtom = (0, jotai.atom)((get) => {
+	const maybeUrlResolver = get(internalStorageUrlResolverAtom);
+	if (maybeUrlResolver == null) return {};
+	return JSON.parse(maybeUrlResolver);
+}, (get, set, value) => {
+	const newCache = {
+		...get(urlResolverAtom),
+		[value.url]: value.response
+	};
+	set(internalStorageUrlResolverAtom, JSON.stringify(newCache));
+});
+const internalStorageSupportedEventAtom = (0, jotai_utils.atomWithStorage)("spiffy-supported-event", void 0, require_atomStore.sessionStorageUtil, { getOnInit: true });
+const internalSupportedEventAtom = (0, jotai.atom)(void 0);
+const supportedEventAtom = (0, jotai.atom)((get) => {
+	const maybeSupportedEvent = get(internalStorageSupportedEventAtom);
+	if (maybeSupportedEvent == null) return;
+	return JSON.parse(maybeSupportedEvent);
+}, (_, set, value) => {
+	if (value == null) {
+		set(internalStorageSupportedEventAtom, void 0);
+		set(internalSupportedEventAtom, void 0);
+		return;
+	}
+	set(internalSupportedEventAtom, value);
+	set(internalStorageSupportedEventAtom, JSON.stringify(value));
+});
+const internalVariantIdAtom = (0, jotai.atom)();
+const internalProductIdAtom = (0, jotai.atom)();
+const internalParentProductIdAtom = (0, jotai.atom)();
+const internalProductUrlAtom = (0, jotai.atom)();
+const internalPlpIdAtom = (0, jotai.atom)();
+const internalUrlAtom = (0, jotai.atom)();
+const internalPageVisitCategoryAtom = (0, jotai.atom)();
+const internalVariantAtom = (0, jotai.atom)("pdp");
+const variantIdAtom = (0, jotai.atom)((get) => get(internalVariantIdAtom));
+const productIdAtom = (0, jotai.atom)((get) => get(internalProductIdAtom));
+const parentProductIdAtom = (0, jotai.atom)((get) => get(internalParentProductIdAtom));
+const productUrlAtom = (0, jotai.atom)((get) => get(internalProductUrlAtom));
+const plpIdAtom = (0, jotai.atom)((get) => get(internalPlpIdAtom));
+const urlAtom = (0, jotai.atom)((get) => get(internalUrlAtom));
+const pageVisitCategoryAtom = (0, jotai.atom)((get) => get(internalPageVisitCategoryAtom));
+const variantAtom = (0, jotai.atom)((get) => get(internalVariantAtom));
+const hasParsedVariantInfoAtom = (0, jotai.atom)(false);
+const variantInfoAtom = (0, jotai.atom)((get) => {
+	const variant = get(variantAtom);
+	if (variant === require_dist.VariantTypeEnum.Pdp) return {
+		variantId: get(variantIdAtom),
+		variant,
+		productId: get(productIdAtom),
+		parentProductId: get(parentProductIdAtom),
+		url: get(urlAtom)
+	};
+	if (variant === require_dist.VariantTypeEnum.Plp) return {
+		variantId: get(variantIdAtom),
+		variant,
+		plpId: get(plpIdAtom),
+		url: get(urlAtom)
+	};
+	if (variant === require_dist.VariantTypeEnum.PageVisit) return {
+		variantId: get(variantIdAtom),
+		variant,
+		url: get(urlAtom),
+		pageVisitCategory: get(pageVisitCategoryAtom)
+	};
+	throw new Error("Invalid variantInfo details");
+}, (_, set, newVariant) => {
+	set(internalVariantAtom, newVariant.variant);
+	set(internalVariantIdAtom, newVariant.variantId);
+	if (newVariant.variant === require_dist.VariantTypeEnum.Pdp) {
+		set(internalProductIdAtom, newVariant.productId);
+		set(internalParentProductIdAtom, newVariant.parentProductId);
+		set(internalUrlAtom, newVariant.url);
+	}
+	if (newVariant.variant === require_dist.VariantTypeEnum.Plp) {
+		set(internalPlpIdAtom, newVariant.plpId);
+		set(internalUrlAtom, newVariant.url);
+	}
+	if (newVariant.variant === require_dist.VariantTypeEnum.PageVisit) {
+		set(internalUrlAtom, newVariant.url);
+		set(internalPageVisitCategoryAtom, newVariant.pageVisitCategory);
+	}
+});
+
+//#endregion
+//#region src/atoms/app/index.ts
+const internalUserIdAtom = (0, jotai.atom)(void 0);
+const userIdAtom = (0, jotai.atom)((get) => {
+	const maybeUserId = get(internalUserIdAtom);
+	if (maybeUserId) return maybeUserId;
+	const { getUserIdOrDefault } = useUserIdentity();
+	return getUserIdOrDefault();
+}, (_, set, value) => {
+	set(internalUserIdAtom, value);
+});
+const userIdentityAtom = (0, jotai.atom)(void 0);
+const appSourceAtom = (0, jotai.atom)((get) => get(require_enviveConfig.contextSourceAtom) ?? __spiffy_ai_commerce_api_client.ContextSourceEnum.App);
+const chatIdAtom = (0, jotai_utils.atomWithStorage)("v1-spiffy-chat-session-id", (0, uuid.v4)(), void 0, { getOnInit: true });
+
+//#endregion
+Object.defineProperty(exports, 'UserIdentityProvider', {
+  enumerable: true,
+  get: function () {
+    return UserIdentityProvider;
+  }
+});
+Object.defineProperty(exports, 'appSourceAtom', {
+  enumerable: true,
+  get: function () {
+    return appSourceAtom;
+  }
+});
+Object.defineProperty(exports, 'chatIdAtom', {
+  enumerable: true,
+  get: function () {
+    return chatIdAtom;
+  }
+});
+Object.defineProperty(exports, 'hasParsedVariantInfoAtom', {
+  enumerable: true,
+  get: function () {
+    return hasParsedVariantInfoAtom;
+  }
+});
+Object.defineProperty(exports, 'useUserIdentity', {
+  enumerable: true,
+  get: function () {
+    return useUserIdentity;
+  }
+});
+Object.defineProperty(exports, 'userIdAtom', {
+  enumerable: true,
+  get: function () {
+    return userIdAtom;
+  }
+});
+Object.defineProperty(exports, 'userIdentityAtom', {
+  enumerable: true,
+  get: function () {
+    return userIdentityAtom;
+  }
+});
+Object.defineProperty(exports, 'variantInfoAtom', {
+  enumerable: true,
+  get: function () {
+    return variantInfoAtom;
+  }
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"app-Di_sBmzj.cjs","names":["ResponseError","UnsupportedProductException","SessionRestartRequired","getAtomStore","baseUrlAtom","config: Configuration","Configuration","DefaultApi","InferenceApi","CustomerServiceApi","orgShortNameAtom","orgIdAtom","contextSourceAtom","envAtom","featureFlagServiceAtom","context: Context","ContextSourceEnum","ContextEnvEnum","messageRequestToCommerceMessageRequest","validateResponse","messageFromResponse","err: unknown","error: unknown","validateSuggestion","data: V1GetSessionMessages200Response","responses: ApiResponse[][]","suggestions: Suggestion[]","userEvents: UserEvent[]","validateUserEvent","UserEventCategory","assistantMessages: Message[][]","ResponseCategory","userMessages: Message[][]","messageFromQueryEvent","messageFromSuggestionEvent","FormType","messageFromFormSubmittedEvent","coreSupportedEventRequestToApiRequest","V1OrgConfigGetSourceEnum","reactAppNameAtom","request: V1OrgConfigGetRequest","ProductExperiment","validateOrgConfigResults","UAParser","UserIdentityProvider: React.FC<{ children: React.ReactNode }>","useLocalStorage","CommerceApiClient","sessionStorageUtil","VariantTypeEnum","contextSourceAtom","ContextSourceEnum"],"sources":["../src/application/commerce-api.ts","../src/contexts/userIdentityContext/userIdentityContext.tsx","../src/atoms/app/variant.ts","../src/atoms/app/index.ts"],"sourcesContent":["import {\n  Context,\n  ContextEnvEnum,\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 {\n  SupportedEvent,\n  ProductExperiment,\n  ClientDetails,\n  UserEvent,\n  NextMessageRequest,\n  SupportedEventRequest,\n  OrgConfig,\n} from \"@envive-ai/types\";\nimport { ApiResponse, Message, Suggestion } from \"src/types\";\nimport { userIdAtom, chatIdAtom } from \"src/atoms/app\";\nimport { getAtomStore } from \"src/atoms/atomStore\";\nimport {\n  baseUrlAtom,\n  orgShortNameAtom,\n  contextSourceAtom,\n  envAtom,\n  reactAppNameAtom,\n} from \"src/atoms/envive/enviveConfig\";\nimport { orgIdAtom, featureFlagServiceAtom } from \"src/atoms/org\";\nimport {\n  UnsupportedProductException,\n  SessionRestartRequired,\n} from \"src/exceptions\";\nimport Logger from \"./logging/logger\";\nimport {\n  validateResponse,\n  validateSuggestion,\n  validateUserEvent,\n  validateOrgConfigResults,\n} from \"./models\";\nimport {\n  messageRequestToCommerceMessageRequest,\n  messageFromResponse,\n  messageFromQueryEvent,\n  messageFromSuggestionEvent,\n  messageFromFormSubmittedEvent,\n  coreSupportedEventRequestToApiRequest,\n} from \"./utils\";\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<ApiResponse, 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: ApiResponse[][];\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: ApiResponse[][] = data?.responses?.map((turn) =>\n      turn\n        .map((response) => validateResponse(response))\n        .filter((response): response is ApiResponse => 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      case ContextSourceEnum.Eval:\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 React, { createContext, useCallback, useContext, useMemo, useState, useEffect } from 'react';\nimport UAParser from 'ua-parser-js';\nimport { ClientDetails, UserIdentityContextType } from '@envive-ai/types';\nimport Logger from '../../application/logging/logger';\nimport CommerceApiClient from '../../application/commerce-api';\nimport { useLocalStorage } from '../localStorageContext';\nimport { v4 as uuid } from 'uuid';\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\nconst UserIdentityContext = createContext<UserIdentityContextType | undefined>(undefined);\n\nexport const UserIdentityProvider: React.FC<{ children: React.ReactNode }> = ({ children }) => {\n  const { getItem, setItem, isAvailable: localStorageIsReady } = 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 | undefined => getItem(USER_ID_OVERRIDE_KEY) ?? undefined,\n    [getItem],\n  );\n\n  const getUserIdDefaultFromLocalStorage = useCallback(\n    (): string | undefined => getItem(USER_ID_DEFAULT_KEY) ?? undefined,\n    [getItem],\n  );\n\n  const setUserIdDefaultInLocalStorage = useCallback(\n    (userId: string): string => {\n      Logger.logInfo(`setUserIdDefaultInLocalStorage - Setting user_id=${userId}`);\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(`setUserIdOverrideInLocalStorage - Setting user_id=${userId}`);\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('[UserIdentityContext] Context not ready, skipping identifyUser', undefined);\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('[spiffy-ai] No GA Client ID found, skipping identifyUser', undefined);\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 <UserIdentityContext.Provider value={value}>{children}</UserIdentityContext.Provider>;\n};\n\nexport const useUserIdentity = () => {\n  const context = useContext(UserIdentityContext);\n  if (!context) {\n    throw new Error('useUserIdentity must be used within a UserIdentityProvider');\n  }\n  return context;\n};\n","import { atomWithStorage } from 'jotai/utils';\nimport { atom } from 'jotai';\nimport { SupportedEventResponse, PageVisitCategory } from '@spiffy-ai/commerce-api-client';\nimport {\n  PageVisitVariantInfo,\n  PDPVariantInfo,\n  PLPVariantInfo,\n  VariantInfo,\n  VariantTypeEnum,\n} from '@envive-ai/types';\nimport { sessionStorageUtil } from 'src/atoms/atomStore';\n\nexport interface SupportedEvent\n  extends Pick<\n    SupportedEventResponse,\n    'supported' | 'ready' | 'category' | 'collections' | 'top_category'\n  > {\n  numberOfReviews: number | undefined;\n  merchant_tags?: string[];\n}\n\ninterface PDPAttributes {\n  product_id?: string;\n}\n\ninterface PLPAttributes {\n  attributes?: {\n    id?: string;\n  };\n}\n\nexport interface UrlResolvingPDPConfig {\n  pdp_attributes: PDPAttributes;\n  number_of_reviews?: number;\n  collections?: string[];\n  merchant_tags?: string[];\n}\n\nexport interface UrlResolvingPLPConfig {\n  plp_attributes: PLPAttributes;\n  top_category?: string;\n}\n\ninterface UrlResolvingGenericConfig {\n  details?: string;\n}\n\nexport type PageVariantCheckConfig = {\n  check_type: string;\n  feature_gate?: string;\n  extractor?: {\n    type: string;\n    map?: Record<string, string[]>;\n    value?: string;\n  };\n  product_id_extractor?: string;\n  product_ids?: string[];\n  plp_id_extractor?: string;\n  plp_ids?: string[];\n  collections?: string[];\n  query_param?: string;\n  category?: string;\n  top_category?: string[];\n  review_minimum?: number;\n  merchant_tags?: string[];\n};\n\nexport type BackendWidgetMountingConfig = {\n  mounting_config_id: string;\n  widget_config_id?: string;\n  mounting_point_widgets?: Array<{\n    checks: PageVariantCheckConfig[];\n    widget_config_id: string;\n  }>;\n};\n\nexport type BackendPageVariantConfig = {\n  variant_id: string;\n  variant_type: string;\n  variant_checks: PageVariantCheckConfig[];\n  widget_mounting: BackendWidgetMountingConfig[];\n  plp_id_extractor?: string;\n  product_id_extractor?: string;\n  parent_product_id_extractor?: string;\n};\n\nexport interface UrlResolverResponse {\n  variant_type: string;\n  specific_details: UrlResolvingPDPConfig | UrlResolvingPLPConfig | UrlResolvingGenericConfig;\n  ready: boolean;\n  user_event?: {\n    event_id?: string;\n    attributes?: PDPAttributes | PLPAttributes;\n    category?: string;\n    created_at?: string;\n  };\n  page_variant?: BackendPageVariantConfig;\n}\n\n// Use a map for per-URL cache\nexport type UrlResolverCache = Record<string, UrlResolverResponse | undefined>;\n\nconst internalStorageUrlResolverAtom = atomWithStorage<string | undefined>(\n  'spiffy-url-resolver',\n  undefined,\n  sessionStorageUtil,\n  {\n    getOnInit: true,\n  },\n);\n\nexport const urlResolverAtom = atom(\n  (get): UrlResolverCache => {\n    const maybeUrlResolver = get(internalStorageUrlResolverAtom);\n    if (maybeUrlResolver == null) {\n      return {};\n    }\n    return JSON.parse(maybeUrlResolver);\n  },\n  (get, set, value: { url: string; response: UrlResolverResponse | undefined }) => {\n    // Get current cache from storage\n    const currentCache = get(urlResolverAtom);\n    const newCache = { ...currentCache, [value.url]: value.response };\n\n    set(internalStorageUrlResolverAtom, JSON.stringify(newCache));\n  },\n);\n\nconst internalStorageSupportedEventAtom = atomWithStorage<string | undefined>(\n  'spiffy-supported-event',\n  undefined,\n  sessionStorageUtil,\n  {\n    getOnInit: true,\n  },\n);\nconst internalSupportedEventAtom = atom<SupportedEvent | undefined>(undefined);\n\nexport const supportedEventAtom = atom(\n  (get): SupportedEvent | undefined => {\n    const maybeSupportedEvent = get(internalStorageSupportedEventAtom);\n    if (maybeSupportedEvent == null) {\n      return undefined;\n    }\n\n    // TODO this is an unvalidated parse. It may be better to implement a custom storage util\n    // and perform the object validation on \"get\" there.\n    return JSON.parse(maybeSupportedEvent);\n  },\n  (_, set, value: SupportedEvent | undefined) => {\n    if (value == null) {\n      set(internalStorageSupportedEventAtom, undefined);\n      set(internalSupportedEventAtom, undefined);\n      return;\n    }\n\n    set(internalSupportedEventAtom, value);\n    set(internalStorageSupportedEventAtom, JSON.stringify(value));\n  },\n);\n\nconst internalVariantIdAtom = atom<string>();\nconst internalProductIdAtom = atom<string>();\nconst internalParentProductIdAtom = atom<string>();\nconst internalProductUrlAtom = atom<string>();\nconst internalPlpIdAtom = atom<string>();\nconst internalUrlAtom = atom<string>();\nconst internalPageVisitCategoryAtom = atom<PageVisitCategory>();\nconst internalVariantAtom = atom<'pdp' | 'plp' | 'search' | 'page_visit'>('pdp');\n\nexport const variantIdAtom = atom((get) => get(internalVariantIdAtom));\nexport const productIdAtom = atom((get) => get(internalProductIdAtom));\nexport const parentProductIdAtom = atom((get) => get(internalParentProductIdAtom));\nexport const productUrlAtom = atom((get) => get(internalProductUrlAtom));\nexport const plpIdAtom = atom((get) => get(internalPlpIdAtom));\nexport const urlAtom = atom((get) => get(internalUrlAtom));\nexport const pageVisitCategoryAtom = atom((get) => get(internalPageVisitCategoryAtom));\nexport const variantAtom = atom((get) => get(internalVariantAtom));\nexport const hasParsedVariantInfoAtom = atom(false);\n\nexport const variantInfoAtom = atom(\n  (get): VariantInfo => {\n    const variant = get(variantAtom);\n    if (variant === VariantTypeEnum.Pdp) {\n      return {\n        variantId: get(variantIdAtom),\n        variant,\n        productId: get(productIdAtom),\n        parentProductId: get(parentProductIdAtom),\n        url: get(urlAtom),\n      } as PDPVariantInfo;\n    }\n    if (variant === VariantTypeEnum.Plp) {\n      return {\n        variantId: get(variantIdAtom),\n        variant,\n        plpId: get(plpIdAtom),\n        url: get(urlAtom),\n      } as PLPVariantInfo;\n    }\n    if (variant === VariantTypeEnum.PageVisit) {\n      return {\n        variantId: get(variantIdAtom),\n        variant,\n        url: get(urlAtom),\n        pageVisitCategory: get(pageVisitCategoryAtom),\n      } as PageVisitVariantInfo;\n    }\n    throw new Error('Invalid variantInfo details');\n  },\n  (_, set, newVariant: VariantInfo) => {\n    set(internalVariantAtom, newVariant.variant);\n    set(internalVariantIdAtom, newVariant.variantId);\n    if (newVariant.variant === VariantTypeEnum.Pdp) {\n      set(internalProductIdAtom, newVariant.productId);\n      set(internalParentProductIdAtom, newVariant.parentProductId);\n      set(internalUrlAtom, newVariant.url);\n    }\n    if (newVariant.variant === VariantTypeEnum.Plp) {\n      set(internalPlpIdAtom, newVariant.plpId);\n      set(internalUrlAtom, newVariant.url);\n    }\n    if (newVariant.variant === VariantTypeEnum.PageVisit) {\n      set(internalUrlAtom, newVariant.url);\n      set(internalPageVisitCategoryAtom, newVariant.pageVisitCategory);\n    }\n  },\n);\n","import { ContextEnvEnum, ContextSourceEnum } from '@spiffy-ai/commerce-api-client';\nimport { atom } from 'jotai';\nimport { atomWithStorage } from 'jotai/utils';\nimport { VariantInfo, UserIdentityContextType } from '@envive-ai/types';\nimport { useUserIdentity } from 'src/contexts/userIdentityContext/userIdentityContext';\nimport { variantInfoAtom } from 'src/atoms/app/variant';\nimport { v4 as uuid } from 'uuid';\nimport { contextSourceAtom } from '../envive/enviveConfig';\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 { variantInfoAtom } from './variant';\n\nconst internalUserIdAtom = atom<string | undefined>(undefined);\n\nexport const userIdAtom = atom(\n  (get) => {\n    const maybeUserId = get(internalUserIdAtom);\n\n    if (maybeUserId) {\n      return maybeUserId;\n    }\n\n    const { getUserIdOrDefault } = useUserIdentity();\n    return getUserIdOrDefault();\n  },\n  (_, set, value: string | undefined) => {\n    set(internalUserIdAtom, value);\n  },\n);\n\nexport const userIdentityAtom = atom<UserIdentityContextType | undefined>(undefined);\n\nexport const appSourceAtom = atom<ContextSourceEnum>(\n  (get): ContextSourceEnum => get(contextSourceAtom) ?? ContextSourceEnum.App,\n);\nexport const chatIdAtom = atomWithStorage<string>('v1-spiffy-chat-session-id', uuid(), undefined, {\n  getOnInit: true,\n});\n"],"mappings":"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"}