@envive-ai/react-hooks 0.3.63 → 0.3.65

package/dist/hooks/TrackComponentVisibleEvent/useTrackComponentVisibleEvent.js

@@ -6,7 +6,7 @@ import "../../atoms/app/index.js";
 import { useAmplitude } from "../../contexts/amplitudeContext/amplitudeContext.js";
 import { extractPageContext } from "../WidgetInteraction/utils.js";
 import { useIntersection } from "../Intersection/useIntersection.js";
-import { useEffect, useRef } from "react";
+import { useEffect, useRef, useState } from "react";
 import { useAtomValue } from "jotai";
 
 //#region src/hooks/TrackComponentVisibleEvent/useTrackComponentVisibleEvent.ts
@@ -27,7 +27,13 @@ const safeNow = () => {
 	}
 };
 const useTrackComponentVisibleEvent = (element, eventProps, rootMargin = "0px", enabled = true) => {
-	const isVisible = useIntersection(element, rootMargin, eventProps);
+	const [visibilitySource, setVisibilitySource] = useState("pending");
+	const isVisible = useIntersection(element, rootMargin, eventProps, () => {
+		setVisibilitySource((prev) => prev === "pending" ? "fallback" : prev);
+	});
+	useEffect(() => {
+		if (isVisible) setVisibilitySource((prev) => prev === "pending" ? "observer" : prev);
+	}, [isVisible]);
 	const hasTrackedEvent = useRef(false);
 	const { trackEvent } = useAmplitude();
 	const variantInfo = useAtomValue(pageVariantInfoAtom);
@@ -72,9 +78,12 @@ const useTrackComponentVisibleEvent = (element, eventProps, rootMargin = "0px",
 		eventProps,
 		trackEvent
 	]);
-	return { isVisible };
+	return {
+		isVisible,
+		visibilitySource
+	};
 };
 
 //#endregion
 export { useTrackComponentVisibleEvent };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/hooks/WidgetLoadDiagnostics/index.cjs

@@ -0,0 +1,4 @@
+const require_useWidgetLoadDiagnostics = require('./useWidgetLoadDiagnostics.cjs');
+
+exports.WIDGET_LOAD_STALL_MS = require_useWidgetLoadDiagnostics.WIDGET_LOAD_STALL_MS;
+exports.useWidgetLoadDiagnostics = require_useWidgetLoadDiagnostics.useWidgetLoadDiagnostics;

package/dist/hooks/WidgetLoadDiagnostics/index.d.cts

@@ -0,0 +1,2 @@
+import { WIDGET_LOAD_STALL_MS, WidgetLoadDiagnosticsInput, WidgetVisibilitySource, useWidgetLoadDiagnostics } from "./useWidgetLoadDiagnostics.cjs";
+export { WIDGET_LOAD_STALL_MS, type WidgetLoadDiagnosticsInput, type WidgetVisibilitySource, useWidgetLoadDiagnostics };

package/dist/hooks/WidgetLoadDiagnostics/index.d.ts

@@ -0,0 +1,2 @@
+import { WIDGET_LOAD_STALL_MS, WidgetLoadDiagnosticsInput, WidgetVisibilitySource, useWidgetLoadDiagnostics } from "./useWidgetLoadDiagnostics.js";
+export { WIDGET_LOAD_STALL_MS, type WidgetLoadDiagnosticsInput, type WidgetVisibilitySource, useWidgetLoadDiagnostics };

package/dist/hooks/WidgetLoadDiagnostics/index.js

@@ -0,0 +1,3 @@
+import { WIDGET_LOAD_STALL_MS, useWidgetLoadDiagnostics } from "./useWidgetLoadDiagnostics.js";
+
+export { WIDGET_LOAD_STALL_MS, useWidgetLoadDiagnostics };

package/dist/hooks/WidgetLoadDiagnostics/useWidgetLoadDiagnostics.cjs

