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

package/dist/AmplitudeOperations-BjC8DOqm.js

@@ -0,0 +1,34 @@
+import { useAmplitude } from "./amplitudeContext-wW37Ziq-.js";
+import { useCallback, useState } from "react";
+
+//#region src/hooks/AmplitudeOperations/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
+export { useAmplitudeTracking };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/AmplitudeOperations-CQs4sVHN.cjs

@@ -0,0 +1,41 @@
+const require_chunk = require('./chunk-CUT6urMc.cjs');
+const require_amplitudeContext = require('./amplitudeContext-D5HSmIWg.cjs');
+let react = require("react");
+react = require_chunk.__toESM(react);
+
+//#region src/hooks/AmplitudeOperations/useAmplitudeOperations.ts
+const useAmplitudeTracking = () => {
+	const { trackEvent, isReady } = require_amplitudeContext.useAmplitude();
+	const [loading, setLoading] = (0, react.useState)(false);
+	const [error, setError] = (0, react.useState)(null);
+	return {
+		track: (0, react.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
+Object.defineProperty(exports, 'useAmplitudeTracking', {
+  enumerable: true,
+  get: function () {
+    return useAmplitudeTracking;
+  }
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/{NewOrgConfig-BfbTlFg1.js → NewOrgConfig-CRakarmw.js}

@@ -1,4 +1,4 @@
-import { useNewOrgConfigContext } from "./newOrgConfigContext-DQiuf8nd.js";
+import { useNewOrgConfigContext } from "./newOrgConfigContext-B_rJMpwN.js";
 
 //#region src/hooks/NewOrgConfig/useNewOrgConfig.ts
 const useNewOrgConfig = () => {
@@ -7,4 +7,4 @@ const useNewOrgConfig = () => {
 
 //#endregion
 export { useNewOrgConfig };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiTmV3T3JnQ29uZmlnLUJmYlRsRmcxLmpzIiwibmFtZXMiOltdLCJzb3VyY2VzIjpbIi4uL3NyYy9ob29rcy9OZXdPcmdDb25maWcvdXNlTmV3T3JnQ29uZmlnLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IHVzZU5ld09yZ0NvbmZpZ0NvbnRleHQgfSBmcm9tIFwic3JjL2NvbnRleHRzL25ld09yZ0NvbmZpZ0NvbnRleHQvbmV3T3JnQ29uZmlnQ29udGV4dFwiO1xuXG5leHBvcnQgY29uc3QgdXNlTmV3T3JnQ29uZmlnID0gKCkgPT4ge1xuICBjb25zdCBjb25maWcgPSB1c2VOZXdPcmdDb25maWdDb250ZXh0KCk7XG5cbiAgcmV0dXJuIGNvbmZpZztcbn07XG4iXSwibWFwcGluZ3MiOiI7OztBQUVBLE1BQWEsd0JBQXdCO0FBR25DLFFBRmUsd0JBQXdCIn0=
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiTmV3T3JnQ29uZmlnLUNSYWthcm13LmpzIiwibmFtZXMiOltdLCJzb3VyY2VzIjpbIi4uL3NyYy9ob29rcy9OZXdPcmdDb25maWcvdXNlTmV3T3JnQ29uZmlnLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IHVzZU5ld09yZ0NvbmZpZ0NvbnRleHQgfSBmcm9tIFwic3JjL2NvbnRleHRzL25ld09yZ0NvbmZpZ0NvbnRleHQvbmV3T3JnQ29uZmlnQ29udGV4dFwiO1xuXG5leHBvcnQgY29uc3QgdXNlTmV3T3JnQ29uZmlnID0gKCkgPT4ge1xuICBjb25zdCBjb25maWcgPSB1c2VOZXdPcmdDb25maWdDb250ZXh0KCk7XG5cbiAgcmV0dXJuIGNvbmZpZztcbn07XG4iXSwibWFwcGluZ3MiOiI7OztBQUVBLE1BQWEsd0JBQXdCO0FBR25DLFFBRmUsd0JBQXdCIn0=

package/dist/{NewOrgConfig-DJm6_abA.cjs → NewOrgConfig-D48KabOj.cjs}

@@ -1,4 +1,4 @@
-const require_newOrgConfigContext = require('./newOrgConfigContext-Cl4H9c3q.cjs');
+const require_newOrgConfigContext = require('./newOrgConfigContext-D1sgTmVU.cjs');
 
 //#region src/hooks/NewOrgConfig/useNewOrgConfig.ts
 const useNewOrgConfig = () => {
@@ -12,4 +12,4 @@ Object.defineProperty(exports, 'useNewOrgConfig', {
     return useNewOrgConfig;
   }
 });
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiTmV3T3JnQ29uZmlnLURKbTZfYWJBLmNqcyIsIm5hbWVzIjpbInVzZU5ld09yZ0NvbmZpZ0NvbnRleHQiXSwic291cmNlcyI6WyIuLi9zcmMvaG9va3MvTmV3T3JnQ29uZmlnL3VzZU5ld09yZ0NvbmZpZy50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyB1c2VOZXdPcmdDb25maWdDb250ZXh0IH0gZnJvbSBcInNyYy9jb250ZXh0cy9uZXdPcmdDb25maWdDb250ZXh0L25ld09yZ0NvbmZpZ0NvbnRleHRcIjtcblxuZXhwb3J0IGNvbnN0IHVzZU5ld09yZ0NvbmZpZyA9ICgpID0+IHtcbiAgY29uc3QgY29uZmlnID0gdXNlTmV3T3JnQ29uZmlnQ29udGV4dCgpO1xuXG4gIHJldHVybiBjb25maWc7XG59O1xuIl0sIm1hcHBpbmdzIjoiOzs7QUFFQSxNQUFhLHdCQUF3QjtBQUduQyxRQUZlQSxvREFBd0IifQ==
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiTmV3T3JnQ29uZmlnLUQ0OEthYk9qLmNqcyIsIm5hbWVzIjpbInVzZU5ld09yZ0NvbmZpZ0NvbnRleHQiXSwic291cmNlcyI6WyIuLi9zcmMvaG9va3MvTmV3T3JnQ29uZmlnL3VzZU5ld09yZ0NvbmZpZy50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyB1c2VOZXdPcmdDb25maWdDb250ZXh0IH0gZnJvbSBcInNyYy9jb250ZXh0cy9uZXdPcmdDb25maWdDb250ZXh0L25ld09yZ0NvbmZpZ0NvbnRleHRcIjtcblxuZXhwb3J0IGNvbnN0IHVzZU5ld09yZ0NvbmZpZyA9ICgpID0+IHtcbiAgY29uc3QgY29uZmlnID0gdXNlTmV3T3JnQ29uZmlnQ29udGV4dCgpO1xuXG4gIHJldHVybiBjb25maWc7XG59O1xuIl0sIm1hcHBpbmdzIjoiOzs7QUFFQSxNQUFhLHdCQUF3QjtBQUduQyxRQUZlQSxvREFBd0IifQ==

package/dist/TrackComponentVisibleEvent-C9RvfdS9.js

@@ -0,0 +1,53 @@
+import { SpiffyMetricsEventName } from "./dist-C38adNK1.js";
+import { useAmplitude } from "./amplitudeContext-wW37Ziq-.js";
+import { useIntersection } from "./useIntersection-bCSteycU.js";
+import { useEffect, useRef } from "react";
+
+//#region src/hooks/TrackComponentVisibleEvent/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
+export { useTrackComponentVisibleEvent };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/TrackComponentVisibleEvent-_Fb-JXkV.cjs

@@ -0,0 +1,60 @@
+const require_chunk = require('./chunk-CUT6urMc.cjs');
+const require_dist = require('./dist-VxRI6eQv.cjs');
+const require_amplitudeContext = require('./amplitudeContext-D5HSmIWg.cjs');
+const require_useIntersection = require('./useIntersection-DuwPFRY9.cjs');
+let react = require("react");
+react = require_chunk.__toESM(react);
+
+//#region src/hooks/TrackComponentVisibleEvent/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 = require_dist.SpiffyMetricsEventName.ChatComponentVisible) => {
+	const isVisible = require_useIntersection.useIntersection(element, "0px");
+	const hasTrackedEvent = (0, react.useRef)(false);
+	const { trackEvent } = require_amplitudeContext.useAmplitude();
+	const componentProps = (() => {
+		if (eventName === require_dist.SpiffyMetricsEventName.ChatComponentVisible) return {
+			chat_component: component,
+			...eventProps
+		};
+		if (eventName === require_dist.SpiffyMetricsEventName.SearchComponentVisible) return {
+			search_component: component,
+			...eventProps
+		};
+		return {
+			component,
+			...eventProps
+		};
+	})();
+	(0, react.useEffect)(() => {
+		if (isVisible && !hasTrackedEvent.current) {
+			trackEvent({
+				eventName,
+				eventProps: componentProps
+			});
+			hasTrackedEvent.current = true;
+		}
+	}, [
+		isVisible,
+		component,
+		eventProps,
+		eventName,
+		componentProps,
+		trackEvent
+	]);
+};
+
+//#endregion
+Object.defineProperty(exports, 'useTrackComponentVisibleEvent', {
+  enumerable: true,
+  get: function () {
+    return useTrackComponentVisibleEvent;
+  }
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/amplitudeContext-D5HSmIWg.cjs

@@ -0,0 +1,253 @@
+const require_chunk = require('./chunk-CUT6urMc.cjs');
+const require_events = require('./events-CgFGtanE.cjs');
+const require_dist = require('./dist-VxRI6eQv.cjs');
+const require_logger = require('./logger-BqHq67zN.cjs');
+const require_enviveConfig = require('./enviveConfig-CHXb9xwk.cjs');
+const require_org = require('./org-BNs_maoW.cjs');
+const require_app = require('./app-Di_sBmzj.cjs');
+const require_localStorageContext = require('./localStorageContext-CWc5xJ6U.cjs');
+const require_enviveConfigContext = require('./enviveConfigContext-zZAJwv87.cjs');
+const require_featureFlagServiceContext = require('./featureFlagServiceContext-DHtkQAtq.cjs');
+let react = require("react");
+react = require_chunk.__toESM(react);
+let jotai = require("jotai");
+jotai = require_chunk.__toESM(jotai);
+let react_jsx_runtime = require("react/jsx-runtime");
+react_jsx_runtime = require_chunk.__toESM(react_jsx_runtime);
+let __amplitude_analytics_browser = require("@amplitude/analytics-browser");
+__amplitude_analytics_browser = require_chunk.__toESM(__amplitude_analytics_browser);
+
+//#region src/contexts/amplitudeContext/amplitudeContext.tsx
+const AmplitudeContext = (0, react.createContext)(null);
+if (typeof window !== "undefined") {
+	require_logger.logger_default.logInfo("AmplitudeContext: window is defined");
+	window.AmplitudeReact = react.default;
+} else require_logger.logger_default.logInfo("AmplitudeContext: window is not defined");
+const AmplitudeProvider = ({ children }) => {
+	const userId = (0, jotai.useAtomValue)(require_app.userIdAtom);
+	const amplitudeApiKey = (0, jotai.useAtomValue)(require_enviveConfig.amplitudeApiKeyAtom);
+	const dataResidency = (0, jotai.useAtomValue)(require_enviveConfig.dataResidencyAtom);
+	const orgGaConfig = (0, jotai.useAtomValue)(require_org.orgAnalyticsGoogleAnalyticsConfigAtom);
+	const env = (0, jotai.useAtomValue)(require_enviveConfig.envAtom);
+	const contextSource = (0, jotai.useAtomValue)(require_enviveConfig.contextSourceAtom);
+	(0, jotai.useAtomValue)(require_enviveConfig.identifyingPrefixAtom);
+	const { getItem } = require_localStorageContext.useLocalStorage();
+	console.log("AmplitudeProvider: getting envive config");
+	const { publicKey, featureOverrides, variantUrlOverride, variantInfoOverride, show, orgShortName, featureGates } = (0, react.useContext)(require_enviveConfigContext.EnviveConfigContext) || {};
+	const { featureFlagService } = require_featureFlagServiceContext.useFeatureFlagService();
+	const [amplitudeClient, setAmplitudeClient] = react.default.useState(void 0);
+	const [internalEventTrackingEnrichment, setInternalEventTrackingEnrichment] = react.default.useState(void 0);
+	const [supplementalDefaultProps, setSupplementalDefaultProps] = react.default.useState({});
+	const isReady = Boolean(userId && featureFlagService && amplitudeApiKey && userId);
+	const getDefaultTrackingProps = (0, react.useCallback)(() => {
+		const gatesProps = featureGates ? featureGates.reduce((acc, curr) => {
+			if (curr.name && curr.value != null) return {
+				...acc,
+				[`feature_gate.${curr.name}`]: curr.value
+			};
+			return acc;
+		}, {}) : {};
+		const experimentProps = {};
+		return {
+			...gatesProps,
+			...experimentProps,
+			...supplementalDefaultProps,
+			app_id: "commerce-chat-react-component",
+			chat_id: getItem(require_dist.LocalStorageKeys.ChatId),
+			env: env || "unknown",
+			app_source: contextSource,
+			"org.short_name": orgShortName,
+			"user.id": userId,
+			"cdp.user_id": null,
+			"cdp.provider": null,
+			"event.source": "web-browser",
+			"event.type": "user-activity",
+			"event.id": null,
+			"event.channel": "web",
+			"event.timestamp": null
+		};
+	}, [
+		featureGates,
+		supplementalDefaultProps,
+		env,
+		contextSource,
+		orgShortName,
+		userId
+	]);
+	const eventPropsToPrefixedEventProps = (0, react.useCallback)((eventName, eventProps) => {
+		const prefix = eventName.toLowerCase().replace(/\s+/g, "_");
+		return Object.entries(eventProps).reduce((acc, [key, value$1]) => {
+			acc[`${prefix}.${key}`] = value$1;
+			return acc;
+		}, {});
+	}, []);
+	const amplitudeSessionReplayInit = (0, react.useCallback)(() => {
+		const isEnabled = Boolean(orgShortName === require_dist.OrgShortName.UniqueVintage && featureFlagService?.isClientSessionEnabled() && featureFlagService?.isFeatureGateEnabled(require_dist.FeatureGates.IsNewFeatureEnabled));
+		const sampleRate = 1;
+		try {
+			require_logger.logger_default.logDebug(`[spiffy-ai] amplitude session-replay initializing isEnabled=${isEnabled} sampleRate=${sampleRate}`);
+			if (!isEnabled) return isEnabled;
+			return isEnabled;
+		} catch (e) {
+			require_logger.logger_default.logError("[spiffy-ai] Error initializing amplitude session-replay", e);
+			return false;
+		}
+	}, [orgShortName, featureFlagService]);
+	const getEventTrackingEnrichment = (0, react.useCallback)(() => {
+		if (internalEventTrackingEnrichment !== void 0) return internalEventTrackingEnrichment;
+		const enrichment = {
+			name: "page-view-tracking-enrichment",
+			type: "enrichment",
+			setup: async () => void 0,
+			execute: async (event) => {
+				let enrichedEvent;
+				if (["[Amplitude] Page Viewed", `[Spiffy] ${require_dist.SpiffyMetricsEventName.BundleLoaded}`].includes(event.event_type)) {
+					const globalProperties = {};
+					if (publicKey) globalProperties["globalProperties.publicKey"] = publicKey;
+					if (featureOverrides) Object.entries(featureOverrides).forEach(([key, value$1]) => {
+						globalProperties[`globalProperties.featureOverrides.${key}`] = String(value$1);
+					});
+					if (variantUrlOverride) globalProperties["globalProperties.variantUrlOverride"] = variantUrlOverride;
+					if (variantInfoOverride) globalProperties["globalProperties.variantInfoOverride"] = JSON.stringify(variantInfoOverride);
+					if (show != null) globalProperties["globalProperties.show"] = String(show);
+					const enabledFeatures = featureFlagService.getFeatureFlags();
+					const enabledFeaturesProperties = Object.entries(enabledFeatures).reduce((acc, [key, value$1]) => ({
+						...acc,
+						[`enabledFeatures.${key}`]: `${value$1}`
+					}), {});
+					const timingProperties = { "timing.enriched_at_ms": window.performance?.now() };
+					enrichedEvent = {
+						...event,
+						event_properties: {
+							...event.event_properties,
+							...getDefaultTrackingProps(),
+							...globalProperties,
+							...enabledFeaturesProperties,
+							...timingProperties
+						}
+					};
+				} else enrichedEvent = event;
+				require_events.EventsDispatcher.dispatch(require_dist.SpiffyEvent.AMPLITUDE_EVENT, enrichedEvent);
+				return enrichedEvent;
+			}
+		};
+		setInternalEventTrackingEnrichment(enrichment);
+		return enrichment;
+	}, [
+		internalEventTrackingEnrichment,
+		getDefaultTrackingProps,
+		featureFlagService,
+		publicKey,
+		featureOverrides,
+		variantUrlOverride,
+		variantInfoOverride,
+		show
+	]);
+	(0, react.useEffect)(() => {
+		if (isReady && !amplitudeClient) {
+			const currentAmplitudeInstance = (0, __amplitude_analytics_browser.createInstance)();
+			const isSessionsEnabled = amplitudeSessionReplayInit();
+			currentAmplitudeInstance.add(getEventTrackingEnrichment());
+			currentAmplitudeInstance.init(amplitudeApiKey, userId, {
+				serverZone: dataResidency,
+				trackingOptions: { ipAddress: true },
+				autocapture: {
+					attribution: true,
+					pageViews: { trackHistoryChanges: "pathOnly" },
+					sessions: isSessionsEnabled,
+					formInteractions: false,
+					fileDownloads: false
+				}
+			});
+			setAmplitudeClient(currentAmplitudeInstance);
+		}
+	}, [
+		isReady,
+		amplitudeClient,
+		amplitudeApiKey,
+		userId,
+		dataResidency,
+		amplitudeSessionReplayInit,
+		getEventTrackingEnrichment
+	]);
+	const trackEvent = (0, react.useCallback)(async ({ eventName, eventProps, eventGroups, alsoSendToGoogleAnalytics = false }) => {
+		require_logger.logger_default.logDebug("Submitting event", eventName);
+		try {
+			const decoratedEventName = `[Spiffy] ${eventName}`;
+			if (!amplitudeClient) {
+				require_logger.logger_default.logWarn("amplitude client undefined", void 0, { event_name: decoratedEventName });
+				return;
+			}
+			const eventData = JSON.stringify({
+				eventName,
+				eventProps,
+				created_at: (/* @__PURE__ */ new Date()).toISOString()
+			});
+			const data = new TextEncoder().encode(eventData);
+			const hashBuffer = await crypto.subtle.digest("SHA-256", data);
+			const currentInsertId = Array.from(new Uint8Array(hashBuffer)).map((b) => b.toString(16).padStart(2, "0")).join("");
+			require_logger.logger_default.logDebug(`amplitude tracking ${decoratedEventName}`, null, {
+				event_name: decoratedEventName,
+				props: eventProps
+			});
+			amplitudeClient.track(decoratedEventName, {
+				...getDefaultTrackingProps(),
+				...eventProps,
+				...eventProps ? eventPropsToPrefixedEventProps(eventName, eventProps) : {}
+			}, {
+				...eventGroups,
+				insert_id: currentInsertId
+			});
+			if (alsoSendToGoogleAnalytics && orgGaConfig) {
+				require_logger.logger_default.logDebug("[spiffy-ai] GA tracking", decoratedEventName);
+				if (window.dataLayer) window.dataLayer.push({
+					event: decoratedEventName,
+					eventProps
+				});
+			}
+		} catch (err) {
+			require_logger.logger_default.logError("[spiffy-ai] Error tracking event", err, {
+				eventName,
+				eventProps
+			});
+		}
+	}, [
+		amplitudeClient,
+		getDefaultTrackingProps,
+		eventPropsToPrefixedEventProps,
+		orgGaConfig
+	]);
+	const value = (0, react.useMemo)(() => ({
+		trackEvent,
+		isReady,
+		setSupplementalDefaultProps: (props) => setSupplementalDefaultProps(props)
+	}), [
+		trackEvent,
+		isReady,
+		setSupplementalDefaultProps
+	]);
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(AmplitudeContext.Provider, {
+		value,
+		children
+	});
+};
+const useAmplitude = () => {
+	const context = (0, react.useContext)(AmplitudeContext);
+	if (!context) throw new Error("useAmplitude must be used within AmplitudeProvider");
+	return context;
+};
+
+//#endregion
+Object.defineProperty(exports, 'AmplitudeProvider', {
+  enumerable: true,
+  get: function () {
+    return AmplitudeProvider;
+  }
+});
+Object.defineProperty(exports, 'useAmplitude', {
+  enumerable: true,
+  get: function () {
+    return useAmplitude;
+  }
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"amplitudeContext-D5HSmIWg.cjs","names":["React","AmplitudeProvider: React.FC<{ children: React.ReactNode }>","userIdAtom","amplitudeApiKeyAtom","dataResidencyAtom","orgAnalyticsGoogleAnalyticsConfigAtom","envAtom","contextSourceAtom","identifyingPrefixAtom","useLocalStorage","EnviveConfigContext","useFeatureFlagService","LocalStorageKeys","value","OrgShortName","FeatureGates","enrichment: EnrichmentPlugin","enrichedEvent: Event","SpiffyMetricsEventName","globalProperties: Record<string, string>","SpiffyEvent","currentAmplitudeInstance: BrowserClient"],"sources":["../src/contexts/amplitudeContext/amplitudeContext.tsx"],"sourcesContent":["import React, {\n  createContext,\n  useContext,\n  useCallback,\n  useMemo,\n  useEffect,\n} from \"react\";\nimport { useAtomValue } from \"jotai\";\nimport { createInstance } from \"@amplitude/analytics-browser\";\nimport {\n  FeatureGates,\n  OrgShortName,\n  LocalStorageKeys,\n  SpiffyEvent,\n  AmplitudeContextType,\n  SpiffyMetricsEventName,\n  TrackEventParams,\n} from \"@envive-ai/types\";\nimport {\n  amplitudeApiKeyAtom,\n  contextSourceAtom,\n  dataResidencyAtom,\n  identifyingPrefixAtom,\n} from \"src/atoms/envive/enviveConfig\";\nimport { useLocalStorage } from \"src/contexts/localStorageContext\";\nimport { orgAnalyticsGoogleAnalyticsConfigAtom } from \"src/atoms/org/orgAnalyticsConfig\";\nimport { userIdAtom } from \"src/atoms/app\";\nimport { envAtom } from \"src/atoms/envive/enviveConfig\";\nimport Logger from \"src/application/logging/logger\";\nimport type {\n  BrowserClient,\n  EnrichmentPlugin,\n  Event,\n  ServerZoneType,\n} from \"@amplitude/analytics-types\";\nimport { EnviveConfigContext, useEnviveConfig } from \"src/contexts/enviveConfigContext/enviveConfigContext\";\nimport { useFeatureFlagService } from \"src/contexts/featureFlagServiceContext/featureFlagServiceContext\";\nimport { EventsDispatcher } from \"src/events\";\n\nconst AmplitudeContext = createContext<AmplitudeContextType | null>(null);\n\nif (typeof window !== 'undefined') {\n  Logger.logInfo('AmplitudeContext: window is defined');\n  (window as any).AmplitudeReact = React;\n} else {\n  Logger.logInfo('AmplitudeContext: window is not defined');\n}\n\nexport const AmplitudeProvider: React.FC<{ children: React.ReactNode }> = ({\n  children,\n}) => {\n  const userId = useAtomValue(userIdAtom);\n  const amplitudeApiKey = useAtomValue(amplitudeApiKeyAtom);\n  const dataResidency = useAtomValue(dataResidencyAtom);\n  const orgGaConfig = useAtomValue(orgAnalyticsGoogleAnalyticsConfigAtom);\n  const env = useAtomValue(envAtom);\n  const contextSource = useAtomValue(contextSourceAtom);\n  const identifyingPrefix = useAtomValue(identifyingPrefixAtom);\n  const { getItem } = useLocalStorage();\n  console.log('AmplitudeProvider: getting envive config');\n\n  const {publicKey,\n    featureOverrides,\n    variantUrlOverride,\n    variantInfoOverride,\n    show,\n    orgShortName,\n    featureGates } = useContext(EnviveConfigContext) || {};\n\n  const { featureFlagService } = useFeatureFlagService();\n\n  const [amplitudeClient, setAmplitudeClient] = React.useState<\n    BrowserClient | undefined\n  >(undefined);\n  const [internalEventTrackingEnrichment, setInternalEventTrackingEnrichment] =\n    React.useState<EnrichmentPlugin | undefined>(undefined);\n  const [supplementalDefaultProps, setSupplementalDefaultProps] =\n    React.useState<Record<string, unknown>>({});\n\n  const isReady = Boolean(\n    userId && featureFlagService && amplitudeApiKey && userId\n  );\n\n  const getDefaultTrackingProps = useCallback((): Record<string, unknown> => {\n    const gatesProps = featureGates\n      ? featureGates.reduce<Record<string, boolean>>((acc, curr) => {\n          if (curr.name && curr.value != null) {\n            return { ...acc, [`feature_gate.${curr.name}`]: curr.value };\n          }\n          return acc;\n        }, {})\n      : {};\n    const experimentProps = {}; // No direct equivalent for experiments in EnviveConfig yet\n\n    const orgLevelAmplitudeTrackingProps = {\n      ...gatesProps,\n      ...experimentProps,\n    };\n\n    return {\n      ...orgLevelAmplitudeTrackingProps,\n      ...supplementalDefaultProps,\n      // TODO: org_id is not directly available in EnviveConfig. Need to find a new source or derive it.\n      // org_id: orgConfig?.org?.org?.id,\n      app_id: \"commerce-chat-react-component\",\n      chat_id: getItem(LocalStorageKeys.ChatId),\n      env: env || \"unknown\",\n      app_source: contextSource,\n      \"org.short_name\": orgShortName,\n      \"user.id\": userId,\n      \"cdp.user_id\": null,\n      \"cdp.provider\": null,\n      \"event.source\": \"web-browser\",\n      \"event.type\": \"user-activity\",\n      \"event.id\": null,\n      \"event.channel\": \"web\",\n      \"event.timestamp\": null,\n    };\n  }, [\n    featureGates,\n    supplementalDefaultProps,\n    env,\n    contextSource,\n    orgShortName,\n    userId,\n  ]);\n\n  const eventPropsToPrefixedEventProps = useCallback(\n    (\n      eventName: SpiffyMetricsEventName,\n      eventProps: Record<string, unknown>\n    ): Record<string, unknown> => {\n      const prefix = eventName.toLowerCase().replace(/\\s+/g, \"_\");\n      return Object.entries(eventProps).reduce((acc, [key, value]) => {\n        acc[`${prefix}.${key}`] = value;\n        return acc;\n      }, {} as Record<string, unknown>);\n    },\n    []\n  );\n\n  const amplitudeSessionReplayInit = useCallback((): boolean => {\n    const isEnabled = Boolean(\n      orgShortName === OrgShortName.UniqueVintage &&\n        featureFlagService?.isClientSessionEnabled() &&\n        featureFlagService?.isFeatureGateEnabled(\n          FeatureGates.IsNewFeatureEnabled\n        )\n    );\n    const sampleRate = 1;\n\n    try {\n      Logger.logDebug(\n        `[spiffy-ai] amplitude session-replay initializing isEnabled=${isEnabled} sampleRate=${sampleRate}`\n      );\n\n      if (!isEnabled) {\n        return isEnabled;\n      }\n\n      // amplitudeInstance.add(sessionReplayPlugin({ sampleRate }));\n\n      return isEnabled;\n    } catch (e) {\n      Logger.logError(\n        \"[spiffy-ai] Error initializing amplitude session-replay\",\n        e\n      );\n      return false;\n    }\n  }, [orgShortName, featureFlagService]);\n\n  const getEventTrackingEnrichment = useCallback((): EnrichmentPlugin => {\n    if (internalEventTrackingEnrichment !== undefined) {\n      return internalEventTrackingEnrichment;\n    }\n\n    const enrichment: EnrichmentPlugin = {\n      name: \"page-view-tracking-enrichment\",\n      type: \"enrichment\",\n      setup: async () => undefined,\n      execute: async (event: Event): Promise<Event> => {\n        let enrichedEvent: Event;\n\n        const eventsToEnrich = [\n          \"[Amplitude] Page Viewed\",\n          `[Spiffy] ${SpiffyMetricsEventName.BundleLoaded}`,\n        ];\n\n        if (eventsToEnrich.includes(event.event_type)) {\n          const globalProperties: Record<string, string> = {};\n\n          if (publicKey) {\n            globalProperties[\"globalProperties.publicKey\"] = publicKey;\n          }\n          if (featureOverrides) {\n            Object.entries(featureOverrides).forEach(([key, value]) => {\n              globalProperties[`globalProperties.featureOverrides.${key}`] =\n                String(value);\n            });\n          }\n          if (variantUrlOverride) {\n            globalProperties[\"globalProperties.variantUrlOverride\"] =\n              variantUrlOverride;\n          }\n          if (variantInfoOverride) {\n            globalProperties[\"globalProperties.variantInfoOverride\"] =\n              JSON.stringify(variantInfoOverride);\n          }\n          if (show != null) {\n            globalProperties[\"globalProperties.show\"] = String(show);\n          }\n\n          const enabledFeatures = featureFlagService!.getFeatureFlags();\n          const enabledFeaturesProperties = Object.entries(\n            enabledFeatures\n          ).reduce<Record<string, string>>(\n            (acc, [key, value]) => ({\n              ...acc,\n              [`enabledFeatures.${key}`]: `${value}`,\n            }),\n            {}\n          );\n\n          const timingProperties = {\n            \"timing.enriched_at_ms\": window.performance?.now(),\n          };\n\n          enrichedEvent = {\n            ...event,\n            event_properties: {\n              ...event.event_properties,\n              ...getDefaultTrackingProps(),\n              ...globalProperties,\n              ...enabledFeaturesProperties,\n              ...timingProperties,\n            },\n          };\n        } else {\n          enrichedEvent = event;\n        }\n\n        EventsDispatcher.dispatch(SpiffyEvent.AMPLITUDE_EVENT, enrichedEvent);\n\n        return enrichedEvent;\n      },\n    };\n    setInternalEventTrackingEnrichment(enrichment);\n    return enrichment;\n  }, [\n    internalEventTrackingEnrichment,\n    getDefaultTrackingProps,\n    featureFlagService,\n    publicKey,\n    featureOverrides,\n    variantUrlOverride,\n    variantInfoOverride,\n    show,\n  ]);\n\n  useEffect(() => {\n    if (isReady && !amplitudeClient) {\n      const currentAmplitudeInstance: BrowserClient = createInstance();\n      const isSessionsEnabled = amplitudeSessionReplayInit();\n      currentAmplitudeInstance.add(getEventTrackingEnrichment());\n      currentAmplitudeInstance.init(amplitudeApiKey!, userId!, {\n        serverZone: dataResidency as ServerZoneType,\n        trackingOptions: {\n          ipAddress: true,\n        },\n        autocapture: {\n          attribution: true,\n          pageViews: {\n            trackHistoryChanges: \"pathOnly\",\n          },\n          sessions: isSessionsEnabled,\n          formInteractions: false,\n          fileDownloads: false,\n        },\n      });\n      setAmplitudeClient(currentAmplitudeInstance);\n    }\n  }, [\n    isReady,\n    amplitudeClient,\n    amplitudeApiKey,\n    userId,\n    dataResidency,\n    amplitudeSessionReplayInit,\n    getEventTrackingEnrichment,\n  ]);\n\n  const trackEvent = useCallback(\n    async ({\n      eventName,\n      eventProps,\n      eventGroups,\n      alsoSendToGoogleAnalytics = false,\n    }: TrackEventParams): Promise<void> => {\n      Logger.logDebug(\"Submitting event\", eventName);\n      try {\n        const decoratedEventName = `[Spiffy] ${eventName}`;\n\n        if (!amplitudeClient) {\n          Logger.logWarn(\"amplitude client undefined\", undefined, {\n            event_name: decoratedEventName,\n          });\n          return;\n        }\n\n        const eventData = JSON.stringify({\n          eventName,\n          eventProps,\n          created_at: new Date().toISOString(),\n        });\n        const encoder = new TextEncoder();\n        const data = encoder.encode(eventData);\n        // calculate a hash of the event properties to use as the insert_id so that duplicate events\n        // are automatically dropped by Amplitude\n        const hashBuffer = await crypto.subtle.digest(\"SHA-256\", data);\n        const hashArray = Array.from(new Uint8Array(hashBuffer));\n        const currentInsertId = hashArray\n          .map((b) => b.toString(16).padStart(2, \"0\"))\n          .join(\"\");\n\n        Logger.logDebug(`amplitude tracking ${decoratedEventName}`, null, {\n          event_name: decoratedEventName,\n          props: eventProps,\n        });\n\n        amplitudeClient.track(\n          decoratedEventName,\n          {\n            ...getDefaultTrackingProps(),\n            ...eventProps,\n            ...(eventProps\n              ? eventPropsToPrefixedEventProps(eventName, eventProps)\n              : {}),\n          },\n          {\n            ...eventGroups,\n            insert_id: currentInsertId,\n          }\n        );\n\n        if (alsoSendToGoogleAnalytics && orgGaConfig) {\n          // TODO: Add in windowDataLayerService or context alternative and hook it up here\n          Logger.logDebug(\"[spiffy-ai] GA tracking\", decoratedEventName);\n          if (window.dataLayer) {\n            (window.dataLayer as any[]).push({\n              event: decoratedEventName,\n              eventProps: eventProps,\n            });\n          }\n        }\n      } catch (err) {\n        Logger.logError(\"[spiffy-ai] Error tracking event\", err, {\n          eventName,\n          eventProps,\n        });\n      }\n    },\n    [\n      amplitudeClient,\n      getDefaultTrackingProps,\n      eventPropsToPrefixedEventProps,\n      orgGaConfig,\n    ]\n  );\n\n  const value = useMemo(\n    () => ({\n      trackEvent,\n      isReady,\n      setSupplementalDefaultProps: (props: Record<string, unknown>) =>\n        setSupplementalDefaultProps(props),\n    }),\n    [trackEvent, isReady, setSupplementalDefaultProps]\n  );\n\n  return (\n    <AmplitudeContext.Provider value={value}>\n      {children}\n    </AmplitudeContext.Provider>\n  );\n};\n\nexport const useAmplitude = () => {\n  const context = useContext(AmplitudeContext);\n  if (!context) {\n    throw new Error(\"useAmplitude must be used within AmplitudeProvider\");\n  }\n  return context;\n};\n"],"mappings":"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"}