@@ -0,0 +1,122 @@
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+const require_eventNames = require('../../services/amplitudeService/eventNames.cjs');
+require('../../services/amplitudeService/amplitudeService.cjs');
+const require_variant = require('../../atoms/app/variant.cjs');
+require('../../atoms/app/index.cjs');
+const require_amplitudeContext = require('../../contexts/amplitudeContext/amplitudeContext.cjs');
+const require_hooks_WidgetInteraction_utils = require('../WidgetInteraction/utils.cjs');
+let react = require("react");
+let jotai = require("jotai");
+
+//#region src/hooks/WidgetLoadDiagnostics/useWidgetLoadDiagnostics.ts
+const WIDGET_LOAD_STALL_MS = 5e3;
+const connectionType = () => {
+	try {
+		return navigator.connection?.effectiveType;
+	} catch {
+		return;
+	}
+};
+const now = () => {
+	try {
+		return typeof window !== "undefined" && window.performance?.now ? window.performance.now() : Date.now();
+	} catch {
+		return Date.now();
+	}
+};
+/**
+* Emits the layered `[Envive] Diagnostics` widget-load net so eng can measure not just what
+* loads, but the negative space between layers — the failures that fire nothing today:
+*
+*   widget_mounted (ungated) → [Envive] Widget Rendered (visible) → widget_load_outcome
+*
+* - `widget_mounted` fires on mount regardless of visibility, so a widget that mounts but never
+*   becomes visible (the suspected infinite-load crux) shows up as a *mounted with no rendered*
+*   gap instead of being invisible to analytics entirely.
+* - `widget_load_outcome` fires once the widget's own requests settle
+*   (content_loaded / static_fallback / error).
+* - `widget_load_stalled` fires if it's still loading at WIDGET_LOAD_STALL_MS AND still mounted.
+*   The timer is cleared on unmount, so a shopper who navigates away first never trips it —
+*   "stalled with no later outcome" is therefore a clean stuck signal, undiluted by abandonment.
+*
+* `load_id` correlates all of the above (and is threaded onto `[Envive] Widget Rendered`) so
+* the gaps are joinable per load.
+*/
+const useWidgetLoadDiagnostics = (input) => {
+	const { enabled, loadId, widgetType, widgetConfigId, startLoading, ownRequestsSettled, hardcopyContent } = input;
+	const { trackEvent } = require_amplitudeContext.useAmplitude();
+	const variantInfo = (0, jotai.useAtomValue)(require_variant.pageVariantInfoAtom);
+	const inputRef = (0, react.useRef)(input);
+	inputRef.current = input;
+	const emit = (props) => {
+		trackEvent({
+			eventName: require_eventNames.EnviveMetricsEventName.Diagnostics,
+			eventProps: {
+				load_id: loadId,
+				widget_type: widgetType,
+				widget_config_id: widgetConfigId,
+				connection_type: connectionType(),
+				context: variantInfo ? require_hooks_WidgetInteraction_utils.extractPageContext(variantInfo) : null,
+				...props
+			}
+		});
+	};
+	const mountFiredRef = (0, react.useRef)(false);
+	(0, react.useEffect)(() => {
+		if (!enabled || mountFiredRef.current) return;
+		mountFiredRef.current = true;
+		emit({ type: "widget_mounted" });
+	}, [enabled]);
+	const visibleAtRef = (0, react.useRef)(null);
+	(0, react.useEffect)(() => {
+		if (startLoading && visibleAtRef.current === null) visibleAtRef.current = now();
+	}, [startLoading]);
+	const outcomeFiredRef = (0, react.useRef)(false);
+	(0, react.useEffect)(() => {
+		if (!enabled || !startLoading || !ownRequestsSettled || outcomeFiredRef.current) return;
+		outcomeFiredRef.current = true;
+		const elapsed_ms = visibleAtRef.current !== null ? Math.round(now() - visibleAtRef.current) : void 0;
+		let outcome;
+		let reason;
+		if (!hardcopyContent) {
+			outcome = "error";
+			reason = inputRef.current.hardcopyErrorReason ?? "no_content";
+		} else if (hardcopyContent.servedFrom === "static") {
+			outcome = "static_fallback";
+			reason = hardcopyContent.fallbackReason;
+		} else outcome = "content_loaded";
+		emit({
+			type: "widget_load_outcome",
+			outcome,
+			reason,
+			elapsed_ms,
+			visibility_source: inputRef.current.visibilitySource
+		});
+	}, [
+		enabled,
+		startLoading,
+		ownRequestsSettled,
+		hardcopyContent
+	]);
+	(0, react.useEffect)(() => {
+		if (!enabled || !startLoading || ownRequestsSettled) return void 0;
+		const timer = setTimeout(() => {
+			emit({
+				type: "widget_load_stalled",
+				elapsed_ms: visibleAtRef.current !== null ? Math.round(now() - visibleAtRef.current) : WIDGET_LOAD_STALL_MS,
+				pending_requests: inputRef.current.pendingRequests,
+				visibility_source: inputRef.current.visibilitySource
+			});
+		}, WIDGET_LOAD_STALL_MS);
+		return () => clearTimeout(timer);
+	}, [
+		enabled,
+		startLoading,
+		ownRequestsSettled
+	]);
+};
+
+//#endregion
+exports.WIDGET_LOAD_STALL_MS = WIDGET_LOAD_STALL_MS;
+exports.useWidgetLoadDiagnostics = useWidgetLoadDiagnostics;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"useWidgetLoadDiagnostics.cjs","names":["useAmplitude","pageVariantInfoAtom","EnviveMetricsEventName","extractPageContext","outcome: string","reason: string | undefined"],"sources":["../../../src/hooks/WidgetLoadDiagnostics/useWidgetLoadDiagnostics.ts"],"sourcesContent":["import { useAtomValue } from 'jotai';\nimport { useEffect, useRef } from 'react';\nimport { pageVariantInfoAtom } from 'src/atoms/app';\nimport { useAmplitude } from 'src/contexts/amplitudeContext/amplitudeContext';\nimport { HardcopyResponse } from 'src/contexts/hardcopyContext';\nimport { PageVariantInfo } from 'src/contexts/pageContext/types';\nimport { WidgetTypeV3 } from 'src/contexts/typesV3';\nimport { extractPageContext } from 'src/hooks/WidgetInteraction/utils';\nimport { EnviveMetricsEventName } from 'src/services/amplitudeService/amplitudeService';\n\n// Fired if a widget is still loading this long after it became visible. Kept at/just above\n// the hardcopy timeout (HARDCOPY_TIMEOUT_MS, 4s) so a normal timeout → static-fallback settles\n// first and does NOT trip a stall; a stall here is a genuine anomaly (e.g. a config hang).\n// Mirrors WIDGET_LOADING_WATCHDOG_MS (the console-only watchdog in withBaseWidget).\nexport const WIDGET_LOAD_STALL_MS = 5000;\n\n// 'pending' = visibility not confirmed by either path when the event fired (e.g. a\n// deferLoading:false widget that loaded eagerly, before the observer reported).\nexport type WidgetVisibilitySource = 'observer' | 'fallback' | 'pending';\n\nexport interface WidgetLoadDiagnosticsInput {\n  /** Gate. No events are emitted unless true. On by default; a Statsig kill switch can disable it. */\n  enabled: boolean;\n  /** Correlates this widget's mount / rendered / outcome / stall events for a single load. */\n  loadId: string;\n  widgetType: WidgetTypeV3;\n  widgetConfigId?: string;\n  /** The widget became visible and started loading its own requests. */\n  startLoading: boolean;\n  /** This widget's own hardcopy / widgetConfig / uiConfig requests have all settled. */\n  ownRequestsSettled: boolean;\n  /** Present once hardcopy resolves; carries `servedFrom` (content_loaded vs static_fallback). */\n  hardcopyContent?: HardcopyResponse;\n  /** Whether visibility came from the observer or the reconcile fallback. */\n  visibilitySource: WidgetVisibilitySource;\n  /** Names of this widget's still-unsettled requests, reported on a stall. */\n  pendingRequests: string[];\n  /** Set when this widget's own hardcopy request rejected (no content — not a static fallback). */\n  hardcopyErrorReason?: string;\n}\n\nconst connectionType = (): string | undefined => {\n  try {\n    // Network Information API — Chromium/Android only, undefined on iOS Safari (our key population).\n    return (navigator as Navigator & { connection?: { effectiveType?: string } }).connection\n      ?.effectiveType;\n  } catch {\n    return undefined;\n  }\n};\n\nconst now = (): number => {\n  try {\n    return typeof window !== 'undefined' && window.performance?.now\n      ? window.performance.now()\n      : Date.now();\n  } catch {\n    return Date.now();\n  }\n};\n\n/**\n * Emits the layered `[Envive] Diagnostics` widget-load net so eng can measure not just what\n * loads, but the negative space between layers — the failures that fire nothing today:\n *\n *   widget_mounted (ungated) → [Envive] Widget Rendered (visible) → widget_load_outcome\n *\n * - `widget_mounted` fires on mount regardless of visibility, so a widget that mounts but never\n *   becomes visible (the suspected infinite-load crux) shows up as a *mounted with no rendered*\n *   gap instead of being invisible to analytics entirely.\n * - `widget_load_outcome` fires once the widget's own requests settle\n *   (content_loaded / static_fallback / error).\n * - `widget_load_stalled` fires if it's still loading at WIDGET_LOAD_STALL_MS AND still mounted.\n *   The timer is cleared on unmount, so a shopper who navigates away first never trips it —\n *   \"stalled with no later outcome\" is therefore a clean stuck signal, undiluted by abandonment.\n *\n * `load_id` correlates all of the above (and is threaded onto `[Envive] Widget Rendered`) so\n * the gaps are joinable per load.\n */\nexport const useWidgetLoadDiagnostics = (input: WidgetLoadDiagnosticsInput): void => {\n  const {\n    enabled,\n    loadId,\n    widgetType,\n    widgetConfigId,\n    startLoading,\n    ownRequestsSettled,\n    hardcopyContent,\n  } = input;\n\n  const { trackEvent } = useAmplitude();\n  const variantInfo = useAtomValue(pageVariantInfoAtom);\n\n  // Latest input, read inside the deferred stall/outcome callbacks (pendingRequests and\n  // visibilitySource churn as requests settle / the fallback engages).\n  const inputRef = useRef(input);\n  inputRef.current = input;\n\n  const emit = (props: Record<string, unknown>) => {\n    trackEvent({\n      eventName: EnviveMetricsEventName.Diagnostics,\n      eventProps: {\n        load_id: loadId,\n        widget_type: widgetType,\n        widget_config_id: widgetConfigId,\n        connection_type: connectionType(),\n        context: variantInfo ? extractPageContext(variantInfo as PageVariantInfo) : null,\n        ...props,\n      },\n    });\n  };\n\n  // Layer 0 — mount. Ungated by visibility: the baseline that fires even when the widget never\n  // becomes visible, so never-visible failures are a measurable gap rather than silence.\n  const mountFiredRef = useRef(false);\n  useEffect(() => {\n    if (!enabled || mountFiredRef.current) return;\n    mountFiredRef.current = true;\n    emit({ type: 'widget_mounted' });\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [enabled]);\n\n  // t0 — when the widget became visible / started loading.\n  const visibleAtRef = useRef<number | null>(null);\n  useEffect(() => {\n    if (startLoading && visibleAtRef.current === null) visibleAtRef.current = now();\n  }, [startLoading]);\n\n  // Layer 2 — terminal outcome, once, when this widget's own requests settle.\n  const outcomeFiredRef = useRef(false);\n  useEffect(() => {\n    if (!enabled || !startLoading || !ownRequestsSettled || outcomeFiredRef.current) return;\n    outcomeFiredRef.current = true;\n\n    const elapsed_ms =\n      visibleAtRef.current !== null ? Math.round(now() - visibleAtRef.current) : undefined;\n\n    let outcome: string;\n    let reason: string | undefined;\n    if (!hardcopyContent) {\n      outcome = 'error';\n      reason = inputRef.current.hardcopyErrorReason ?? 'no_content';\n    } else if (hardcopyContent.servedFrom === 'static') {\n      outcome = 'static_fallback';\n      reason = hardcopyContent.fallbackReason;\n    } else {\n      outcome = 'content_loaded';\n    }\n\n    emit({\n      type: 'widget_load_outcome',\n      outcome,\n      reason,\n      elapsed_ms,\n      visibility_source: inputRef.current.visibilitySource,\n    });\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [enabled, startLoading, ownRequestsSettled, hardcopyContent]);\n\n  // Layer 1.5 — stall. Only arms while loading; cleared on unmount, so abandonment never trips it.\n  useEffect(() => {\n    if (!enabled || !startLoading || ownRequestsSettled) return undefined;\n    const timer = setTimeout(() => {\n      const elapsed_ms =\n        visibleAtRef.current !== null\n          ? Math.round(now() - visibleAtRef.current)\n          : WIDGET_LOAD_STALL_MS;\n      emit({\n        type: 'widget_load_stalled',\n        elapsed_ms,\n        pending_requests: inputRef.current.pendingRequests,\n        visibility_source: inputRef.current.visibilitySource,\n      });\n    }, WIDGET_LOAD_STALL_MS);\n    return () => clearTimeout(timer);\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [enabled, startLoading, ownRequestsSettled]);\n};\n"],"mappings":";;;;;;;;;;;AAcA,MAAa,uBAAuB;AA2BpC,MAAM,uBAA2C;AAC/C,KAAI;AAEF,SAAQ,UAAsE,YAC1E;SACE;AACN;;;AAIJ,MAAM,YAAoB;AACxB,KAAI;AACF,SAAO,OAAO,WAAW,eAAe,OAAO,aAAa,MACxD,OAAO,YAAY,KAAK,GACxB,KAAK,KAAK;SACR;AACN,SAAO,KAAK,KAAK;;;;;;;;;;;;;;;;;;;;;AAsBrB,MAAa,4BAA4B,UAA4C;CACnF,MAAM,EACJ,SACA,QACA,YACA,gBACA,cACA,oBACA,oBACE;CAEJ,MAAM,EAAE,eAAeA,uCAAc;CACrC,MAAM,sCAA2BC,oCAAoB;CAIrD,MAAM,6BAAkB,MAAM;AAC9B,UAAS,UAAU;CAEnB,MAAM,QAAQ,UAAmC;AAC/C,aAAW;GACT,WAAWC,0CAAuB;GAClC,YAAY;IACV,SAAS;IACT,aAAa;IACb,kBAAkB;IAClB,iBAAiB,gBAAgB;IACjC,SAAS,cAAcC,yDAAmB,YAA+B,GAAG;IAC5E,GAAG;IACJ;GACF,CAAC;;CAKJ,MAAM,kCAAuB,MAAM;AACnC,4BAAgB;AACd,MAAI,CAAC,WAAW,cAAc,QAAS;AACvC,gBAAc,UAAU;AACxB,OAAK,EAAE,MAAM,kBAAkB,CAAC;IAE/B,CAAC,QAAQ,CAAC;CAGb,MAAM,iCAAqC,KAAK;AAChD,4BAAgB;AACd,MAAI,gBAAgB,aAAa,YAAY,KAAM,cAAa,UAAU,KAAK;IAC9E,CAAC,aAAa,CAAC;CAGlB,MAAM,oCAAyB,MAAM;AACrC,4BAAgB;AACd,MAAI,CAAC,WAAW,CAAC,gBAAgB,CAAC,sBAAsB,gBAAgB,QAAS;AACjF,kBAAgB,UAAU;EAE1B,MAAM,aACJ,aAAa,YAAY,OAAO,KAAK,MAAM,KAAK,GAAG,aAAa,QAAQ,GAAG;EAE7E,IAAIC;EACJ,IAAIC;AACJ,MAAI,CAAC,iBAAiB;AACpB,aAAU;AACV,YAAS,SAAS,QAAQ,uBAAuB;aACxC,gBAAgB,eAAe,UAAU;AAClD,aAAU;AACV,YAAS,gBAAgB;QAEzB,WAAU;AAGZ,OAAK;GACH,MAAM;GACN;GACA;GACA;GACA,mBAAmB,SAAS,QAAQ;GACrC,CAAC;IAED;EAAC;EAAS;EAAc;EAAoB;EAAgB,CAAC;AAGhE,4BAAgB;AACd,MAAI,CAAC,WAAW,CAAC,gBAAgB,mBAAoB,QAAO;EAC5D,MAAM,QAAQ,iBAAiB;AAK7B,QAAK;IACH,MAAM;IACN,YALA,aAAa,YAAY,OACrB,KAAK,MAAM,KAAK,GAAG,aAAa,QAAQ,GACxC;IAIJ,kBAAkB,SAAS,QAAQ;IACnC,mBAAmB,SAAS,QAAQ;IACrC,CAAC;KACD,qBAAqB;AACxB,eAAa,aAAa,MAAM;IAE/B;EAAC;EAAS;EAAc;EAAmB,CAAC"}

package/dist/hooks/WidgetLoadDiagnostics/useWidgetLoadDiagnostics.d.cts

@@ -0,0 +1,48 @@
+import { WidgetTypeV3 } from "../../contexts/typesV3.cjs";
+import { HardcopyResponse } from "../../services/hardcopyService/hardcopyService.cjs";
+
+//#region src/hooks/WidgetLoadDiagnostics/useWidgetLoadDiagnostics.d.ts
+declare const WIDGET_LOAD_STALL_MS = 5000;
+type WidgetVisibilitySource = 'observer' | 'fallback' | 'pending';
+interface WidgetLoadDiagnosticsInput {
+  /** Gate. No events are emitted unless true. On by default; a Statsig kill switch can disable it. */
+  enabled: boolean;
+  /** Correlates this widget's mount / rendered / outcome / stall events for a single load. */
+  loadId: string;
+  widgetType: WidgetTypeV3;
+  widgetConfigId?: string;
+  /** The widget became visible and started loading its own requests. */
+  startLoading: boolean;
+  /** This widget's own hardcopy / widgetConfig / uiConfig requests have all settled. */
+  ownRequestsSettled: boolean;
+  /** Present once hardcopy resolves; carries `servedFrom` (content_loaded vs static_fallback). */
+  hardcopyContent?: HardcopyResponse;
+  /** Whether visibility came from the observer or the reconcile fallback. */
+  visibilitySource: WidgetVisibilitySource;
+  /** Names of this widget's still-unsettled requests, reported on a stall. */
+  pendingRequests: string[];
+  /** Set when this widget's own hardcopy request rejected (no content — not a static fallback). */
+  hardcopyErrorReason?: string;
+}
+/**
+ * Emits the layered `[Envive] Diagnostics` widget-load net so eng can measure not just what
+ * loads, but the negative space between layers — the failures that fire nothing today:
+ *
+ *   widget_mounted (ungated) → [Envive] Widget Rendered (visible) → widget_load_outcome
+ *
+ * - `widget_mounted` fires on mount regardless of visibility, so a widget that mounts but never
+ *   becomes visible (the suspected infinite-load crux) shows up as a *mounted with no rendered*
+ *   gap instead of being invisible to analytics entirely.
+ * - `widget_load_outcome` fires once the widget's own requests settle
+ *   (content_loaded / static_fallback / error).
+ * - `widget_load_stalled` fires if it's still loading at WIDGET_LOAD_STALL_MS AND still mounted.
+ *   The timer is cleared on unmount, so a shopper who navigates away first never trips it —
+ *   "stalled with no later outcome" is therefore a clean stuck signal, undiluted by abandonment.
+ *
+ * `load_id` correlates all of the above (and is threaded onto `[Envive] Widget Rendered`) so
+ * the gaps are joinable per load.
+ */
+declare const useWidgetLoadDiagnostics: (input: WidgetLoadDiagnosticsInput) => void;
+//#endregion
+export { WIDGET_LOAD_STALL_MS, WidgetLoadDiagnosticsInput, WidgetVisibilitySource, useWidgetLoadDiagnostics };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/hooks/WidgetLoadDiagnostics/useWidgetLoadDiagnostics.d.ts

@@ -0,0 +1,48 @@
+import { WidgetTypeV3 } from "../../contexts/typesV3.js";
+import { HardcopyResponse } from "../../services/hardcopyService/hardcopyService.js";
+
+//#region src/hooks/WidgetLoadDiagnostics/useWidgetLoadDiagnostics.d.ts
+declare const WIDGET_LOAD_STALL_MS = 5000;
+type WidgetVisibilitySource = 'observer' | 'fallback' | 'pending';
+interface WidgetLoadDiagnosticsInput {
+  /** Gate. No events are emitted unless true. On by default; a Statsig kill switch can disable it. */
+  enabled: boolean;
+  /** Correlates this widget's mount / rendered / outcome / stall events for a single load. */
+  loadId: string;
+  widgetType: WidgetTypeV3;
+  widgetConfigId?: string;
+  /** The widget became visible and started loading its own requests. */
+  startLoading: boolean;
+  /** This widget's own hardcopy / widgetConfig / uiConfig requests have all settled. */
+  ownRequestsSettled: boolean;
+  /** Present once hardcopy resolves; carries `servedFrom` (content_loaded vs static_fallback). */
+  hardcopyContent?: HardcopyResponse;
+  /** Whether visibility came from the observer or the reconcile fallback. */
+  visibilitySource: WidgetVisibilitySource;
+  /** Names of this widget's still-unsettled requests, reported on a stall. */
+  pendingRequests: string[];
+  /** Set when this widget's own hardcopy request rejected (no content — not a static fallback). */
+  hardcopyErrorReason?: string;
+}
+/**
+ * Emits the layered `[Envive] Diagnostics` widget-load net so eng can measure not just what
+ * loads, but the negative space between layers — the failures that fire nothing today:
+ *
+ *   widget_mounted (ungated) → [Envive] Widget Rendered (visible) → widget_load_outcome
+ *
+ * - `widget_mounted` fires on mount regardless of visibility, so a widget that mounts but never
+ *   becomes visible (the suspected infinite-load crux) shows up as a *mounted with no rendered*
+ *   gap instead of being invisible to analytics entirely.
+ * - `widget_load_outcome` fires once the widget's own requests settle
+ *   (content_loaded / static_fallback / error).
+ * - `widget_load_stalled` fires if it's still loading at WIDGET_LOAD_STALL_MS AND still mounted.
+ *   The timer is cleared on unmount, so a shopper who navigates away first never trips it —
+ *   "stalled with no later outcome" is therefore a clean stuck signal, undiluted by abandonment.
+ *
+ * `load_id` correlates all of the above (and is threaded onto `[Envive] Widget Rendered`) so
+ * the gaps are joinable per load.
+ */
+declare const useWidgetLoadDiagnostics: (input: WidgetLoadDiagnosticsInput) => void;
+//#endregion
+export { WIDGET_LOAD_STALL_MS, WidgetLoadDiagnosticsInput, WidgetVisibilitySource, useWidgetLoadDiagnostics };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/hooks/WidgetLoadDiagnostics/useWidgetLoadDiagnostics.js

@@ -0,0 +1,120 @@
+import { EnviveMetricsEventName } from "../../services/amplitudeService/eventNames.js";
+import "../../services/amplitudeService/amplitudeService.js";
+import { pageVariantInfoAtom } from "../../atoms/app/variant.js";
+import "../../atoms/app/index.js";
+import { useAmplitude } from "../../contexts/amplitudeContext/amplitudeContext.js";
+import { extractPageContext } from "../WidgetInteraction/utils.js";
+import { useEffect, useRef } from "react";
+import { useAtomValue } from "jotai";
+
+//#region src/hooks/WidgetLoadDiagnostics/useWidgetLoadDiagnostics.ts
+const WIDGET_LOAD_STALL_MS = 5e3;
+const connectionType = () => {
+	try {
+		return navigator.connection?.effectiveType;
+	} catch {
+		return;
+	}
+};
+const now = () => {
+	try {
+		return typeof window !== "undefined" && window.performance?.now ? window.performance.now() : Date.now();
+	} catch {
+		return Date.now();
+	}
+};
+/**
+* Emits the layered `[Envive] Diagnostics` widget-load net so eng can measure not just what
+* loads, but the negative space between layers — the failures that fire nothing today:
+*
+*   widget_mounted (ungated) → [Envive] Widget Rendered (visible) → widget_load_outcome
+*
+* - `widget_mounted` fires on mount regardless of visibility, so a widget that mounts but never
+*   becomes visible (the suspected infinite-load crux) shows up as a *mounted with no rendered*
+*   gap instead of being invisible to analytics entirely.
+* - `widget_load_outcome` fires once the widget's own requests settle
+*   (content_loaded / static_fallback / error).
+* - `widget_load_stalled` fires if it's still loading at WIDGET_LOAD_STALL_MS AND still mounted.
+*   The timer is cleared on unmount, so a shopper who navigates away first never trips it —
+*   "stalled with no later outcome" is therefore a clean stuck signal, undiluted by abandonment.
+*
+* `load_id` correlates all of the above (and is threaded onto `[Envive] Widget Rendered`) so
+* the gaps are joinable per load.
+*/
+const useWidgetLoadDiagnostics = (input) => {
+	const { enabled, loadId, widgetType, widgetConfigId, startLoading, ownRequestsSettled, hardcopyContent } = input;
+	const { trackEvent } = useAmplitude();
+	const variantInfo = useAtomValue(pageVariantInfoAtom);
+	const inputRef = useRef(input);
+	inputRef.current = input;
+	const emit = (props) => {
+		trackEvent({
+			eventName: EnviveMetricsEventName.Diagnostics,
+			eventProps: {
+				load_id: loadId,
+				widget_type: widgetType,
+				widget_config_id: widgetConfigId,
+				connection_type: connectionType(),
+				context: variantInfo ? extractPageContext(variantInfo) : null,
+				...props
+			}
+		});
+	};
+	const mountFiredRef = useRef(false);
+	useEffect(() => {
+		if (!enabled || mountFiredRef.current) return;
+		mountFiredRef.current = true;
+		emit({ type: "widget_mounted" });
+	}, [enabled]);
+	const visibleAtRef = useRef(null);
+	useEffect(() => {
+		if (startLoading && visibleAtRef.current === null) visibleAtRef.current = now();
+	}, [startLoading]);
+	const outcomeFiredRef = useRef(false);
+	useEffect(() => {
+		if (!enabled || !startLoading || !ownRequestsSettled || outcomeFiredRef.current) return;
+		outcomeFiredRef.current = true;
+		const elapsed_ms = visibleAtRef.current !== null ? Math.round(now() - visibleAtRef.current) : void 0;
+		let outcome;
+		let reason;
+		if (!hardcopyContent) {
+			outcome = "error";
+			reason = inputRef.current.hardcopyErrorReason ?? "no_content";
+		} else if (hardcopyContent.servedFrom === "static") {
+			outcome = "static_fallback";
+			reason = hardcopyContent.fallbackReason;
+		} else outcome = "content_loaded";
+		emit({
+			type: "widget_load_outcome",
+			outcome,
+			reason,
+			elapsed_ms,
+			visibility_source: inputRef.current.visibilitySource
+		});
+	}, [
+		enabled,
+		startLoading,
+		ownRequestsSettled,
+		hardcopyContent
+	]);
+	useEffect(() => {
+		if (!enabled || !startLoading || ownRequestsSettled) return void 0;
+		const timer = setTimeout(() => {
+			emit({
+				type: "widget_load_stalled",
+				elapsed_ms: visibleAtRef.current !== null ? Math.round(now() - visibleAtRef.current) : WIDGET_LOAD_STALL_MS,
+				pending_requests: inputRef.current.pendingRequests,
+				visibility_source: inputRef.current.visibilitySource
+			});
+		}, WIDGET_LOAD_STALL_MS);
+		return () => clearTimeout(timer);
+	}, [
+		enabled,
+		startLoading,
+		ownRequestsSettled
+	]);
+};
+
+//#endregion
+export { WIDGET_LOAD_STALL_MS, useWidgetLoadDiagnostics };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"useWidgetLoadDiagnostics.js","names":["outcome: string","reason: string | undefined"],"sources":["../../../src/hooks/WidgetLoadDiagnostics/useWidgetLoadDiagnostics.ts"],"sourcesContent":["import { useAtomValue } from 'jotai';\nimport { useEffect, useRef } from 'react';\nimport { pageVariantInfoAtom } from 'src/atoms/app';\nimport { useAmplitude } from 'src/contexts/amplitudeContext/amplitudeContext';\nimport { HardcopyResponse } from 'src/contexts/hardcopyContext';\nimport { PageVariantInfo } from 'src/contexts/pageContext/types';\nimport { WidgetTypeV3 } from 'src/contexts/typesV3';\nimport { extractPageContext } from 'src/hooks/WidgetInteraction/utils';\nimport { EnviveMetricsEventName } from 'src/services/amplitudeService/amplitudeService';\n\n// Fired if a widget is still loading this long after it became visible. Kept at/just above\n// the hardcopy timeout (HARDCOPY_TIMEOUT_MS, 4s) so a normal timeout → static-fallback settles\n// first and does NOT trip a stall; a stall here is a genuine anomaly (e.g. a config hang).\n// Mirrors WIDGET_LOADING_WATCHDOG_MS (the console-only watchdog in withBaseWidget).\nexport const WIDGET_LOAD_STALL_MS = 5000;\n\n// 'pending' = visibility not confirmed by either path when the event fired (e.g. a\n// deferLoading:false widget that loaded eagerly, before the observer reported).\nexport type WidgetVisibilitySource = 'observer' | 'fallback' | 'pending';\n\nexport interface WidgetLoadDiagnosticsInput {\n  /** Gate. No events are emitted unless true. On by default; a Statsig kill switch can disable it. */\n  enabled: boolean;\n  /** Correlates this widget's mount / rendered / outcome / stall events for a single load. */\n  loadId: string;\n  widgetType: WidgetTypeV3;\n  widgetConfigId?: string;\n  /** The widget became visible and started loading its own requests. */\n  startLoading: boolean;\n  /** This widget's own hardcopy / widgetConfig / uiConfig requests have all settled. */\n  ownRequestsSettled: boolean;\n  /** Present once hardcopy resolves; carries `servedFrom` (content_loaded vs static_fallback). */\n  hardcopyContent?: HardcopyResponse;\n  /** Whether visibility came from the observer or the reconcile fallback. */\n  visibilitySource: WidgetVisibilitySource;\n  /** Names of this widget's still-unsettled requests, reported on a stall. */\n  pendingRequests: string[];\n  /** Set when this widget's own hardcopy request rejected (no content — not a static fallback). */\n  hardcopyErrorReason?: string;\n}\n\nconst connectionType = (): string | undefined => {\n  try {\n    // Network Information API — Chromium/Android only, undefined on iOS Safari (our key population).\n    return (navigator as Navigator & { connection?: { effectiveType?: string } }).connection\n      ?.effectiveType;\n  } catch {\n    return undefined;\n  }\n};\n\nconst now = (): number => {\n  try {\n    return typeof window !== 'undefined' && window.performance?.now\n      ? window.performance.now()\n      : Date.now();\n  } catch {\n    return Date.now();\n  }\n};\n\n/**\n * Emits the layered `[Envive] Diagnostics` widget-load net so eng can measure not just what\n * loads, but the negative space between layers — the failures that fire nothing today:\n *\n *   widget_mounted (ungated) → [Envive] Widget Rendered (visible) → widget_load_outcome\n *\n * - `widget_mounted` fires on mount regardless of visibility, so a widget that mounts but never\n *   becomes visible (the suspected infinite-load crux) shows up as a *mounted with no rendered*\n *   gap instead of being invisible to analytics entirely.\n * - `widget_load_outcome` fires once the widget's own requests settle\n *   (content_loaded / static_fallback / error).\n * - `widget_load_stalled` fires if it's still loading at WIDGET_LOAD_STALL_MS AND still mounted.\n *   The timer is cleared on unmount, so a shopper who navigates away first never trips it —\n *   \"stalled with no later outcome\" is therefore a clean stuck signal, undiluted by abandonment.\n *\n * `load_id` correlates all of the above (and is threaded onto `[Envive] Widget Rendered`) so\n * the gaps are joinable per load.\n */\nexport const useWidgetLoadDiagnostics = (input: WidgetLoadDiagnosticsInput): void => {\n  const {\n    enabled,\n    loadId,\n    widgetType,\n    widgetConfigId,\n    startLoading,\n    ownRequestsSettled,\n    hardcopyContent,\n  } = input;\n\n  const { trackEvent } = useAmplitude();\n  const variantInfo = useAtomValue(pageVariantInfoAtom);\n\n  // Latest input, read inside the deferred stall/outcome callbacks (pendingRequests and\n  // visibilitySource churn as requests settle / the fallback engages).\n  const inputRef = useRef(input);\n  inputRef.current = input;\n\n  const emit = (props: Record<string, unknown>) => {\n    trackEvent({\n      eventName: EnviveMetricsEventName.Diagnostics,\n      eventProps: {\n        load_id: loadId,\n        widget_type: widgetType,\n        widget_config_id: widgetConfigId,\n        connection_type: connectionType(),\n        context: variantInfo ? extractPageContext(variantInfo as PageVariantInfo) : null,\n        ...props,\n      },\n    });\n  };\n\n  // Layer 0 — mount. Ungated by visibility: the baseline that fires even when the widget never\n  // becomes visible, so never-visible failures are a measurable gap rather than silence.\n  const mountFiredRef = useRef(false);\n  useEffect(() => {\n    if (!enabled || mountFiredRef.current) return;\n    mountFiredRef.current = true;\n    emit({ type: 'widget_mounted' });\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [enabled]);\n\n  // t0 — when the widget became visible / started loading.\n  const visibleAtRef = useRef<number | null>(null);\n  useEffect(() => {\n    if (startLoading && visibleAtRef.current === null) visibleAtRef.current = now();\n  }, [startLoading]);\n\n  // Layer 2 — terminal outcome, once, when this widget's own requests settle.\n  const outcomeFiredRef = useRef(false);\n  useEffect(() => {\n    if (!enabled || !startLoading || !ownRequestsSettled || outcomeFiredRef.current) return;\n    outcomeFiredRef.current = true;\n\n    const elapsed_ms =\n      visibleAtRef.current !== null ? Math.round(now() - visibleAtRef.current) : undefined;\n\n    let outcome: string;\n    let reason: string | undefined;\n    if (!hardcopyContent) {\n      outcome = 'error';\n      reason = inputRef.current.hardcopyErrorReason ?? 'no_content';\n    } else if (hardcopyContent.servedFrom === 'static') {\n      outcome = 'static_fallback';\n      reason = hardcopyContent.fallbackReason;\n    } else {\n      outcome = 'content_loaded';\n    }\n\n    emit({\n      type: 'widget_load_outcome',\n      outcome,\n      reason,\n      elapsed_ms,\n      visibility_source: inputRef.current.visibilitySource,\n    });\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [enabled, startLoading, ownRequestsSettled, hardcopyContent]);\n\n  // Layer 1.5 — stall. Only arms while loading; cleared on unmount, so abandonment never trips it.\n  useEffect(() => {\n    if (!enabled || !startLoading || ownRequestsSettled) return undefined;\n    const timer = setTimeout(() => {\n      const elapsed_ms =\n        visibleAtRef.current !== null\n          ? Math.round(now() - visibleAtRef.current)\n          : WIDGET_LOAD_STALL_MS;\n      emit({\n        type: 'widget_load_stalled',\n        elapsed_ms,\n        pending_requests: inputRef.current.pendingRequests,\n        visibility_source: inputRef.current.visibilitySource,\n      });\n    }, WIDGET_LOAD_STALL_MS);\n    return () => clearTimeout(timer);\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [enabled, startLoading, ownRequestsSettled]);\n};\n"],"mappings":";;;;;;;;;;AAcA,MAAa,uBAAuB;AA2BpC,MAAM,uBAA2C;AAC/C,KAAI;AAEF,SAAQ,UAAsE,YAC1E;SACE;AACN;;;AAIJ,MAAM,YAAoB;AACxB,KAAI;AACF,SAAO,OAAO,WAAW,eAAe,OAAO,aAAa,MACxD,OAAO,YAAY,KAAK,GACxB,KAAK,KAAK;SACR;AACN,SAAO,KAAK,KAAK;;;;;;;;;;;;;;;;;;;;;AAsBrB,MAAa,4BAA4B,UAA4C;CACnF,MAAM,EACJ,SACA,QACA,YACA,gBACA,cACA,oBACA,oBACE;CAEJ,MAAM,EAAE,eAAe,cAAc;CACrC,MAAM,cAAc,aAAa,oBAAoB;CAIrD,MAAM,WAAW,OAAO,MAAM;AAC9B,UAAS,UAAU;CAEnB,MAAM,QAAQ,UAAmC;AAC/C,aAAW;GACT,WAAW,uBAAuB;GAClC,YAAY;IACV,SAAS;IACT,aAAa;IACb,kBAAkB;IAClB,iBAAiB,gBAAgB;IACjC,SAAS,cAAc,mBAAmB,YAA+B,GAAG;IAC5E,GAAG;IACJ;GACF,CAAC;;CAKJ,MAAM,gBAAgB,OAAO,MAAM;AACnC,iBAAgB;AACd,MAAI,CAAC,WAAW,cAAc,QAAS;AACvC,gBAAc,UAAU;AACxB,OAAK,EAAE,MAAM,kBAAkB,CAAC;IAE/B,CAAC,QAAQ,CAAC;CAGb,MAAM,eAAe,OAAsB,KAAK;AAChD,iBAAgB;AACd,MAAI,gBAAgB,aAAa,YAAY,KAAM,cAAa,UAAU,KAAK;IAC9E,CAAC,aAAa,CAAC;CAGlB,MAAM,kBAAkB,OAAO,MAAM;AACrC,iBAAgB;AACd,MAAI,CAAC,WAAW,CAAC,gBAAgB,CAAC,sBAAsB,gBAAgB,QAAS;AACjF,kBAAgB,UAAU;EAE1B,MAAM,aACJ,aAAa,YAAY,OAAO,KAAK,MAAM,KAAK,GAAG,aAAa,QAAQ,GAAG;EAE7E,IAAIA;EACJ,IAAIC;AACJ,MAAI,CAAC,iBAAiB;AACpB,aAAU;AACV,YAAS,SAAS,QAAQ,uBAAuB;aACxC,gBAAgB,eAAe,UAAU;AAClD,aAAU;AACV,YAAS,gBAAgB;QAEzB,WAAU;AAGZ,OAAK;GACH,MAAM;GACN;GACA;GACA;GACA,mBAAmB,SAAS,QAAQ;GACrC,CAAC;IAED;EAAC;EAAS;EAAc;EAAoB;EAAgB,CAAC;AAGhE,iBAAgB;AACd,MAAI,CAAC,WAAW,CAAC,gBAAgB,mBAAoB,QAAO;EAC5D,MAAM,QAAQ,iBAAiB;AAK7B,QAAK;IACH,MAAM;IACN,YALA,aAAa,YAAY,OACrB,KAAK,MAAM,KAAK,GAAG,aAAa,QAAQ,GACxC;IAIJ,kBAAkB,SAAS,QAAQ;IACnC,mBAAmB,SAAS,QAAQ;IACrC,CAAC;KACD,qBAAqB;AACxB,eAAa,aAAa,MAAM;IAE/B;EAAC;EAAS;EAAc;EAAmB,CAAC"}

package/dist/hooks/utils.d.cts

@@ -19,4 +19,4 @@ declare enum SearchResultsState {
 declare const getSearchResultsState: (isLoadingSearch: boolean, searchData: SearchResult | null) => SearchResultsState;
 //#endregion
 export { SearchResultsState, createAppLoadedEvent, createVisitUserEvent, getSearchResultsState, isElementPartiallyVisible, isWithinBusinessHours };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuZC5jdHMiLCJuYW1lcyI6W10sInNvdXJjZXMiOlsiLi4vLi4vc3JjL2hvb2tzL3V0aWxzLmQudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgU2VhcmNoUmVzdWx0IH0gZnJvbSAnc3JjL2FwcGxpY2F0aW9uL21vZGVscy9hcGkvc2VhcmNoJztcbmltcG9ydCB7IFVzZXJFdmVudCwgVmFyaWFudEluZm8gfSBmcm9tICdzcmMvYXBwbGljYXRpb24vbW9kZWxzJztcbmV4cG9ydCBkZWNsYXJlIGNvbnN0IGlzRWxlbWVudFBhcnRpYWxseVZpc2libGU6IChlbD86IEhUTUxEaXZFbGVtZW50IHwgbnVsbCkgPT4gYm9vbGVhbjtcbmV4cG9ydCBkZWNsYXJlIGNvbnN0IGNyZWF0ZUFwcExvYWRlZEV2ZW50OiAoKSA9PiBVc2VyRXZlbnQ7XG5leHBvcnQgZGVjbGFyZSBjb25zdCBjcmVhdGVWaXNpdFVzZXJFdmVudDogKHsgdmFyaWFudEluZm8sIH06IHtcbiAgICB2YXJpYW50SW5mbzogVmFyaWFudEluZm87XG59KSA9PiBVc2VyRXZlbnQgfCB1bmRlZmluZWQ7XG5leHBvcnQgZGVjbGFyZSBjb25zdCBpc1dpdGhpbkJ1c2luZXNzSG91cnM6IChzdGFydFRpbWU6IHN0cmluZywgZW5kVGltZTogc3RyaW5nLCB0aW1lWm9uZTogc3RyaW5nKSA9PiBib29sZWFuO1xuZXhwb3J0IGRlY2xhcmUgZW51bSBTZWFyY2hSZXN1bHRzU3RhdGUge1xuICAgIExvYWRpbmcgPSAwLFxuICAgIFJlc3VsdHMgPSAxLFxuICAgIE5vUmVzdWx0cyA9IDJcbn1cbmV4cG9ydCBkZWNsYXJlIGNvbnN0IGdldFNlYXJjaFJlc3VsdHNTdGF0ZTogKGlzTG9hZGluZ1NlYXJjaDogYm9vbGVhbiwgc2VhcmNoRGF0YTogU2VhcmNoUmVzdWx0IHwgbnVsbCkgPT4gU2VhcmNoUmVzdWx0c1N0YXRlO1xuIl0sIm1hcHBpbmdzIjoiOzs7OztBQUVBLElBQVcsNEJBQTRCLENBQUMsVUFBVSxlQUFlO0FBQ2pFLElBQVcsdUJBQXVCLENBQUMsVUFBVSxVQUFVO0FBQ3ZELElBQVcsdUJBQXVCO0NBQUM7T0FBVTtPQUFpQjtPQUFBO0NBQUE7QUFDOUQsSUFBVyx3QkFBaUIsQ0FBQSxHQUFBO0FBQzVCLElBQVcscUJBQWdCLENBQUEsR0FBQTtBQUMzQixJQUFXLHdCQUF3QjtDQUFDO09BQVU7T0FBb0I7Q0FBbUIifQ==
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuZC5jdHMiLCJuYW1lcyI6W10sInNvdXJjZXMiOlsiLi4vLi4vc3JjL2hvb2tzL3V0aWxzLmQudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgU2VhcmNoUmVzdWx0IH0gZnJvbSAnc3JjL2FwcGxpY2F0aW9uL21vZGVscy9hcGkvc2VhcmNoJztcbmltcG9ydCB7IFVzZXJFdmVudCwgVmFyaWFudEluZm8gfSBmcm9tICdzcmMvYXBwbGljYXRpb24vbW9kZWxzJztcbmV4cG9ydCBkZWNsYXJlIGNvbnN0IGlzRWxlbWVudFBhcnRpYWxseVZpc2libGU6IChlbD86IEhUTUxEaXZFbGVtZW50IHwgbnVsbCkgPT4gYm9vbGVhbjtcbmV4cG9ydCBkZWNsYXJlIGNvbnN0IGNyZWF0ZUFwcExvYWRlZEV2ZW50OiAoKSA9PiBVc2VyRXZlbnQ7XG5leHBvcnQgZGVjbGFyZSBjb25zdCBjcmVhdGVWaXNpdFVzZXJFdmVudDogKHsgdmFyaWFudEluZm8sIH06IHtcbiAgICB2YXJpYW50SW5mbzogVmFyaWFudEluZm87XG59KSA9PiBVc2VyRXZlbnQgfCB1bmRlZmluZWQ7XG5leHBvcnQgZGVjbGFyZSBjb25zdCBpc1dpdGhpbkJ1c2luZXNzSG91cnM6IChzdGFydFRpbWU6IHN0cmluZywgZW5kVGltZTogc3RyaW5nLCB0aW1lWm9uZTogc3RyaW5nKSA9PiBib29sZWFuO1xuZXhwb3J0IGRlY2xhcmUgZW51bSBTZWFyY2hSZXN1bHRzU3RhdGUge1xuICAgIExvYWRpbmcgPSAwLFxuICAgIFJlc3VsdHMgPSAxLFxuICAgIE5vUmVzdWx0cyA9IDJcbn1cbmV4cG9ydCBkZWNsYXJlIGNvbnN0IGdldFNlYXJjaFJlc3VsdHNTdGF0ZTogKGlzTG9hZGluZ1NlYXJjaDogYm9vbGVhbiwgc2VhcmNoRGF0YTogU2VhcmNoUmVzdWx0IHwgbnVsbCkgPT4gU2VhcmNoUmVzdWx0c1N0YXRlO1xuIl0sIm1hcHBpbmdzIjoiOzs7OztBQUVBLElBQVcsNEJBQTRCLENBQUMsV0FBVyxlQUFlO0FBQ2xFLElBQVcsdUJBQXVCLENBQUMsV0FBVyxVQUFVO0FBQ3hELElBQVcsdUJBQXVCO0NBQUM7T0FBVztPQUFnQjtPQUFBO0NBQUE7QUFDOUQsSUFBVyx3QkFBaUIsQ0FBQSxJQUFBO0FBQzVCLElBQVcscUJBQWdCLENBQUEsSUFBQTtBQUMzQixJQUFXLHdCQUF3QjtDQUFDO09BQVc7T0FBb0I7Q0FBbUIifQ==

package/dist/hooks/utils.d.ts

@@ -19,4 +19,4 @@ declare enum SearchResultsState {
 declare const getSearchResultsState: (isLoadingSearch: boolean, searchData: SearchResult | null) => SearchResultsState;
 //#endregion
 export { SearchResultsState, createAppLoadedEvent, createVisitUserEvent, getSearchResultsState, isElementPartiallyVisible, isWithinBusinessHours };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuZC50cyIsIm5hbWVzIjpbXSwic291cmNlcyI6WyIuLi8uLi9zcmMvaG9va3MvdXRpbHMuZC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBTZWFyY2hSZXN1bHQgfSBmcm9tICdzcmMvYXBwbGljYXRpb24vbW9kZWxzL2FwaS9zZWFyY2gnO1xuaW1wb3J0IHsgVXNlckV2ZW50LCBWYXJpYW50SW5mbyB9IGZyb20gJ3NyYy9hcHBsaWNhdGlvbi9tb2RlbHMnO1xuZXhwb3J0IGRlY2xhcmUgY29uc3QgaXNFbGVtZW50UGFydGlhbGx5VmlzaWJsZTogKGVsPzogSFRNTERpdkVsZW1lbnQgfCBudWxsKSA9PiBib29sZWFuO1xuZXhwb3J0IGRlY2xhcmUgY29uc3QgY3JlYXRlQXBwTG9hZGVkRXZlbnQ6ICgpID0+IFVzZXJFdmVudDtcbmV4cG9ydCBkZWNsYXJlIGNvbnN0IGNyZWF0ZVZpc2l0VXNlckV2ZW50OiAoeyB2YXJpYW50SW5mbywgfToge1xuICAgIHZhcmlhbnRJbmZvOiBWYXJpYW50SW5mbztcbn0pID0+IFVzZXJFdmVudCB8IHVuZGVmaW5lZDtcbmV4cG9ydCBkZWNsYXJlIGNvbnN0IGlzV2l0aGluQnVzaW5lc3NIb3VyczogKHN0YXJ0VGltZTogc3RyaW5nLCBlbmRUaW1lOiBzdHJpbmcsIHRpbWVab25lOiBzdHJpbmcpID0+IGJvb2xlYW47XG5leHBvcnQgZGVjbGFyZSBlbnVtIFNlYXJjaFJlc3VsdHNTdGF0ZSB7XG4gICAgTG9hZGluZyA9IDAsXG4gICAgUmVzdWx0cyA9IDEsXG4gICAgTm9SZXN1bHRzID0gMlxufVxuZXhwb3J0IGRlY2xhcmUgY29uc3QgZ2V0U2VhcmNoUmVzdWx0c1N0YXRlOiAoaXNMb2FkaW5nU2VhcmNoOiBib29sZWFuLCBzZWFyY2hEYXRhOiBTZWFyY2hSZXN1bHQgfCBudWxsKSA9PiBTZWFyY2hSZXN1bHRzU3RhdGU7XG4iXSwibWFwcGluZ3MiOiI7Ozs7O0FBRUEsSUFBVyw0QkFBNEIsQ0FBQyxXQUFXLGVBQWU7QUFDbEUsSUFBVyx1QkFBdUIsQ0FBQyxXQUFXLFVBQVU7QUFDeEQsSUFBVyx1QkFBdUI7Q0FBQztPQUFXO09BQWdCO09BQUE7Q0FBQTtBQUM5RCxJQUFXLHdCQUFpQixDQUFBLElBQUE7QUFDNUIsSUFBVyxxQkFBZ0IsQ0FBQSxJQUFBO0FBQzNCLElBQVcsd0JBQXdCO0NBQUM7T0FBVztPQUFvQjtDQUFtQiJ9
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuZC50cyIsIm5hbWVzIjpbXSwic291cmNlcyI6WyIuLi8uLi9zcmMvaG9va3MvdXRpbHMuZC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBTZWFyY2hSZXN1bHQgfSBmcm9tICdzcmMvYXBwbGljYXRpb24vbW9kZWxzL2FwaS9zZWFyY2gnO1xuaW1wb3J0IHsgVXNlckV2ZW50LCBWYXJpYW50SW5mbyB9IGZyb20gJ3NyYy9hcHBsaWNhdGlvbi9tb2RlbHMnO1xuZXhwb3J0IGRlY2xhcmUgY29uc3QgaXNFbGVtZW50UGFydGlhbGx5VmlzaWJsZTogKGVsPzogSFRNTERpdkVsZW1lbnQgfCBudWxsKSA9PiBib29sZWFuO1xuZXhwb3J0IGRlY2xhcmUgY29uc3QgY3JlYXRlQXBwTG9hZGVkRXZlbnQ6ICgpID0+IFVzZXJFdmVudDtcbmV4cG9ydCBkZWNsYXJlIGNvbnN0IGNyZWF0ZVZpc2l0VXNlckV2ZW50OiAoeyB2YXJpYW50SW5mbywgfToge1xuICAgIHZhcmlhbnRJbmZvOiBWYXJpYW50SW5mbztcbn0pID0+IFVzZXJFdmVudCB8IHVuZGVmaW5lZDtcbmV4cG9ydCBkZWNsYXJlIGNvbnN0IGlzV2l0aGluQnVzaW5lc3NIb3VyczogKHN0YXJ0VGltZTogc3RyaW5nLCBlbmRUaW1lOiBzdHJpbmcsIHRpbWVab25lOiBzdHJpbmcpID0+IGJvb2xlYW47XG5leHBvcnQgZGVjbGFyZSBlbnVtIFNlYXJjaFJlc3VsdHNTdGF0ZSB7XG4gICAgTG9hZGluZyA9IDAsXG4gICAgUmVzdWx0cyA9IDEsXG4gICAgTm9SZXN1bHRzID0gMlxufVxuZXhwb3J0IGRlY2xhcmUgY29uc3QgZ2V0U2VhcmNoUmVzdWx0c1N0YXRlOiAoaXNMb2FkaW5nU2VhcmNoOiBib29sZWFuLCBzZWFyY2hEYXRhOiBTZWFyY2hSZXN1bHQgfCBudWxsKSA9PiBTZWFyY2hSZXN1bHRzU3RhdGU7XG4iXSwibWFwcGluZ3MiOiI7Ozs7O0FBRUEsSUFBVyw0QkFBNEIsQ0FBQyxTQUFTLGVBQWU7QUFDaEUsSUFBVyx1QkFBdUIsQ0FBQyxTQUFTLFVBQVU7QUFDdEQsSUFBVyx1QkFBdUI7Q0FBQztPQUFTO09BQWtCO09BQUE7Q0FBQTtBQUM5RCxJQUFXLHdCQUFpQixDQUFBLEVBQUE7QUFDNUIsSUFBVyxxQkFBZ0IsQ0FBQSxFQUFBO0FBQzNCLElBQVcsd0JBQXdCO0NBQUM7T0FBUztPQUFvQjtDQUFtQiJ9

package/dist/services/amplitudeService/eventNames.cjs

@@ -49,10 +49,11 @@ let EnviveMetricsEventName = /* @__PURE__ */ function(EnviveMetricsEventName$1)
 	EnviveMetricsEventName$1["WidgetTextRequest"] = "Widget Text Request";
 	EnviveMetricsEventName$1["WidgetTextResponse"] = "Widget Text Response";
 	EnviveMetricsEventName$1["WidgetTextClicked"] = "Widget Text Clicked";
+	EnviveMetricsEventName$1["Diagnostics"] = "Diagnostics";
 	return EnviveMetricsEventName$1;
 }({});
 
 //#endregion
 exports.EnviveMetricsEventName = EnviveMetricsEventName;
 exports.SpiffyMetricsEventName = SpiffyMetricsEventName;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/services/amplitudeService/eventNames.d.cts

@@ -47,7 +47,8 @@ declare enum EnviveMetricsEventName {
   WidgetTextRequest = "Widget Text Request",
   WidgetTextResponse = "Widget Text Response",
   WidgetTextClicked = "Widget Text Clicked",
+  Diagnostics = "Diagnostics",
 }
 //#endregion
 export { EnviveMetricsEventName, SpiffyMetricsEventName };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/services/amplitudeService/eventNames.d.ts

@@ -47,7 +47,8 @@ declare enum EnviveMetricsEventName {
   WidgetTextRequest = "Widget Text Request",
   WidgetTextResponse = "Widget Text Response",
   WidgetTextClicked = "Widget Text Clicked",
+  Diagnostics = "Diagnostics",
 }
 //#endregion
 export { EnviveMetricsEventName, SpiffyMetricsEventName };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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