@envive-ai/react-hooks 0.3.45 → 0.3.47

package/dist/services/featureFlagService/index.cjs

@@ -0,0 +1,101 @@
+const require_logger = require('../../application/logging/logger.cjs');
+const require_featureGates = require('../../application/models/featureGates.cjs');
+
+//#region src/services/featureFlagService/index.ts
+const FEATURE_FLAGS_STORAGE_KEY = "spiffy-feature-flags";
+const logger = new require_logger.default("featureFlagService");
+var FeatureFlagService = class FeatureFlagService {
+	constructor(featureGates) {
+		this.isFeatureGateEnabled = (featureGate) => {
+			const gateValue = this.featureGates.find((gate) => gate.name === featureGate);
+			const featureFlagOverride = FeatureFlagService.getFeatureFlagOverride(featureGate);
+			if (featureFlagOverride !== void 0) return featureFlagOverride;
+			if (gateValue == null || gateValue.value == null) {
+				logger.logDebug(`isFeatureGateEnabled featureGate:${featureGate} value is undefined - returning false`);
+				return false;
+			}
+			return gateValue.value;
+		};
+		this.isClientSessionEnabled = () => this.isFeatureGateEnabled(require_featureGates.FeatureGates.IsClientSessionEnabled);
+		this.getFeatureFlags = () => {
+			return Object.fromEntries(Object.values(require_featureGates.FeatureGates).map((featureGate) => [featureGate, this.isFeatureGateEnabled(featureGate)]));
+		};
+		this.getFullFlagValue = (featureGate) => {
+			const gateValue = this.featureGates.find((gate) => gate.name === featureGate);
+			return {
+				resolved: this.isFeatureGateEnabled(featureGate),
+				initial: gateValue?.value,
+				query_param_override: FeatureFlagService.getQueryParamFeatureGateOverrides(featureGate),
+				window_param_override: FeatureFlagService.getWindowFeatureGateOverrides(featureGate),
+				stored_override: FeatureFlagService.getStoredFeatureGateOverrides(featureGate)
+			};
+		};
+		this.getFullFlagValues = () => {
+			const featureGates$1 = Object.values(require_featureGates.FeatureGates).map((featureGate) => [featureGate, this.getFullFlagValue(featureGate)]);
+			return featureGates$1.length > 0 ? featureGates$1.reduce((acc, entry) => {
+				const [name, value] = entry;
+				if (name && value != null) return {
+					...acc,
+					[`feature_gate.${name}`]: value
+				};
+				return acc;
+			}, {}) : {};
+		};
+		this.featureGates = featureGates;
+	}
+	static getQueryParamFeatureGateOverrides(featureGate) {
+		const url = window.location?.href ?? "";
+		if (url.includes("?")) {
+			const urlObj = new URL(url);
+			const params = new URLSearchParams(urlObj.search);
+			const value = Object.fromEntries(params.entries())[featureGate];
+			if (value != null) return value === "true";
+		}
+	}
+	static getWindowFeatureGateOverrides(featureGate) {
+		if (typeof window === "undefined") return;
+		const windowOverride = window;
+		const value = (windowOverride?._envive?.featureOverrides ?? windowOverride?._spiffy?.featureOverrides)?.[String(featureGate)];
+		if (value != null) return value;
+	}
+	static getStoredFeatureGateOverrides(featureGate) {
+		if (typeof window === "undefined" || typeof window.localStorage === "undefined") return;
+		try {
+			const featureFlags = window.localStorage.getItem(FEATURE_FLAGS_STORAGE_KEY);
+			if (!featureFlags) return;
+			return JSON.parse(featureFlags)[featureGate];
+		} catch (err) {
+			logger.logError("getStoredFeatureGateOverrides: error parsing feature flags", err);
+			return;
+		}
+	}
+	static getFeatureFlagOverride(featureGate) {
+		const queryOverride = FeatureFlagService.getQueryParamFeatureGateOverrides(featureGate);
+		if (queryOverride != null) {
+			logger.logDebug(`isFeatureGateEnabled featureGate:${featureGate} overridden by URL param. New value: ${queryOverride}`);
+			return queryOverride;
+		}
+		const windowOverride = FeatureFlagService.getWindowFeatureGateOverrides(featureGate);
+		if (windowOverride != null) {
+			logger.logDebug(`isFeatureGateEnabled featureGate:${featureGate} overridden by window param. New value: ${windowOverride}`);
+			return windowOverride;
+		}
+		const storedOverride = FeatureFlagService.getStoredFeatureGateOverrides(featureGate);
+		if (storedOverride != null) {
+			logger.logDebug(`isFeatureGateEnabled featureGate:${featureGate} overridden by stored value. New value: ${storedOverride}`);
+			return storedOverride;
+		}
+	}
+	static persistFeatureGateOverrides() {
+		if (typeof window === "undefined" || typeof window.localStorage === "undefined") return;
+		const overrides = Object.values(require_featureGates.FeatureGates).map((featureGate) => [featureGate, FeatureFlagService.getFeatureFlagOverride(featureGate)]).filter(([, value]) => value !== void 0).reduce((acc, [key, value]) => ({
+			...acc,
+			[key]: value
+		}), {});
+		window.localStorage.setItem(FEATURE_FLAGS_STORAGE_KEY, JSON.stringify(overrides));
+	}
+};
+
+//#endregion
+exports.FeatureFlagService = FeatureFlagService;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"index.cjs","names":["Logger","FeatureGates","featureGates"],"sources":["../../../src/services/featureFlagService/index.ts"],"sourcesContent":["import { OrgConfigFeatureGate } from 'src/application/models/api/orgConfigResults';\nimport { FeatureGates } from 'src/application/models/featureGates';\nimport Logger from 'src/application/logging/logger';\n\nconst FEATURE_FLAGS_STORAGE_KEY = 'spiffy-feature-flags';\n\nconst logger = new Logger('featureFlagService');\n\nexport interface FullFlagValue {\n  resolved: boolean;\n  initial: boolean | undefined;\n  query_param_override: boolean | undefined;\n  window_param_override: boolean | undefined;\n  stored_override: boolean | undefined;\n}\n\n// Kept free of React imports: the injection bundle constructs this service\n// before deciding whether to load the React app, and pulling React into\n// that pre-config code path would put it on the eager critical chunk.\nexport class FeatureFlagService {\n  private featureGates: OrgConfigFeatureGate[];\n\n  constructor(featureGates: OrgConfigFeatureGate[]) {\n    this.featureGates = featureGates;\n  }\n\n  static getQueryParamFeatureGateOverrides(featureGate: FeatureGates): boolean | undefined {\n    const url = window.location?.href ?? '';\n    if (url.includes('?')) {\n      const urlObj = new URL(url);\n      const params = new URLSearchParams(urlObj.search);\n      const paramsObj = Object.fromEntries(params.entries());\n      const value = paramsObj[featureGate];\n\n      if (value != null) {\n        return value === 'true';\n      }\n    }\n\n    return undefined;\n  }\n\n  static getWindowFeatureGateOverrides(featureGate: FeatureGates): boolean | undefined {\n    if (typeof window === 'undefined') {\n      return undefined;\n    }\n    const windowOverride = window as Window & {\n      _envive?: { featureOverrides?: Record<string, boolean> };\n      _spiffy?: { featureOverrides?: Record<string, boolean> };\n    };\n    const featureOverrides =\n      windowOverride?._envive?.featureOverrides ?? windowOverride?._spiffy?.featureOverrides;\n    const value = featureOverrides?.[String(featureGate)];\n    if (value != null) {\n      return value;\n    }\n    return undefined;\n  }\n\n  static getStoredFeatureGateOverrides(featureGate: FeatureGates): boolean | undefined {\n    if (typeof window === 'undefined' || typeof window.localStorage === 'undefined') {\n      return undefined;\n    }\n    try {\n      const featureFlags = window.localStorage.getItem(FEATURE_FLAGS_STORAGE_KEY);\n      if (!featureFlags) {\n        return undefined;\n      }\n      const featureFlagsObj = JSON.parse(featureFlags) as Record<string, boolean>;\n      return featureFlagsObj[featureGate];\n    } catch (err) {\n      logger.logError('getStoredFeatureGateOverrides: error parsing feature flags', err);\n      return undefined;\n    }\n  }\n\n  static getFeatureFlagOverride(featureGate: FeatureGates): boolean | undefined {\n    const queryOverride = FeatureFlagService.getQueryParamFeatureGateOverrides(featureGate);\n    if (queryOverride != null) {\n      logger.logDebug(\n        `isFeatureGateEnabled featureGate:${featureGate} overridden by URL param. New value: ${queryOverride}`,\n      );\n      return queryOverride;\n    }\n\n    const windowOverride = FeatureFlagService.getWindowFeatureGateOverrides(featureGate);\n    if (windowOverride != null) {\n      logger.logDebug(\n        `isFeatureGateEnabled featureGate:${featureGate} overridden by window param. New value: ${windowOverride}`,\n      );\n      return windowOverride;\n    }\n\n    const storedOverride = FeatureFlagService.getStoredFeatureGateOverrides(featureGate);\n    if (storedOverride != null) {\n      logger.logDebug(\n        `isFeatureGateEnabled featureGate:${featureGate} overridden by stored value. New value: ${storedOverride}`,\n      );\n      return storedOverride;\n    }\n\n    return undefined;\n  }\n\n  isFeatureGateEnabled = (featureGate: FeatureGates): boolean => {\n    const gateValue = this.featureGates.find(gate => gate.name === featureGate);\n\n    const featureFlagOverride = FeatureFlagService.getFeatureFlagOverride(featureGate);\n    if (featureFlagOverride !== undefined) {\n      return featureFlagOverride;\n    }\n\n    if (gateValue == null || gateValue.value == null) {\n      logger.logDebug(\n        `isFeatureGateEnabled featureGate:${featureGate} value is undefined - returning false`,\n      );\n      return false;\n    }\n    return gateValue.value;\n  };\n\n  // Ensure that standard overrides work as expected\n  isClientSessionEnabled = (): boolean =>\n    this.isFeatureGateEnabled(FeatureGates.IsClientSessionEnabled);\n\n  getFeatureFlags = (): Record<string, boolean> => {\n    return Object.fromEntries(\n      Object.values(FeatureGates).map((featureGate: FeatureGates) => [\n        featureGate,\n        this.isFeatureGateEnabled(featureGate),\n      ]),\n    );\n  };\n\n  getFullFlagValue = (featureGate: FeatureGates): FullFlagValue => {\n    const gateValue = this.featureGates.find(gate => gate.name === featureGate);\n    return {\n      resolved: this.isFeatureGateEnabled(featureGate),\n      initial: gateValue?.value,\n      query_param_override: FeatureFlagService.getQueryParamFeatureGateOverrides(featureGate),\n      window_param_override: FeatureFlagService.getWindowFeatureGateOverrides(featureGate),\n      stored_override: FeatureFlagService.getStoredFeatureGateOverrides(featureGate),\n    };\n  };\n\n  getFullFlagValues = (): Record<string, FullFlagValue> => {\n    const featureGates = Object.values(FeatureGates).map((featureGate: FeatureGates) => [\n      featureGate,\n      this.getFullFlagValue(featureGate),\n    ]);\n\n    return featureGates.length > 0\n      ? featureGates.reduce<Record<string, FullFlagValue>>((acc, entry) => {\n          const [name, value] = entry as [FeatureGates, FullFlagValue];\n          if (name && value != null) {\n            return { ...acc, [`feature_gate.${name}`]: value };\n          }\n          return acc;\n        }, {})\n      : {};\n  };\n\n  static persistFeatureGateOverrides(): void {\n    if (typeof window === 'undefined' || typeof window.localStorage === 'undefined') {\n      return;\n    }\n    const overrides = Object.values(FeatureGates)\n      .map(\n        featureGate =>\n          [featureGate, FeatureFlagService.getFeatureFlagOverride(featureGate)] as const,\n      )\n      .filter(([, value]) => value !== undefined)\n      .reduce<Record<string, boolean>>((acc, [key, value]) => ({ ...acc, [key]: value! }), {});\n    window.localStorage.setItem(FEATURE_FLAGS_STORAGE_KEY, JSON.stringify(overrides));\n  }\n}\n"],"mappings":"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"}

package/dist/services/featureFlagService/index.d.cts

@@ -0,0 +1,28 @@
+import { FeatureGates } from "../../application/models/featureGates.cjs";
+import { OrgConfigFeatureGate } from "../../application/models/api/orgConfigResults.cjs";
+
+//#region src/services/featureFlagService/index.d.ts
+interface FullFlagValue {
+  resolved: boolean;
+  initial: boolean | undefined;
+  query_param_override: boolean | undefined;
+  window_param_override: boolean | undefined;
+  stored_override: boolean | undefined;
+}
+declare class FeatureFlagService {
+  private featureGates;
+  constructor(featureGates: OrgConfigFeatureGate[]);
+  static getQueryParamFeatureGateOverrides(featureGate: FeatureGates): boolean | undefined;
+  static getWindowFeatureGateOverrides(featureGate: FeatureGates): boolean | undefined;
+  static getStoredFeatureGateOverrides(featureGate: FeatureGates): boolean | undefined;
+  static getFeatureFlagOverride(featureGate: FeatureGates): boolean | undefined;
+  isFeatureGateEnabled: (featureGate: FeatureGates) => boolean;
+  isClientSessionEnabled: () => boolean;
+  getFeatureFlags: () => Record<string, boolean>;
+  getFullFlagValue: (featureGate: FeatureGates) => FullFlagValue;
+  getFullFlagValues: () => Record<string, FullFlagValue>;
+  static persistFeatureGateOverrides(): void;
+}
+//#endregion
+export { FeatureFlagService, FullFlagValue };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC5jdHMiLCJuYW1lcyI6W10sInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3NlcnZpY2VzL2ZlYXR1cmVGbGFnU2VydmljZS9pbmRleC5kLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE9yZ0NvbmZpZ0ZlYXR1cmVHYXRlIH0gZnJvbSAnc3JjL2FwcGxpY2F0aW9uL21vZGVscy9hcGkvb3JnQ29uZmlnUmVzdWx0cyc7XG5pbXBvcnQgeyBGZWF0dXJlR2F0ZXMgfSBmcm9tICdzcmMvYXBwbGljYXRpb24vbW9kZWxzL2ZlYXR1cmVHYXRlcyc7XG5leHBvcnQgaW50ZXJmYWNlIEZ1bGxGbGFnVmFsdWUge1xuICAgIHJlc29sdmVkOiBib29sZWFuO1xuICAgIGluaXRpYWw6IGJvb2xlYW4gfCB1bmRlZmluZWQ7XG4gICAgcXVlcnlfcGFyYW1fb3ZlcnJpZGU6IGJvb2xlYW4gfCB1bmRlZmluZWQ7XG4gICAgd2luZG93X3BhcmFtX292ZXJyaWRlOiBib29sZWFuIHwgdW5kZWZpbmVkO1xuICAgIHN0b3JlZF9vdmVycmlkZTogYm9vbGVhbiB8IHVuZGVmaW5lZDtcbn1cbmV4cG9ydCBkZWNsYXJlIGNsYXNzIEZlYXR1cmVGbGFnU2VydmljZSB7XG4gICAgcHJpdmF0ZSBmZWF0dXJlR2F0ZXM7XG4gICAgY29uc3RydWN0b3IoZmVhdHVyZUdhdGVzOiBPcmdDb25maWdGZWF0dXJlR2F0ZVtdKTtcbiAgICBzdGF0aWMgZ2V0UXVlcnlQYXJhbUZlYXR1cmVHYXRlT3ZlcnJpZGVzKGZlYXR1cmVHYXRlOiBGZWF0dXJlR2F0ZXMpOiBib29sZWFuIHwgdW5kZWZpbmVkO1xuICAgIHN0YXRpYyBnZXRXaW5kb3dGZWF0dXJlR2F0ZU92ZXJyaWRlcyhmZWF0dXJlR2F0ZTogRmVhdHVyZUdhdGVzKTogYm9vbGVhbiB8IHVuZGVmaW5lZDtcbiAgICBzdGF0aWMgZ2V0U3RvcmVkRmVhdHVyZUdhdGVPdmVycmlkZXMoZmVhdHVyZUdhdGU6IEZlYXR1cmVHYXRlcyk6IGJvb2xlYW4gfCB1bmRlZmluZWQ7XG4gICAgc3RhdGljIGdldEZlYXR1cmVGbGFnT3ZlcnJpZGUoZmVhdHVyZUdhdGU6IEZlYXR1cmVHYXRlcyk6IGJvb2xlYW4gfCB1bmRlZmluZWQ7XG4gICAgaXNGZWF0dXJlR2F0ZUVuYWJsZWQ6IChmZWF0dXJlR2F0ZTogRmVhdHVyZUdhdGVzKSA9PiBib29sZWFuO1xuICAgIGlzQ2xpZW50U2Vzc2lvbkVuYWJsZWQ6ICgpID0+IGJvb2xlYW47XG4gICAgZ2V0RmVhdHVyZUZsYWdzOiAoKSA9PiBSZWNvcmQ8c3RyaW5nLCBib29sZWFuPjtcbiAgICBnZXRGdWxsRmxhZ1ZhbHVlOiAoZmVhdHVyZUdhdGU6IEZlYXR1cmVHYXRlcykgPT4gRnVsbEZsYWdWYWx1ZTtcbiAgICBnZXRGdWxsRmxhZ1ZhbHVlczogKCkgPT4gUmVjb3JkPHN0cmluZywgRnVsbEZsYWdWYWx1ZT47XG4gICAgc3RhdGljIHBlcnNpc3RGZWF0dXJlR2F0ZU92ZXJyaWRlcygpOiB2b2lkO1xufVxuIl0sIm1hcHBpbmdzIjoiOzs7O0FBRUEsSUFBVyxnQkFBZ0IsQ0FBQyxJQUFHO0FBQy9CLElBQVcscUJBQVU7Q0FBQTtPQUFBO09BQUE7T0FBQTtPQUFBO09BQUE7T0FBQTtPQUFBO09BQUE7T0FBQTtPQUFBO09BQUE7Q0FBQSJ9

package/dist/services/featureFlagService/index.d.ts

@@ -0,0 +1,28 @@
+import { FeatureGates } from "../../application/models/featureGates.js";
+import { OrgConfigFeatureGate } from "../../application/models/api/orgConfigResults.js";
+
+//#region src/services/featureFlagService/index.d.ts
+interface FullFlagValue {
+  resolved: boolean;
+  initial: boolean | undefined;
+  query_param_override: boolean | undefined;
+  window_param_override: boolean | undefined;
+  stored_override: boolean | undefined;
+}
+declare class FeatureFlagService {
+  private featureGates;
+  constructor(featureGates: OrgConfigFeatureGate[]);
+  static getQueryParamFeatureGateOverrides(featureGate: FeatureGates): boolean | undefined;
+  static getWindowFeatureGateOverrides(featureGate: FeatureGates): boolean | undefined;
+  static getStoredFeatureGateOverrides(featureGate: FeatureGates): boolean | undefined;
+  static getFeatureFlagOverride(featureGate: FeatureGates): boolean | undefined;
+  isFeatureGateEnabled: (featureGate: FeatureGates) => boolean;
+  isClientSessionEnabled: () => boolean;
+  getFeatureFlags: () => Record<string, boolean>;
+  getFullFlagValue: (featureGate: FeatureGates) => FullFlagValue;
+  getFullFlagValues: () => Record<string, FullFlagValue>;
+  static persistFeatureGateOverrides(): void;
+}
+//#endregion
+export { FeatureFlagService, FullFlagValue };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsIm5hbWVzIjpbXSwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvc2VydmljZXMvZmVhdHVyZUZsYWdTZXJ2aWNlL2luZGV4LmQudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgT3JnQ29uZmlnRmVhdHVyZUdhdGUgfSBmcm9tICdzcmMvYXBwbGljYXRpb24vbW9kZWxzL2FwaS9vcmdDb25maWdSZXN1bHRzJztcbmltcG9ydCB7IEZlYXR1cmVHYXRlcyB9IGZyb20gJ3NyYy9hcHBsaWNhdGlvbi9tb2RlbHMvZmVhdHVyZUdhdGVzJztcbmV4cG9ydCBpbnRlcmZhY2UgRnVsbEZsYWdWYWx1ZSB7XG4gICAgcmVzb2x2ZWQ6IGJvb2xlYW47XG4gICAgaW5pdGlhbDogYm9vbGVhbiB8IHVuZGVmaW5lZDtcbiAgICBxdWVyeV9wYXJhbV9vdmVycmlkZTogYm9vbGVhbiB8IHVuZGVmaW5lZDtcbiAgICB3aW5kb3dfcGFyYW1fb3ZlcnJpZGU6IGJvb2xlYW4gfCB1bmRlZmluZWQ7XG4gICAgc3RvcmVkX292ZXJyaWRlOiBib29sZWFuIHwgdW5kZWZpbmVkO1xufVxuZXhwb3J0IGRlY2xhcmUgY2xhc3MgRmVhdHVyZUZsYWdTZXJ2aWNlIHtcbiAgICBwcml2YXRlIGZlYXR1cmVHYXRlcztcbiAgICBjb25zdHJ1Y3RvcihmZWF0dXJlR2F0ZXM6IE9yZ0NvbmZpZ0ZlYXR1cmVHYXRlW10pO1xuICAgIHN0YXRpYyBnZXRRdWVyeVBhcmFtRmVhdHVyZUdhdGVPdmVycmlkZXMoZmVhdHVyZUdhdGU6IEZlYXR1cmVHYXRlcyk6IGJvb2xlYW4gfCB1bmRlZmluZWQ7XG4gICAgc3RhdGljIGdldFdpbmRvd0ZlYXR1cmVHYXRlT3ZlcnJpZGVzKGZlYXR1cmVHYXRlOiBGZWF0dXJlR2F0ZXMpOiBib29sZWFuIHwgdW5kZWZpbmVkO1xuICAgIHN0YXRpYyBnZXRTdG9yZWRGZWF0dXJlR2F0ZU92ZXJyaWRlcyhmZWF0dXJlR2F0ZTogRmVhdHVyZUdhdGVzKTogYm9vbGVhbiB8IHVuZGVmaW5lZDtcbiAgICBzdGF0aWMgZ2V0RmVhdHVyZUZsYWdPdmVycmlkZShmZWF0dXJlR2F0ZTogRmVhdHVyZUdhdGVzKTogYm9vbGVhbiB8IHVuZGVmaW5lZDtcbiAgICBpc0ZlYXR1cmVHYXRlRW5hYmxlZDogKGZlYXR1cmVHYXRlOiBGZWF0dXJlR2F0ZXMpID0+IGJvb2xlYW47XG4gICAgaXNDbGllbnRTZXNzaW9uRW5hYmxlZDogKCkgPT4gYm9vbGVhbjtcbiAgICBnZXRGZWF0dXJlRmxhZ3M6ICgpID0+IFJlY29yZDxzdHJpbmcsIGJvb2xlYW4+O1xuICAgIGdldEZ1bGxGbGFnVmFsdWU6IChmZWF0dXJlR2F0ZTogRmVhdHVyZUdhdGVzKSA9PiBGdWxsRmxhZ1ZhbHVlO1xuICAgIGdldEZ1bGxGbGFnVmFsdWVzOiAoKSA9PiBSZWNvcmQ8c3RyaW5nLCBGdWxsRmxhZ1ZhbHVlPjtcbiAgICBzdGF0aWMgcGVyc2lzdEZlYXR1cmVHYXRlT3ZlcnJpZGVzKCk6IHZvaWQ7XG59XG4iXSwibWFwcGluZ3MiOiI7Ozs7QUFFQSxJQUFXLGdCQUFnQixDQUFDLElBQUc7QUFDL0IsSUFBVyxxQkFBVTtDQUFBO09BQUE7T0FBQTtPQUFBO09BQUE7T0FBQTtPQUFBO09BQUE7T0FBQTtPQUFBO09BQUE7T0FBQTtDQUFBIn0=

package/dist/services/featureFlagService/index.js

@@ -0,0 +1,101 @@
+import logger_default from "../../application/logging/logger.js";
+import { FeatureGates } from "../../application/models/featureGates.js";
+
+//#region src/services/featureFlagService/index.ts
+const FEATURE_FLAGS_STORAGE_KEY = "spiffy-feature-flags";
+const logger = new logger_default("featureFlagService");
+var FeatureFlagService = class FeatureFlagService {
+	constructor(featureGates) {
+		this.isFeatureGateEnabled = (featureGate) => {
+			const gateValue = this.featureGates.find((gate) => gate.name === featureGate);
+			const featureFlagOverride = FeatureFlagService.getFeatureFlagOverride(featureGate);
+			if (featureFlagOverride !== void 0) return featureFlagOverride;
+			if (gateValue == null || gateValue.value == null) {
+				logger.logDebug(`isFeatureGateEnabled featureGate:${featureGate} value is undefined - returning false`);
+				return false;
+			}
+			return gateValue.value;
+		};
+		this.isClientSessionEnabled = () => this.isFeatureGateEnabled(FeatureGates.IsClientSessionEnabled);
+		this.getFeatureFlags = () => {
+			return Object.fromEntries(Object.values(FeatureGates).map((featureGate) => [featureGate, this.isFeatureGateEnabled(featureGate)]));
+		};
+		this.getFullFlagValue = (featureGate) => {
+			const gateValue = this.featureGates.find((gate) => gate.name === featureGate);
+			return {
+				resolved: this.isFeatureGateEnabled(featureGate),
+				initial: gateValue?.value,
+				query_param_override: FeatureFlagService.getQueryParamFeatureGateOverrides(featureGate),
+				window_param_override: FeatureFlagService.getWindowFeatureGateOverrides(featureGate),
+				stored_override: FeatureFlagService.getStoredFeatureGateOverrides(featureGate)
+			};
+		};
+		this.getFullFlagValues = () => {
+			const featureGates$1 = Object.values(FeatureGates).map((featureGate) => [featureGate, this.getFullFlagValue(featureGate)]);
+			return featureGates$1.length > 0 ? featureGates$1.reduce((acc, entry) => {
+				const [name, value] = entry;
+				if (name && value != null) return {
+					...acc,
+					[`feature_gate.${name}`]: value
+				};
+				return acc;
+			}, {}) : {};
+		};
+		this.featureGates = featureGates;
+	}
+	static getQueryParamFeatureGateOverrides(featureGate) {
+		const url = window.location?.href ?? "";
+		if (url.includes("?")) {
+			const urlObj = new URL(url);
+			const params = new URLSearchParams(urlObj.search);
+			const value = Object.fromEntries(params.entries())[featureGate];
+			if (value != null) return value === "true";
+		}
+	}
+	static getWindowFeatureGateOverrides(featureGate) {
+		if (typeof window === "undefined") return;
+		const windowOverride = window;
+		const value = (windowOverride?._envive?.featureOverrides ?? windowOverride?._spiffy?.featureOverrides)?.[String(featureGate)];
+		if (value != null) return value;
+	}
+	static getStoredFeatureGateOverrides(featureGate) {
+		if (typeof window === "undefined" || typeof window.localStorage === "undefined") return;
+		try {
+			const featureFlags = window.localStorage.getItem(FEATURE_FLAGS_STORAGE_KEY);
+			if (!featureFlags) return;
+			return JSON.parse(featureFlags)[featureGate];
+		} catch (err) {
+			logger.logError("getStoredFeatureGateOverrides: error parsing feature flags", err);
+			return;
+		}
+	}
+	static getFeatureFlagOverride(featureGate) {
+		const queryOverride = FeatureFlagService.getQueryParamFeatureGateOverrides(featureGate);
+		if (queryOverride != null) {
+			logger.logDebug(`isFeatureGateEnabled featureGate:${featureGate} overridden by URL param. New value: ${queryOverride}`);
+			return queryOverride;
+		}
+		const windowOverride = FeatureFlagService.getWindowFeatureGateOverrides(featureGate);
+		if (windowOverride != null) {
+			logger.logDebug(`isFeatureGateEnabled featureGate:${featureGate} overridden by window param. New value: ${windowOverride}`);
+			return windowOverride;
+		}
+		const storedOverride = FeatureFlagService.getStoredFeatureGateOverrides(featureGate);
+		if (storedOverride != null) {
+			logger.logDebug(`isFeatureGateEnabled featureGate:${featureGate} overridden by stored value. New value: ${storedOverride}`);
+			return storedOverride;
+		}
+	}
+	static persistFeatureGateOverrides() {
+		if (typeof window === "undefined" || typeof window.localStorage === "undefined") return;
+		const overrides = Object.values(FeatureGates).map((featureGate) => [featureGate, FeatureFlagService.getFeatureFlagOverride(featureGate)]).filter(([, value]) => value !== void 0).reduce((acc, [key, value]) => ({
+			...acc,
+			[key]: value
+		}), {});
+		window.localStorage.setItem(FEATURE_FLAGS_STORAGE_KEY, JSON.stringify(overrides));
+	}
+};
+
+//#endregion
+export { FeatureFlagService };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"index.js","names":["Logger","featureGates"],"sources":["../../../src/services/featureFlagService/index.ts"],"sourcesContent":["import { OrgConfigFeatureGate } from 'src/application/models/api/orgConfigResults';\nimport { FeatureGates } from 'src/application/models/featureGates';\nimport Logger from 'src/application/logging/logger';\n\nconst FEATURE_FLAGS_STORAGE_KEY = 'spiffy-feature-flags';\n\nconst logger = new Logger('featureFlagService');\n\nexport interface FullFlagValue {\n  resolved: boolean;\n  initial: boolean | undefined;\n  query_param_override: boolean | undefined;\n  window_param_override: boolean | undefined;\n  stored_override: boolean | undefined;\n}\n\n// Kept free of React imports: the injection bundle constructs this service\n// before deciding whether to load the React app, and pulling React into\n// that pre-config code path would put it on the eager critical chunk.\nexport class FeatureFlagService {\n  private featureGates: OrgConfigFeatureGate[];\n\n  constructor(featureGates: OrgConfigFeatureGate[]) {\n    this.featureGates = featureGates;\n  }\n\n  static getQueryParamFeatureGateOverrides(featureGate: FeatureGates): boolean | undefined {\n    const url = window.location?.href ?? '';\n    if (url.includes('?')) {\n      const urlObj = new URL(url);\n      const params = new URLSearchParams(urlObj.search);\n      const paramsObj = Object.fromEntries(params.entries());\n      const value = paramsObj[featureGate];\n\n      if (value != null) {\n        return value === 'true';\n      }\n    }\n\n    return undefined;\n  }\n\n  static getWindowFeatureGateOverrides(featureGate: FeatureGates): boolean | undefined {\n    if (typeof window === 'undefined') {\n      return undefined;\n    }\n    const windowOverride = window as Window & {\n      _envive?: { featureOverrides?: Record<string, boolean> };\n      _spiffy?: { featureOverrides?: Record<string, boolean> };\n    };\n    const featureOverrides =\n      windowOverride?._envive?.featureOverrides ?? windowOverride?._spiffy?.featureOverrides;\n    const value = featureOverrides?.[String(featureGate)];\n    if (value != null) {\n      return value;\n    }\n    return undefined;\n  }\n\n  static getStoredFeatureGateOverrides(featureGate: FeatureGates): boolean | undefined {\n    if (typeof window === 'undefined' || typeof window.localStorage === 'undefined') {\n      return undefined;\n    }\n    try {\n      const featureFlags = window.localStorage.getItem(FEATURE_FLAGS_STORAGE_KEY);\n      if (!featureFlags) {\n        return undefined;\n      }\n      const featureFlagsObj = JSON.parse(featureFlags) as Record<string, boolean>;\n      return featureFlagsObj[featureGate];\n    } catch (err) {\n      logger.logError('getStoredFeatureGateOverrides: error parsing feature flags', err);\n      return undefined;\n    }\n  }\n\n  static getFeatureFlagOverride(featureGate: FeatureGates): boolean | undefined {\n    const queryOverride = FeatureFlagService.getQueryParamFeatureGateOverrides(featureGate);\n    if (queryOverride != null) {\n      logger.logDebug(\n        `isFeatureGateEnabled featureGate:${featureGate} overridden by URL param. New value: ${queryOverride}`,\n      );\n      return queryOverride;\n    }\n\n    const windowOverride = FeatureFlagService.getWindowFeatureGateOverrides(featureGate);\n    if (windowOverride != null) {\n      logger.logDebug(\n        `isFeatureGateEnabled featureGate:${featureGate} overridden by window param. New value: ${windowOverride}`,\n      );\n      return windowOverride;\n    }\n\n    const storedOverride = FeatureFlagService.getStoredFeatureGateOverrides(featureGate);\n    if (storedOverride != null) {\n      logger.logDebug(\n        `isFeatureGateEnabled featureGate:${featureGate} overridden by stored value. New value: ${storedOverride}`,\n      );\n      return storedOverride;\n    }\n\n    return undefined;\n  }\n\n  isFeatureGateEnabled = (featureGate: FeatureGates): boolean => {\n    const gateValue = this.featureGates.find(gate => gate.name === featureGate);\n\n    const featureFlagOverride = FeatureFlagService.getFeatureFlagOverride(featureGate);\n    if (featureFlagOverride !== undefined) {\n      return featureFlagOverride;\n    }\n\n    if (gateValue == null || gateValue.value == null) {\n      logger.logDebug(\n        `isFeatureGateEnabled featureGate:${featureGate} value is undefined - returning false`,\n      );\n      return false;\n    }\n    return gateValue.value;\n  };\n\n  // Ensure that standard overrides work as expected\n  isClientSessionEnabled = (): boolean =>\n    this.isFeatureGateEnabled(FeatureGates.IsClientSessionEnabled);\n\n  getFeatureFlags = (): Record<string, boolean> => {\n    return Object.fromEntries(\n      Object.values(FeatureGates).map((featureGate: FeatureGates) => [\n        featureGate,\n        this.isFeatureGateEnabled(featureGate),\n      ]),\n    );\n  };\n\n  getFullFlagValue = (featureGate: FeatureGates): FullFlagValue => {\n    const gateValue = this.featureGates.find(gate => gate.name === featureGate);\n    return {\n      resolved: this.isFeatureGateEnabled(featureGate),\n      initial: gateValue?.value,\n      query_param_override: FeatureFlagService.getQueryParamFeatureGateOverrides(featureGate),\n      window_param_override: FeatureFlagService.getWindowFeatureGateOverrides(featureGate),\n      stored_override: FeatureFlagService.getStoredFeatureGateOverrides(featureGate),\n    };\n  };\n\n  getFullFlagValues = (): Record<string, FullFlagValue> => {\n    const featureGates = Object.values(FeatureGates).map((featureGate: FeatureGates) => [\n      featureGate,\n      this.getFullFlagValue(featureGate),\n    ]);\n\n    return featureGates.length > 0\n      ? featureGates.reduce<Record<string, FullFlagValue>>((acc, entry) => {\n          const [name, value] = entry as [FeatureGates, FullFlagValue];\n          if (name && value != null) {\n            return { ...acc, [`feature_gate.${name}`]: value };\n          }\n          return acc;\n        }, {})\n      : {};\n  };\n\n  static persistFeatureGateOverrides(): void {\n    if (typeof window === 'undefined' || typeof window.localStorage === 'undefined') {\n      return;\n    }\n    const overrides = Object.values(FeatureGates)\n      .map(\n        featureGate =>\n          [featureGate, FeatureFlagService.getFeatureFlagOverride(featureGate)] as const,\n      )\n      .filter(([, value]) => value !== undefined)\n      .reduce<Record<string, boolean>>((acc, [key, value]) => ({ ...acc, [key]: value! }), {});\n    window.localStorage.setItem(FEATURE_FLAGS_STORAGE_KEY, JSON.stringify(overrides));\n  }\n}\n"],"mappings":"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"}

package/dist/services/ga4ProjectionService/ga4EventSchema.cjs

@@ -26,7 +26,13 @@ const require_eventNames = require('../amplitudeService/eventNames.cjs');
 const WIDGET_INTERACTION_DATA_PROJECTIONS = {
 	widget_collapsed: { interaction_collapse_source: "widget_collapsed.collapse_source" },
 	product_card_clicked: { interaction_product_id: "product_card_clicked.product_id" },
-	suggestion_scrolled: { interaction_suggestion_id: "suggestion_scrolled.suggestion_id" }
+	suggestion_scrolled: { interaction_suggestion_id: "suggestion_scrolled.suggestion_id" },
+	variant_selector_opened: { interaction_product_id: "variant_selector_opened.product_id" },
+	variant_option_selected: {
+		interaction_product_id: "variant_option_selected.product_id",
+		interaction_option_name: "variant_option_selected.option_name"
+	},
+	variant_selector_dismissed: { interaction_product_id: "variant_selector_dismissed.product_id" }
 };
 const GA4_EVENT_SCHEMA = {
 	[require_eventNames.EnviveMetricsEventName.WidgetRendered]: {
@@ -110,4 +116,4 @@ const GA4_EVENT_SCHEMA = {
 
 //#endregion
 exports.GA4_EVENT_SCHEMA = GA4_EVENT_SCHEMA;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"ga4EventSchema.cjs","names":["WIDGET_INTERACTION_DATA_PROJECTIONS: WidgetInteractionDataProjection","GA4_EVENT_SCHEMA: Record<EnviveMetricsEventName, GA4EventSchemaEntry>","EnviveMetricsEventName"],"sources":["../../../src/services/ga4ProjectionService/ga4EventSchema.ts"],"sourcesContent":["/**\n * GA4 Event Schema — single source of truth for Envive → GA4 projection.\n *\n * Every EnviveMetricsEventName MUST have an entry here. The Record type enforces\n * this at compile time — adding a new enum member without a schema entry will\n * cause a TypeScript error.\n *\n * ## How to update this file\n *\n * When adding or modifying event properties, decide whether they belong in `allowedFields` using these criteria:\n * - **Low cardinality** — avoid unbounded values (free text, IDs, URLs, timestamps).\n * - **Non-sensitive** — no PII, user input text, or internal implementation details.\n * - **Flat scalar** — GA4 custom dimensions are flat strings/numbers/booleans.\n *   Nested objects should NOT be added; extract specific sub-fields instead.\n * - **Snake_case key** — must already be dot-notation snake_case (e.g. `chat.user_typed`).\n * - **Analytically useful** — the field should enable meaningful filtering/segmentation\n *   for merchants in their GA4 dashboards.\n *\n * If excluded from `allowedFields`, the projection layer will automatically drop it.\n *\n * IF IN DOUBT, DON'T HESITATE TO REACH OUT TO THE ANALYTICS TEAM!!!\n */\nimport { EnviveMetricsEventName } from '../amplitudeService/eventNames';\n\n/**\n * Defines which fields to extract from `trigger.widget_interaction_data`\n * for a given `trigger.widget_interaction` value.\n *\n * Key: the value of `trigger.widget_interaction` (e.g. \"widget_collapsed\")\n * Value: mapping of { ga4FlatKey: sourceFieldInWidgetInteractionData }\n */\nexport type WidgetInteractionDataProjection = Record<string, Record<string, string>>;\n\nexport interface GA4ProjectedEventConfig {\n  gaEventName: string;\n  allowedFields: readonly string[];\n  /**\n   * When present, used instead of `allowedFields` to both filter and rename fields.\n   * Key: the desired GA4 parameter name. Value: the source dot-notation key in eventProps.\n   */\n  fieldProjections?: Record<string, string>;\n  widgetInteractionDataProjections?: WidgetInteractionDataProjection;\n}\n\nexport interface GA4ExcludedEventConfig {\n  gaEventName: null;\n}\n\nexport type GA4EventSchemaEntry = GA4ProjectedEventConfig | GA4ExcludedEventConfig;\n\nconst WIDGET_INTERACTION_DATA_PROJECTIONS: WidgetInteractionDataProjection = {\n  widget_collapsed: { interaction_collapse_source: 'widget_collapsed.collapse_source' },\n  product_card_clicked: { interaction_product_id: 'product_card_clicked.product_id' },\n  suggestion_scrolled: { interaction_suggestion_id: 'suggestion_scrolled.suggestion_id' },\n};\n\nexport const GA4_EVENT_SCHEMA: Record<EnviveMetricsEventName, GA4EventSchemaEntry> = {\n  [EnviveMetricsEventName.WidgetRendered]: {\n    gaEventName: 'envive_widget_rendered',\n    allowedFields: [],\n    fieldProjections: {\n      page_type: 'context.page_type',\n      page_id: 'context.page_id',\n      surface: 'context.surface',\n      widget: 'trigger.widget',\n      widget_role: 'trigger.widget_role',\n    },\n  },\n\n  [EnviveMetricsEventName.WidgetInteraction]: {\n    gaEventName: 'envive_widget_interaction',\n    allowedFields: [],\n    fieldProjections: {\n      page_type: 'context.page_type',\n      page_id: 'context.page_id',\n      surface: 'context.surface',\n      widget: 'trigger.widget',\n      interaction_type: 'trigger.widget_interaction',\n      interaction_class: 'trigger.interaction_class',\n      widget_role: 'trigger.widget_role',\n    },\n    widgetInteractionDataProjections: WIDGET_INTERACTION_DATA_PROJECTIONS,\n  },\n\n  [EnviveMetricsEventName.ChatRequest]: {\n    gaEventName: 'envive_chat_request',\n    allowedFields: [\n      'page_type',\n      'page_id',\n      'trigger.widget',\n      'chat.request_type',\n      // 'chat.request_text', // This is high cardinality and potentially PII but we might want to include it later\n      'chat.user_typed',\n      'chat.suggestion_id', // not currently implemented\n      'chat.suggestion_category', // not currently implemented\n      'chat.suggestion_created_at', // not currently implemented\n      'chat.suggestion_is_answer', // not currently implemented\n      'chat.form_type', // not currently implemented\n    ],\n  },\n\n  [EnviveMetricsEventName.ChatResponse]: {\n    gaEventName: 'envive_chat_response',\n    allowedFields: [\n      'page_type',\n      'page_id',\n      'trigger.widget', // not currently implemented (maybe it should'nt be???)\n      'chat.user_typed',\n      'chat.response_time_ms',\n      'chat.product_cards_returned',\n      'chat.product_ids_returned',\n      'chat.review_cards_returned',\n    ],\n  },\n\n  [EnviveMetricsEventName.EnviveInitialized]: {\n    gaEventName: 'envive_initialized',\n    allowedFields: [\n      'environment.sales_agent_enabled',\n      'environment.envive_enabled',\n      // 'environment.search_enabled', // For now, search is not implemented. We will add it later.\n      'performance.start_time_ms',\n      'performance.initialize_time_ms',\n    ],\n  },\n\n  // This event is not currently implemented\n  [EnviveMetricsEventName.PageViewed]: {\n    gaEventName: 'envive_page_context_evaluated',\n    allowedFields: [],\n    fieldProjections: {\n      page_type: 'context.page_type',\n      page_id: 'context.page_id',\n      context_supported: 'context.supported',\n      context_ready: 'context.ready',\n      context_page_variant_id: 'context.page_variant_id',\n      environment_envive_enabled: 'environment.envive_enabled',\n    },\n  },\n\n  [EnviveMetricsEventName.WidgetTextRequest]: {\n    gaEventName: null,\n  },\n\n  [EnviveMetricsEventName.WidgetTextResponse]: {\n    gaEventName: null,\n  },\n\n  [EnviveMetricsEventName.WidgetTextClicked]: {\n    gaEventName: null,\n  },\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAkDA,MAAMA,sCAAuE;CAC3E,kBAAkB,EAAE,6BAA6B,oCAAoC;CACrF,sBAAsB,EAAE,wBAAwB,mCAAmC;CACnF,qBAAqB,EAAE,2BAA2B,qCAAqC;CACxF;AAED,MAAaC,mBAAwE;EAClFC,0CAAuB,iBAAiB;EACvC,aAAa;EACb,eAAe,EAAE;EACjB,kBAAkB;GAChB,WAAW;GACX,SAAS;GACT,SAAS;GACT,QAAQ;GACR,aAAa;GACd;EACF;EAEAA,0CAAuB,oBAAoB;EAC1C,aAAa;EACb,eAAe,EAAE;EACjB,kBAAkB;GAChB,WAAW;GACX,SAAS;GACT,SAAS;GACT,QAAQ;GACR,kBAAkB;GAClB,mBAAmB;GACnB,aAAa;GACd;EACD,kCAAkC;EACnC;EAEAA,0CAAuB,cAAc;EACpC,aAAa;EACb,eAAe;GACb;GACA;GACA;GACA;GAEA;GACA;GACA;GACA;GACA;GACA;GACD;EACF;EAEAA,0CAAuB,eAAe;EACrC,aAAa;EACb,eAAe;GACb;GACA;GACA;GACA;GACA;GACA;GACA;GACA;GACD;EACF;EAEAA,0CAAuB,oBAAoB;EAC1C,aAAa;EACb,eAAe;GACb;GACA;GAEA;GACA;GACD;EACF;EAGAA,0CAAuB,aAAa;EACnC,aAAa;EACb,eAAe,EAAE;EACjB,kBAAkB;GAChB,WAAW;GACX,SAAS;GACT,mBAAmB;GACnB,eAAe;GACf,yBAAyB;GACzB,4BAA4B;GAC7B;EACF;EAEAA,0CAAuB,oBAAoB,EAC1C,aAAa,MACd;EAEAA,0CAAuB,qBAAqB,EAC3C,aAAa,MACd;EAEAA,0CAAuB,oBAAoB,EAC1C,aAAa,MACd;CACF"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"ga4EventSchema.cjs","names":["WIDGET_INTERACTION_DATA_PROJECTIONS: WidgetInteractionDataProjection","GA4_EVENT_SCHEMA: Record<EnviveMetricsEventName, GA4EventSchemaEntry>","EnviveMetricsEventName"],"sources":["../../../src/services/ga4ProjectionService/ga4EventSchema.ts"],"sourcesContent":["/**\n * GA4 Event Schema — single source of truth for Envive → GA4 projection.\n *\n * Every EnviveMetricsEventName MUST have an entry here. The Record type enforces\n * this at compile time — adding a new enum member without a schema entry will\n * cause a TypeScript error.\n *\n * ## How to update this file\n *\n * When adding or modifying event properties, decide whether they belong in `allowedFields` using these criteria:\n * - **Low cardinality** — avoid unbounded values (free text, IDs, URLs, timestamps).\n * - **Non-sensitive** — no PII, user input text, or internal implementation details.\n * - **Flat scalar** — GA4 custom dimensions are flat strings/numbers/booleans.\n *   Nested objects should NOT be added; extract specific sub-fields instead.\n * - **Snake_case key** — must already be dot-notation snake_case (e.g. `chat.user_typed`).\n * - **Analytically useful** — the field should enable meaningful filtering/segmentation\n *   for merchants in their GA4 dashboards.\n *\n * If excluded from `allowedFields`, the projection layer will automatically drop it.\n *\n * IF IN DOUBT, DON'T HESITATE TO REACH OUT TO THE ANALYTICS TEAM!!!\n */\nimport { EnviveMetricsEventName } from '../amplitudeService/eventNames';\n\n/**\n * Defines which fields to extract from `trigger.widget_interaction_data`\n * for a given `trigger.widget_interaction` value.\n *\n * Key: the value of `trigger.widget_interaction` (e.g. \"widget_collapsed\")\n * Value: mapping of { ga4FlatKey: sourceFieldInWidgetInteractionData }\n */\nexport type WidgetInteractionDataProjection = Record<string, Record<string, string>>;\n\nexport interface GA4ProjectedEventConfig {\n  gaEventName: string;\n  allowedFields: readonly string[];\n  /**\n   * When present, used instead of `allowedFields` to both filter and rename fields.\n   * Key: the desired GA4 parameter name. Value: the source dot-notation key in eventProps.\n   */\n  fieldProjections?: Record<string, string>;\n  widgetInteractionDataProjections?: WidgetInteractionDataProjection;\n}\n\nexport interface GA4ExcludedEventConfig {\n  gaEventName: null;\n}\n\nexport type GA4EventSchemaEntry = GA4ProjectedEventConfig | GA4ExcludedEventConfig;\n\nconst WIDGET_INTERACTION_DATA_PROJECTIONS: WidgetInteractionDataProjection = {\n  widget_collapsed: { interaction_collapse_source: 'widget_collapsed.collapse_source' },\n  product_card_clicked: { interaction_product_id: 'product_card_clicked.product_id' },\n  suggestion_scrolled: { interaction_suggestion_id: 'suggestion_scrolled.suggestion_id' },\n  variant_selector_opened: { interaction_product_id: 'variant_selector_opened.product_id' },\n  // option_value is intentionally excluded — merchant-defined values are high cardinality\n  variant_option_selected: {\n    interaction_product_id: 'variant_option_selected.product_id',\n    interaction_option_name: 'variant_option_selected.option_name',\n  },\n  variant_selector_dismissed: { interaction_product_id: 'variant_selector_dismissed.product_id' },\n};\n\nexport const GA4_EVENT_SCHEMA: Record<EnviveMetricsEventName, GA4EventSchemaEntry> = {\n  [EnviveMetricsEventName.WidgetRendered]: {\n    gaEventName: 'envive_widget_rendered',\n    allowedFields: [],\n    fieldProjections: {\n      page_type: 'context.page_type',\n      page_id: 'context.page_id',\n      surface: 'context.surface',\n      widget: 'trigger.widget',\n      widget_role: 'trigger.widget_role',\n    },\n  },\n\n  [EnviveMetricsEventName.WidgetInteraction]: {\n    gaEventName: 'envive_widget_interaction',\n    allowedFields: [],\n    fieldProjections: {\n      page_type: 'context.page_type',\n      page_id: 'context.page_id',\n      surface: 'context.surface',\n      widget: 'trigger.widget',\n      interaction_type: 'trigger.widget_interaction',\n      interaction_class: 'trigger.interaction_class',\n      widget_role: 'trigger.widget_role',\n    },\n    widgetInteractionDataProjections: WIDGET_INTERACTION_DATA_PROJECTIONS,\n  },\n\n  [EnviveMetricsEventName.ChatRequest]: {\n    gaEventName: 'envive_chat_request',\n    allowedFields: [\n      'page_type',\n      'page_id',\n      'trigger.widget',\n      'chat.request_type',\n      // 'chat.request_text', // This is high cardinality and potentially PII but we might want to include it later\n      'chat.user_typed',\n      'chat.suggestion_id', // not currently implemented\n      'chat.suggestion_category', // not currently implemented\n      'chat.suggestion_created_at', // not currently implemented\n      'chat.suggestion_is_answer', // not currently implemented\n      'chat.form_type', // not currently implemented\n    ],\n  },\n\n  [EnviveMetricsEventName.ChatResponse]: {\n    gaEventName: 'envive_chat_response',\n    allowedFields: [\n      'page_type',\n      'page_id',\n      'trigger.widget', // not currently implemented (maybe it should'nt be???)\n      'chat.user_typed',\n      'chat.response_time_ms',\n      'chat.product_cards_returned',\n      'chat.product_ids_returned',\n      'chat.review_cards_returned',\n    ],\n  },\n\n  [EnviveMetricsEventName.EnviveInitialized]: {\n    gaEventName: 'envive_initialized',\n    allowedFields: [\n      'environment.sales_agent_enabled',\n      'environment.envive_enabled',\n      // 'environment.search_enabled', // For now, search is not implemented. We will add it later.\n      'performance.start_time_ms',\n      'performance.initialize_time_ms',\n    ],\n  },\n\n  // This event is not currently implemented\n  [EnviveMetricsEventName.PageViewed]: {\n    gaEventName: 'envive_page_context_evaluated',\n    allowedFields: [],\n    fieldProjections: {\n      page_type: 'context.page_type',\n      page_id: 'context.page_id',\n      context_supported: 'context.supported',\n      context_ready: 'context.ready',\n      context_page_variant_id: 'context.page_variant_id',\n      environment_envive_enabled: 'environment.envive_enabled',\n    },\n  },\n\n  [EnviveMetricsEventName.WidgetTextRequest]: {\n    gaEventName: null,\n  },\n\n  [EnviveMetricsEventName.WidgetTextResponse]: {\n    gaEventName: null,\n  },\n\n  [EnviveMetricsEventName.WidgetTextClicked]: {\n    gaEventName: null,\n  },\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAkDA,MAAMA,sCAAuE;CAC3E,kBAAkB,EAAE,6BAA6B,oCAAoC;CACrF,sBAAsB,EAAE,wBAAwB,mCAAmC;CACnF,qBAAqB,EAAE,2BAA2B,qCAAqC;CACvF,yBAAyB,EAAE,wBAAwB,sCAAsC;CAEzF,yBAAyB;EACvB,wBAAwB;EACxB,yBAAyB;EAC1B;CACD,4BAA4B,EAAE,wBAAwB,yCAAyC;CAChG;AAED,MAAaC,mBAAwE;EAClFC,0CAAuB,iBAAiB;EACvC,aAAa;EACb,eAAe,EAAE;EACjB,kBAAkB;GAChB,WAAW;GACX,SAAS;GACT,SAAS;GACT,QAAQ;GACR,aAAa;GACd;EACF;EAEAA,0CAAuB,oBAAoB;EAC1C,aAAa;EACb,eAAe,EAAE;EACjB,kBAAkB;GAChB,WAAW;GACX,SAAS;GACT,SAAS;GACT,QAAQ;GACR,kBAAkB;GAClB,mBAAmB;GACnB,aAAa;GACd;EACD,kCAAkC;EACnC;EAEAA,0CAAuB,cAAc;EACpC,aAAa;EACb,eAAe;GACb;GACA;GACA;GACA;GAEA;GACA;GACA;GACA;GACA;GACA;GACD;EACF;EAEAA,0CAAuB,eAAe;EACrC,aAAa;EACb,eAAe;GACb;GACA;GACA;GACA;GACA;GACA;GACA;GACA;GACD;EACF;EAEAA,0CAAuB,oBAAoB;EAC1C,aAAa;EACb,eAAe;GACb;GACA;GAEA;GACA;GACD;EACF;EAGAA,0CAAuB,aAAa;EACnC,aAAa;EACb,eAAe,EAAE;EACjB,kBAAkB;GAChB,WAAW;GACX,SAAS;GACT,mBAAmB;GACnB,eAAe;GACf,yBAAyB;GACzB,4BAA4B;GAC7B;EACF;EAEAA,0CAAuB,oBAAoB,EAC1C,aAAa,MACd;EAEAA,0CAAuB,qBAAqB,EAC3C,aAAa,MACd;EAEAA,0CAAuB,oBAAoB,EAC1C,aAAa,MACd;CACF"}

package/dist/services/ga4ProjectionService/ga4EventSchema.js

@@ -26,7 +26,13 @@ import { EnviveMetricsEventName } from "../amplitudeService/eventNames.js";
 const WIDGET_INTERACTION_DATA_PROJECTIONS = {
 	widget_collapsed: { interaction_collapse_source: "widget_collapsed.collapse_source" },
 	product_card_clicked: { interaction_product_id: "product_card_clicked.product_id" },
-	suggestion_scrolled: { interaction_suggestion_id: "suggestion_scrolled.suggestion_id" }
+	suggestion_scrolled: { interaction_suggestion_id: "suggestion_scrolled.suggestion_id" },
+	variant_selector_opened: { interaction_product_id: "variant_selector_opened.product_id" },
+	variant_option_selected: {
+		interaction_product_id: "variant_option_selected.product_id",
+		interaction_option_name: "variant_option_selected.option_name"
+	},
+	variant_selector_dismissed: { interaction_product_id: "variant_selector_dismissed.product_id" }
 };
 const GA4_EVENT_SCHEMA = {
 	[EnviveMetricsEventName.WidgetRendered]: {
@@ -110,4 +116,4 @@ const GA4_EVENT_SCHEMA = {
 
 //#endregion
 export { GA4_EVENT_SCHEMA };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"ga4EventSchema.js","names":["WIDGET_INTERACTION_DATA_PROJECTIONS: WidgetInteractionDataProjection","GA4_EVENT_SCHEMA: Record<EnviveMetricsEventName, GA4EventSchemaEntry>"],"sources":["../../../src/services/ga4ProjectionService/ga4EventSchema.ts"],"sourcesContent":["/**\n * GA4 Event Schema — single source of truth for Envive → GA4 projection.\n *\n * Every EnviveMetricsEventName MUST have an entry here. The Record type enforces\n * this at compile time — adding a new enum member without a schema entry will\n * cause a TypeScript error.\n *\n * ## How to update this file\n *\n * When adding or modifying event properties, decide whether they belong in `allowedFields` using these criteria:\n * - **Low cardinality** — avoid unbounded values (free text, IDs, URLs, timestamps).\n * - **Non-sensitive** — no PII, user input text, or internal implementation details.\n * - **Flat scalar** — GA4 custom dimensions are flat strings/numbers/booleans.\n *   Nested objects should NOT be added; extract specific sub-fields instead.\n * - **Snake_case key** — must already be dot-notation snake_case (e.g. `chat.user_typed`).\n * - **Analytically useful** — the field should enable meaningful filtering/segmentation\n *   for merchants in their GA4 dashboards.\n *\n * If excluded from `allowedFields`, the projection layer will automatically drop it.\n *\n * IF IN DOUBT, DON'T HESITATE TO REACH OUT TO THE ANALYTICS TEAM!!!\n */\nimport { EnviveMetricsEventName } from '../amplitudeService/eventNames';\n\n/**\n * Defines which fields to extract from `trigger.widget_interaction_data`\n * for a given `trigger.widget_interaction` value.\n *\n * Key: the value of `trigger.widget_interaction` (e.g. \"widget_collapsed\")\n * Value: mapping of { ga4FlatKey: sourceFieldInWidgetInteractionData }\n */\nexport type WidgetInteractionDataProjection = Record<string, Record<string, string>>;\n\nexport interface GA4ProjectedEventConfig {\n  gaEventName: string;\n  allowedFields: readonly string[];\n  /**\n   * When present, used instead of `allowedFields` to both filter and rename fields.\n   * Key: the desired GA4 parameter name. Value: the source dot-notation key in eventProps.\n   */\n  fieldProjections?: Record<string, string>;\n  widgetInteractionDataProjections?: WidgetInteractionDataProjection;\n}\n\nexport interface GA4ExcludedEventConfig {\n  gaEventName: null;\n}\n\nexport type GA4EventSchemaEntry = GA4ProjectedEventConfig | GA4ExcludedEventConfig;\n\nconst WIDGET_INTERACTION_DATA_PROJECTIONS: WidgetInteractionDataProjection = {\n  widget_collapsed: { interaction_collapse_source: 'widget_collapsed.collapse_source' },\n  product_card_clicked: { interaction_product_id: 'product_card_clicked.product_id' },\n  suggestion_scrolled: { interaction_suggestion_id: 'suggestion_scrolled.suggestion_id' },\n};\n\nexport const GA4_EVENT_SCHEMA: Record<EnviveMetricsEventName, GA4EventSchemaEntry> = {\n  [EnviveMetricsEventName.WidgetRendered]: {\n    gaEventName: 'envive_widget_rendered',\n    allowedFields: [],\n    fieldProjections: {\n      page_type: 'context.page_type',\n      page_id: 'context.page_id',\n      surface: 'context.surface',\n      widget: 'trigger.widget',\n      widget_role: 'trigger.widget_role',\n    },\n  },\n\n  [EnviveMetricsEventName.WidgetInteraction]: {\n    gaEventName: 'envive_widget_interaction',\n    allowedFields: [],\n    fieldProjections: {\n      page_type: 'context.page_type',\n      page_id: 'context.page_id',\n      surface: 'context.surface',\n      widget: 'trigger.widget',\n      interaction_type: 'trigger.widget_interaction',\n      interaction_class: 'trigger.interaction_class',\n      widget_role: 'trigger.widget_role',\n    },\n    widgetInteractionDataProjections: WIDGET_INTERACTION_DATA_PROJECTIONS,\n  },\n\n  [EnviveMetricsEventName.ChatRequest]: {\n    gaEventName: 'envive_chat_request',\n    allowedFields: [\n      'page_type',\n      'page_id',\n      'trigger.widget',\n      'chat.request_type',\n      // 'chat.request_text', // This is high cardinality and potentially PII but we might want to include it later\n      'chat.user_typed',\n      'chat.suggestion_id', // not currently implemented\n      'chat.suggestion_category', // not currently implemented\n      'chat.suggestion_created_at', // not currently implemented\n      'chat.suggestion_is_answer', // not currently implemented\n      'chat.form_type', // not currently implemented\n    ],\n  },\n\n  [EnviveMetricsEventName.ChatResponse]: {\n    gaEventName: 'envive_chat_response',\n    allowedFields: [\n      'page_type',\n      'page_id',\n      'trigger.widget', // not currently implemented (maybe it should'nt be???)\n      'chat.user_typed',\n      'chat.response_time_ms',\n      'chat.product_cards_returned',\n      'chat.product_ids_returned',\n      'chat.review_cards_returned',\n    ],\n  },\n\n  [EnviveMetricsEventName.EnviveInitialized]: {\n    gaEventName: 'envive_initialized',\n    allowedFields: [\n      'environment.sales_agent_enabled',\n      'environment.envive_enabled',\n      // 'environment.search_enabled', // For now, search is not implemented. We will add it later.\n      'performance.start_time_ms',\n      'performance.initialize_time_ms',\n    ],\n  },\n\n  // This event is not currently implemented\n  [EnviveMetricsEventName.PageViewed]: {\n    gaEventName: 'envive_page_context_evaluated',\n    allowedFields: [],\n    fieldProjections: {\n      page_type: 'context.page_type',\n      page_id: 'context.page_id',\n      context_supported: 'context.supported',\n      context_ready: 'context.ready',\n      context_page_variant_id: 'context.page_variant_id',\n      environment_envive_enabled: 'environment.envive_enabled',\n    },\n  },\n\n  [EnviveMetricsEventName.WidgetTextRequest]: {\n    gaEventName: null,\n  },\n\n  [EnviveMetricsEventName.WidgetTextResponse]: {\n    gaEventName: null,\n  },\n\n  [EnviveMetricsEventName.WidgetTextClicked]: {\n    gaEventName: null,\n  },\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAkDA,MAAMA,sCAAuE;CAC3E,kBAAkB,EAAE,6BAA6B,oCAAoC;CACrF,sBAAsB,EAAE,wBAAwB,mCAAmC;CACnF,qBAAqB,EAAE,2BAA2B,qCAAqC;CACxF;AAED,MAAaC,mBAAwE;EAClF,uBAAuB,iBAAiB;EACvC,aAAa;EACb,eAAe,EAAE;EACjB,kBAAkB;GAChB,WAAW;GACX,SAAS;GACT,SAAS;GACT,QAAQ;GACR,aAAa;GACd;EACF;EAEA,uBAAuB,oBAAoB;EAC1C,aAAa;EACb,eAAe,EAAE;EACjB,kBAAkB;GAChB,WAAW;GACX,SAAS;GACT,SAAS;GACT,QAAQ;GACR,kBAAkB;GAClB,mBAAmB;GACnB,aAAa;GACd;EACD,kCAAkC;EACnC;EAEA,uBAAuB,cAAc;EACpC,aAAa;EACb,eAAe;GACb;GACA;GACA;GACA;GAEA;GACA;GACA;GACA;GACA;GACA;GACD;EACF;EAEA,uBAAuB,eAAe;EACrC,aAAa;EACb,eAAe;GACb;GACA;GACA;GACA;GACA;GACA;GACA;GACA;GACD;EACF;EAEA,uBAAuB,oBAAoB;EAC1C,aAAa;EACb,eAAe;GACb;GACA;GAEA;GACA;GACD;EACF;EAGA,uBAAuB,aAAa;EACnC,aAAa;EACb,eAAe,EAAE;EACjB,kBAAkB;GAChB,WAAW;GACX,SAAS;GACT,mBAAmB;GACnB,eAAe;GACf,yBAAyB;GACzB,4BAA4B;GAC7B;EACF;EAEA,uBAAuB,oBAAoB,EAC1C,aAAa,MACd;EAEA,uBAAuB,qBAAqB,EAC3C,aAAa,MACd;EAEA,uBAAuB,oBAAoB,EAC1C,aAAa,MACd;CACF"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"ga4EventSchema.js","names":["WIDGET_INTERACTION_DATA_PROJECTIONS: WidgetInteractionDataProjection","GA4_EVENT_SCHEMA: Record<EnviveMetricsEventName, GA4EventSchemaEntry>"],"sources":["../../../src/services/ga4ProjectionService/ga4EventSchema.ts"],"sourcesContent":["/**\n * GA4 Event Schema — single source of truth for Envive → GA4 projection.\n *\n * Every EnviveMetricsEventName MUST have an entry here. The Record type enforces\n * this at compile time — adding a new enum member without a schema entry will\n * cause a TypeScript error.\n *\n * ## How to update this file\n *\n * When adding or modifying event properties, decide whether they belong in `allowedFields` using these criteria:\n * - **Low cardinality** — avoid unbounded values (free text, IDs, URLs, timestamps).\n * - **Non-sensitive** — no PII, user input text, or internal implementation details.\n * - **Flat scalar** — GA4 custom dimensions are flat strings/numbers/booleans.\n *   Nested objects should NOT be added; extract specific sub-fields instead.\n * - **Snake_case key** — must already be dot-notation snake_case (e.g. `chat.user_typed`).\n * - **Analytically useful** — the field should enable meaningful filtering/segmentation\n *   for merchants in their GA4 dashboards.\n *\n * If excluded from `allowedFields`, the projection layer will automatically drop it.\n *\n * IF IN DOUBT, DON'T HESITATE TO REACH OUT TO THE ANALYTICS TEAM!!!\n */\nimport { EnviveMetricsEventName } from '../amplitudeService/eventNames';\n\n/**\n * Defines which fields to extract from `trigger.widget_interaction_data`\n * for a given `trigger.widget_interaction` value.\n *\n * Key: the value of `trigger.widget_interaction` (e.g. \"widget_collapsed\")\n * Value: mapping of { ga4FlatKey: sourceFieldInWidgetInteractionData }\n */\nexport type WidgetInteractionDataProjection = Record<string, Record<string, string>>;\n\nexport interface GA4ProjectedEventConfig {\n  gaEventName: string;\n  allowedFields: readonly string[];\n  /**\n   * When present, used instead of `allowedFields` to both filter and rename fields.\n   * Key: the desired GA4 parameter name. Value: the source dot-notation key in eventProps.\n   */\n  fieldProjections?: Record<string, string>;\n  widgetInteractionDataProjections?: WidgetInteractionDataProjection;\n}\n\nexport interface GA4ExcludedEventConfig {\n  gaEventName: null;\n}\n\nexport type GA4EventSchemaEntry = GA4ProjectedEventConfig | GA4ExcludedEventConfig;\n\nconst WIDGET_INTERACTION_DATA_PROJECTIONS: WidgetInteractionDataProjection = {\n  widget_collapsed: { interaction_collapse_source: 'widget_collapsed.collapse_source' },\n  product_card_clicked: { interaction_product_id: 'product_card_clicked.product_id' },\n  suggestion_scrolled: { interaction_suggestion_id: 'suggestion_scrolled.suggestion_id' },\n  variant_selector_opened: { interaction_product_id: 'variant_selector_opened.product_id' },\n  // option_value is intentionally excluded — merchant-defined values are high cardinality\n  variant_option_selected: {\n    interaction_product_id: 'variant_option_selected.product_id',\n    interaction_option_name: 'variant_option_selected.option_name',\n  },\n  variant_selector_dismissed: { interaction_product_id: 'variant_selector_dismissed.product_id' },\n};\n\nexport const GA4_EVENT_SCHEMA: Record<EnviveMetricsEventName, GA4EventSchemaEntry> = {\n  [EnviveMetricsEventName.WidgetRendered]: {\n    gaEventName: 'envive_widget_rendered',\n    allowedFields: [],\n    fieldProjections: {\n      page_type: 'context.page_type',\n      page_id: 'context.page_id',\n      surface: 'context.surface',\n      widget: 'trigger.widget',\n      widget_role: 'trigger.widget_role',\n    },\n  },\n\n  [EnviveMetricsEventName.WidgetInteraction]: {\n    gaEventName: 'envive_widget_interaction',\n    allowedFields: [],\n    fieldProjections: {\n      page_type: 'context.page_type',\n      page_id: 'context.page_id',\n      surface: 'context.surface',\n      widget: 'trigger.widget',\n      interaction_type: 'trigger.widget_interaction',\n      interaction_class: 'trigger.interaction_class',\n      widget_role: 'trigger.widget_role',\n    },\n    widgetInteractionDataProjections: WIDGET_INTERACTION_DATA_PROJECTIONS,\n  },\n\n  [EnviveMetricsEventName.ChatRequest]: {\n    gaEventName: 'envive_chat_request',\n    allowedFields: [\n      'page_type',\n      'page_id',\n      'trigger.widget',\n      'chat.request_type',\n      // 'chat.request_text', // This is high cardinality and potentially PII but we might want to include it later\n      'chat.user_typed',\n      'chat.suggestion_id', // not currently implemented\n      'chat.suggestion_category', // not currently implemented\n      'chat.suggestion_created_at', // not currently implemented\n      'chat.suggestion_is_answer', // not currently implemented\n      'chat.form_type', // not currently implemented\n    ],\n  },\n\n  [EnviveMetricsEventName.ChatResponse]: {\n    gaEventName: 'envive_chat_response',\n    allowedFields: [\n      'page_type',\n      'page_id',\n      'trigger.widget', // not currently implemented (maybe it should'nt be???)\n      'chat.user_typed',\n      'chat.response_time_ms',\n      'chat.product_cards_returned',\n      'chat.product_ids_returned',\n      'chat.review_cards_returned',\n    ],\n  },\n\n  [EnviveMetricsEventName.EnviveInitialized]: {\n    gaEventName: 'envive_initialized',\n    allowedFields: [\n      'environment.sales_agent_enabled',\n      'environment.envive_enabled',\n      // 'environment.search_enabled', // For now, search is not implemented. We will add it later.\n      'performance.start_time_ms',\n      'performance.initialize_time_ms',\n    ],\n  },\n\n  // This event is not currently implemented\n  [EnviveMetricsEventName.PageViewed]: {\n    gaEventName: 'envive_page_context_evaluated',\n    allowedFields: [],\n    fieldProjections: {\n      page_type: 'context.page_type',\n      page_id: 'context.page_id',\n      context_supported: 'context.supported',\n      context_ready: 'context.ready',\n      context_page_variant_id: 'context.page_variant_id',\n      environment_envive_enabled: 'environment.envive_enabled',\n    },\n  },\n\n  [EnviveMetricsEventName.WidgetTextRequest]: {\n    gaEventName: null,\n  },\n\n  [EnviveMetricsEventName.WidgetTextResponse]: {\n    gaEventName: null,\n  },\n\n  [EnviveMetricsEventName.WidgetTextClicked]: {\n    gaEventName: null,\n  },\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAkDA,MAAMA,sCAAuE;CAC3E,kBAAkB,EAAE,6BAA6B,oCAAoC;CACrF,sBAAsB,EAAE,wBAAwB,mCAAmC;CACnF,qBAAqB,EAAE,2BAA2B,qCAAqC;CACvF,yBAAyB,EAAE,wBAAwB,sCAAsC;CAEzF,yBAAyB;EACvB,wBAAwB;EACxB,yBAAyB;EAC1B;CACD,4BAA4B,EAAE,wBAAwB,yCAAyC;CAChG;AAED,MAAaC,mBAAwE;EAClF,uBAAuB,iBAAiB;EACvC,aAAa;EACb,eAAe,EAAE;EACjB,kBAAkB;GAChB,WAAW;GACX,SAAS;GACT,SAAS;GACT,QAAQ;GACR,aAAa;GACd;EACF;EAEA,uBAAuB,oBAAoB;EAC1C,aAAa;EACb,eAAe,EAAE;EACjB,kBAAkB;GAChB,WAAW;GACX,SAAS;GACT,SAAS;GACT,QAAQ;GACR,kBAAkB;GAClB,mBAAmB;GACnB,aAAa;GACd;EACD,kCAAkC;EACnC;EAEA,uBAAuB,cAAc;EACpC,aAAa;EACb,eAAe;GACb;GACA;GACA;GACA;GAEA;GACA;GACA;GACA;GACA;GACA;GACD;EACF;EAEA,uBAAuB,eAAe;EACrC,aAAa;EACb,eAAe;GACb;GACA;GACA;GACA;GACA;GACA;GACA;GACA;GACD;EACF;EAEA,uBAAuB,oBAAoB;EAC1C,aAAa;EACb,eAAe;GACb;GACA;GAEA;GACA;GACD;EACF;EAGA,uBAAuB,aAAa;EACnC,aAAa;EACb,eAAe,EAAE;EACjB,kBAAkB;GAChB,WAAW;GACX,SAAS;GACT,mBAAmB;GACnB,eAAe;GACf,yBAAyB;GACzB,4BAA4B;GAC7B;EACF;EAEA,uBAAuB,oBAAoB,EAC1C,aAAa,MACd;EAEA,uBAAuB,qBAAqB,EAC3C,aAAa,MACd;EAEA,uBAAuB,oBAAoB,EAC1C,aAAa,MACd;CACF"}

package/dist/services/hardcopyService/hardcopyService.cjs

@@ -1,8 +1,8 @@
 const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
-const require_contexts_typesV3 = require('../../contexts/typesV3.cjs');
 const require_logger = require('../../application/logging/logger.cjs');
 const require_urlsParser = require('../../application/utils/urlsParser.cjs');
 const require_snakeToCamelTransformer = require('../../application/models/utils/snakeToCamelTransformer.cjs');
+const require_contexts_typesV3 = require('../../contexts/typesV3.cjs');
 const require_eventNames = require('../amplitudeService/eventNames.cjs');
 require('../../application/utils/index.cjs');
 const require_atomStore = require('../../atoms/atomStore/atomStore.cjs');
@@ -199,7 +199,8 @@ var HardcopyService = class {
 						widget_type: request.widgetType,
 						response_id: response.responseId,
 						widget_text: response.values,
-						request_id: widgetTextRequest.requestId
+						request_id: widgetTextRequest.requestId,
+						...response.aiSuggestionsAttributionBySlot ? { ai_suggestions_attribution_by_slot: response.aiSuggestionsAttributionBySlot } : {}
 					}
 				});
 				return convertedResponse;
@@ -231,4 +232,4 @@ var MockHardcopyService = class {
 exports.HardcopyService = HardcopyService;
 exports.MOCK_HARDCOPY_RESPONSE = MOCK_HARDCOPY_RESPONSE;
 exports.MockHardcopyService = MockHardcopyService;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"hardcopyService.cjs","names":["Logger","MOCK_HARDCOPY_RESPONSE: Partial<Record<WidgetTypeV3, HardcopyResponse>>","WidgetTypeV3","toCamelCase","config: HardcopyServiceConfig","getQueryParam","getAtomStore","resolvedBaseConfigVersionAtom","widgetTextRequest: WidgetTextRequest","EnviveMetricsEventName","CommerceApiClient","overrides: Partial<Record<WidgetTypeV3, HardcopyResponse>>"],"sources":["../../../src/services/hardcopyService/hardcopyService.ts"],"sourcesContent":["import { v4 as uuid } from 'uuid';\nimport CommerceApiClient from 'src/application/commerce-api';\nimport { WidgetString, WidgetText } from 'src/application/models/api/widgetText';\nimport { WidgetTextRequest } from 'src/application/models/api/widgetTextRequest';\nimport { toCamelCase } from 'src/application/models/utils/snakeToCamelTransformer';\nimport { getQueryParam } from 'src/application/utils';\nimport { UserEvent } from 'src/application/models';\nimport Logger from 'src/application/logging/logger';\nimport { AppDetails } from 'src/atoms/app';\nimport { getAtomStore } from 'src/atoms/atomStore/atomStore';\nimport { resolvedBaseConfigVersionAtom } from 'src/atoms/envive/resolvedBaseConfigVersion';\nimport { WidgetTypeV3 } from 'src/contexts/typesV3';\nimport { EnviveMetricsEventName, TrackEventParams } from '../amplitudeService';\n\nconst logger = new Logger('hardcopyService');\n\nexport interface HardcopyRequest {\n  widgetType: WidgetTypeV3;\n  userEvent: UserEvent;\n}\n\nexport type HardcopyResponse = {\n  responseId: string;\n  language: string;\n  rawValues?: Record<string, WidgetString | WidgetString[]>;\n  values: Record<string, string | string[]>;\n};\n\nexport interface IHardcopyService {\n  getHardcopy(request: HardcopyRequest): Promise<HardcopyResponse>;\n}\n\nexport interface HardcopyServiceConfig {\n  getAppDetails: () => AppDetails;\n  getFeatureFlags: () => Record<string, boolean>;\n  trackEvent?: (params: TrackEventParams) => Promise<void>;\n}\n\n// Sample responses used both as fallback when the backend fails and by MockHardcopyService.\nexport const MOCK_HARDCOPY_RESPONSE: Partial<Record<WidgetTypeV3, HardcopyResponse>> = {\n  [WidgetTypeV3.PromptCarouselV3]: {\n    responseId: uuid(),\n    language: 'en',\n    values: {\n      promptButtonTexts: [\n        'What are your best sellers?',\n        'Show me summer dresses',\n        'Do you have free shipping?',\n        'What sizes are available?',\n        'Can I return items?',\n      ],\n    },\n  },\n  [WidgetTypeV3.TitledPromptCarouselV3]: {\n    responseId: 'mock-response-id',\n    language: 'en',\n    values: {\n      titleLabel: 'Need some help?',\n      promptButtonTexts: [\n        'What are your best sellers?',\n        'Show me summer dresses',\n        'Do you have free shipping?',\n        'What sizes are available?',\n        'Can I return items?',\n      ],\n    },\n  },\n  [WidgetTypeV3.SocialProofV3]: {\n    responseId: 'mock-response-id',\n    language: 'en',\n    values: {\n      titleLabel: 'Shopping Assistant',\n      numberOfCustomersText: '123 customers',\n      customerQueryText: 'found what they were looking for...',\n      primaryButtonText: 'Start shopping',\n      secondaryButtonTitleText: 'Popular searches',\n      secondaryButtonTexts: [\n        'Why should I buy from you?',\n        'How do I return an item?',\n        'New arrivals',\n        'Sale items',\n        'Popular items',\n      ],\n      textFieldPlaceholderText: 'Ask me anything...',\n    },\n  },\n  [WidgetTypeV3.TypingAnimationV3]: {\n    responseId: 'mock-response-id',\n    language: 'en',\n    values: {\n      titleLabel: 'Shopping Assistant',\n      headlineText: 'Need help finding',\n      animatedTextSequence: [\n        'the perfect gift for your loved ones?',\n        'something special for the holidays?',\n        'the ideal present for someone special?',\n      ],\n      hintText: 'Ask me anything',\n      promptButtonTexts: [\n        'What are your best sellers?',\n        'Show me summer dresses',\n        'Do you have free shipping?',\n        'What sizes are available?',\n      ],\n      textFieldAriaLabel: 'Ask me anything',\n    },\n  },\n  [WidgetTypeV3.ChatPreviewComparisonV3]: {\n    responseId: 'mock-response-id',\n    language: 'en',\n    values: {\n      titleLabel: 'Shopping Assistant',\n      headlineText: 'Need help comparing?',\n      textFieldPlaceholderText: 'Ask me anything...',\n    },\n  },\n  [WidgetTypeV3.ChatPreviewLoadingV3]: {\n    responseId: 'mock-response-id',\n    language: 'en',\n    values: {\n      titleLabel: 'Shopping Assistant',\n      textFieldPlaceholderText: 'Ask me anything...',\n    },\n  },\n  [WidgetTypeV3.ChatPreviewV3]: {\n    responseId: 'mock-response-id',\n    language: 'en',\n    values: {\n      titleLabel: 'Shopping Assistant',\n      textFieldPlaceholderText: 'Ask me anything...',\n    },\n  },\n  [WidgetTypeV3.PromptButtonCarouselWithImageV3]: {\n    responseId: 'mock-response-id',\n    language: 'en',\n    values: {\n      titleLabel: 'Need some help?',\n      promptButtonsTexts: ['Help me find a product', \"What's on your mind?\", 'Talk to a human'],\n      textFieldPlaceholderText: 'Ask me anything...',\n    },\n  },\n  [WidgetTypeV3.ProductCardV3]: {\n    responseId: 'mock-response-id',\n    language: 'en',\n    values: {\n      headline: 'Discover Your Perfect Style',\n      animatedText: [\n        'the perfect outfit for any occasion',\n        'trending fashion that fits your lifestyle',\n        'quality pieces that last',\n      ],\n      prompts: [\n        'What are your best sellers?',\n        'Show me summer dresses',\n        'Do you have free shipping?',\n        'What sizes are available?',\n        'Can I return items?',\n      ],\n      placeholder: 'Ask me anything...',\n    },\n  },\n  [WidgetTypeV3.FloatingChatV3]: {\n    responseId: 'mock-response-id',\n    language: 'en',\n    values: {\n      welcomeMessageTitle: 'Welcome to Envive AI',\n      welcomeMessageText:\n        'Your personal shopper trained on the collective knowledge of thousands of real experts!',\n      chatFooterTextFieldPlaceholderText: 'Ask me anything...',\n      disclaimerText: 'This is a disclaimer...',\n      leftToggleLabel: 'Shop with AI',\n      rightToggleLabel: 'Live support',\n    },\n  },\n  [WidgetTypeV3.FullPageSalesAgentV3]: {\n    responseId: 'mock-response-id',\n    language: 'en',\n    values: {\n      welcomeMessageTitle: 'Welcome to Envive AI',\n      welcomeMessageText:\n        'Your personal shopper trained on the collective knowledge of thousands of real experts!',\n      chatFooterTextFieldPlaceholderText: 'Ask me anything...',\n      disclaimerText: 'This is a disclaimer...',\n    },\n  },\n};\n\nconst convertToHardcopyResponse = (response: WidgetText): HardcopyResponse => ({\n  responseId: response.responseId,\n  language: response.language,\n  rawValues: response.values,\n  values: Object.fromEntries(\n    Object.entries(response.values).map(([key, value]) => [\n      toCamelCase(key),\n      value.length === 1 ? value[0].value : value.map(v => v.value),\n    ]),\n  ),\n});\n\nexport class HardcopyService implements IHardcopyService {\n  constructor(private config: HardcopyServiceConfig) {}\n\n  async getHardcopy(request: HardcopyRequest): Promise<HardcopyResponse> {\n    const overrideConfigVersion =\n      getQueryParam('spiffy_config_version') ||\n      getQueryParam('envive_config_version') ||\n      getAtomStore().get(resolvedBaseConfigVersionAtom) ||\n      undefined;\n\n    const widgetTextRequest: WidgetTextRequest = {\n      requestId: uuid(),\n      widgetType: request.widgetType,\n      context: this.config.getAppDetails(),\n      featureFlags: this.config.getFeatureFlags(),\n      language: navigator.languages[0] || 'en',\n      overrideConfigVersion,\n      url: window.location.href,\n    };\n\n    this.config.trackEvent?.({\n      eventName: EnviveMetricsEventName.WidgetTextRequest,\n      eventProps: {\n        widget_type: request.widgetType,\n        request_id: widgetTextRequest.requestId,\n      },\n    });\n\n    try {\n      const response = await CommerceApiClient.getHardcopy(widgetTextRequest);\n      if (response) {\n        const convertedResponse = convertToHardcopyResponse(response);\n        logger.logDebug('converted response', convertedResponse);\n        this.config.trackEvent?.({\n          eventName: EnviveMetricsEventName.WidgetTextResponse,\n          eventProps: {\n            widget_type: request.widgetType,\n            response_id: response.responseId,\n            widget_text: response.values,\n            request_id: widgetTextRequest.requestId,\n          },\n        });\n        return convertedResponse;\n      }\n    } catch (error) {\n      logger.logError('error getting hardcopy from backend', error);\n    }\n\n    const mockResponse = MOCK_HARDCOPY_RESPONSE[request.widgetType];\n    if (mockResponse) {\n      logger.logDebug('no real response, using mock', mockResponse);\n      return mockResponse;\n    }\n    throw new Error(`No hardcopy response found for widget type: ${request.widgetType}`);\n  }\n}\n\nexport class MockHardcopyService implements IHardcopyService {\n  constructor(private overrides: Partial<Record<WidgetTypeV3, HardcopyResponse>> = {}) {}\n\n  async getHardcopy(request: HardcopyRequest): Promise<HardcopyResponse> {\n    const fallbackWidgetType =\n      request.widgetType === WidgetTypeV3.ProductCardV3\n        ? WidgetTypeV3.ImagePromptCardV3\n        : request.widgetType;\n\n    const response =\n      this.overrides[request.widgetType] ??\n      this.overrides[fallbackWidgetType] ??\n      MOCK_HARDCOPY_RESPONSE[request.widgetType];\n\n    if (!response) {\n      throw new Error(`No hardcopy response found for widget type: ${request.widgetType}`);\n    }\n    return response;\n  }\n}\n"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"hardcopyService.cjs","names":["Logger","MOCK_HARDCOPY_RESPONSE: Partial<Record<WidgetTypeV3, HardcopyResponse>>","WidgetTypeV3","toCamelCase","config: HardcopyServiceConfig","getQueryParam","getAtomStore","resolvedBaseConfigVersionAtom","widgetTextRequest: WidgetTextRequest","EnviveMetricsEventName","CommerceApiClient","overrides: Partial<Record<WidgetTypeV3, HardcopyResponse>>"],"sources":["../../../src/services/hardcopyService/hardcopyService.ts"],"sourcesContent":["import { v4 as uuid } from 'uuid';\nimport CommerceApiClient from 'src/application/commerce-api';\nimport { WidgetString, WidgetText } from 'src/application/models/api/widgetText';\nimport { WidgetTextRequest } from 'src/application/models/api/widgetTextRequest';\nimport { toCamelCase } from 'src/application/models/utils/snakeToCamelTransformer';\nimport { getQueryParam } from 'src/application/utils';\nimport { UserEvent } from 'src/application/models';\nimport Logger from 'src/application/logging/logger';\nimport { AppDetails } from 'src/atoms/app';\nimport { getAtomStore } from 'src/atoms/atomStore/atomStore';\nimport { resolvedBaseConfigVersionAtom } from 'src/atoms/envive/resolvedBaseConfigVersion';\nimport { WidgetTypeV3 } from 'src/contexts/typesV3';\nimport { EnviveMetricsEventName, TrackEventParams } from '../amplitudeService';\n\nconst logger = new Logger('hardcopyService');\n\nexport interface HardcopyRequest {\n  widgetType: WidgetTypeV3;\n  userEvent: UserEvent;\n}\n\nexport type HardcopyResponse = {\n  responseId: string;\n  language: string;\n  rawValues?: Record<string, WidgetString | WidgetString[]>;\n  values: Record<string, string | string[]>;\n};\n\nexport interface IHardcopyService {\n  getHardcopy(request: HardcopyRequest): Promise<HardcopyResponse>;\n}\n\nexport interface HardcopyServiceConfig {\n  getAppDetails: () => AppDetails;\n  getFeatureFlags: () => Record<string, boolean>;\n  trackEvent?: (params: TrackEventParams) => Promise<void>;\n}\n\n// Sample responses used both as fallback when the backend fails and by MockHardcopyService.\nexport const MOCK_HARDCOPY_RESPONSE: Partial<Record<WidgetTypeV3, HardcopyResponse>> = {\n  [WidgetTypeV3.PromptCarouselV3]: {\n    responseId: uuid(),\n    language: 'en',\n    values: {\n      promptButtonTexts: [\n        'What are your best sellers?',\n        'Show me summer dresses',\n        'Do you have free shipping?',\n        'What sizes are available?',\n        'Can I return items?',\n      ],\n    },\n  },\n  [WidgetTypeV3.TitledPromptCarouselV3]: {\n    responseId: 'mock-response-id',\n    language: 'en',\n    values: {\n      titleLabel: 'Need some help?',\n      promptButtonTexts: [\n        'What are your best sellers?',\n        'Show me summer dresses',\n        'Do you have free shipping?',\n        'What sizes are available?',\n        'Can I return items?',\n      ],\n    },\n  },\n  [WidgetTypeV3.SocialProofV3]: {\n    responseId: 'mock-response-id',\n    language: 'en',\n    values: {\n      titleLabel: 'Shopping Assistant',\n      numberOfCustomersText: '123 customers',\n      customerQueryText: 'found what they were looking for...',\n      primaryButtonText: 'Start shopping',\n      secondaryButtonTitleText: 'Popular searches',\n      secondaryButtonTexts: [\n        'Why should I buy from you?',\n        'How do I return an item?',\n        'New arrivals',\n        'Sale items',\n        'Popular items',\n      ],\n      textFieldPlaceholderText: 'Ask me anything...',\n    },\n  },\n  [WidgetTypeV3.TypingAnimationV3]: {\n    responseId: 'mock-response-id',\n    language: 'en',\n    values: {\n      titleLabel: 'Shopping Assistant',\n      headlineText: 'Need help finding',\n      animatedTextSequence: [\n        'the perfect gift for your loved ones?',\n        'something special for the holidays?',\n        'the ideal present for someone special?',\n      ],\n      hintText: 'Ask me anything',\n      promptButtonTexts: [\n        'What are your best sellers?',\n        'Show me summer dresses',\n        'Do you have free shipping?',\n        'What sizes are available?',\n      ],\n      textFieldAriaLabel: 'Ask me anything',\n    },\n  },\n  [WidgetTypeV3.ChatPreviewComparisonV3]: {\n    responseId: 'mock-response-id',\n    language: 'en',\n    values: {\n      titleLabel: 'Shopping Assistant',\n      headlineText: 'Need help comparing?',\n      textFieldPlaceholderText: 'Ask me anything...',\n    },\n  },\n  [WidgetTypeV3.ChatPreviewLoadingV3]: {\n    responseId: 'mock-response-id',\n    language: 'en',\n    values: {\n      titleLabel: 'Shopping Assistant',\n      textFieldPlaceholderText: 'Ask me anything...',\n    },\n  },\n  [WidgetTypeV3.ChatPreviewV3]: {\n    responseId: 'mock-response-id',\n    language: 'en',\n    values: {\n      titleLabel: 'Shopping Assistant',\n      textFieldPlaceholderText: 'Ask me anything...',\n    },\n  },\n  [WidgetTypeV3.PromptButtonCarouselWithImageV3]: {\n    responseId: 'mock-response-id',\n    language: 'en',\n    values: {\n      titleLabel: 'Need some help?',\n      promptButtonsTexts: ['Help me find a product', \"What's on your mind?\", 'Talk to a human'],\n      textFieldPlaceholderText: 'Ask me anything...',\n    },\n  },\n  [WidgetTypeV3.ProductCardV3]: {\n    responseId: 'mock-response-id',\n    language: 'en',\n    values: {\n      headline: 'Discover Your Perfect Style',\n      animatedText: [\n        'the perfect outfit for any occasion',\n        'trending fashion that fits your lifestyle',\n        'quality pieces that last',\n      ],\n      prompts: [\n        'What are your best sellers?',\n        'Show me summer dresses',\n        'Do you have free shipping?',\n        'What sizes are available?',\n        'Can I return items?',\n      ],\n      placeholder: 'Ask me anything...',\n    },\n  },\n  [WidgetTypeV3.FloatingChatV3]: {\n    responseId: 'mock-response-id',\n    language: 'en',\n    values: {\n      welcomeMessageTitle: 'Welcome to Envive AI',\n      welcomeMessageText:\n        'Your personal shopper trained on the collective knowledge of thousands of real experts!',\n      chatFooterTextFieldPlaceholderText: 'Ask me anything...',\n      disclaimerText: 'This is a disclaimer...',\n      leftToggleLabel: 'Shop with AI',\n      rightToggleLabel: 'Live support',\n    },\n  },\n  [WidgetTypeV3.FullPageSalesAgentV3]: {\n    responseId: 'mock-response-id',\n    language: 'en',\n    values: {\n      welcomeMessageTitle: 'Welcome to Envive AI',\n      welcomeMessageText:\n        'Your personal shopper trained on the collective knowledge of thousands of real experts!',\n      chatFooterTextFieldPlaceholderText: 'Ask me anything...',\n      disclaimerText: 'This is a disclaimer...',\n    },\n  },\n};\n\nconst convertToHardcopyResponse = (response: WidgetText): HardcopyResponse => ({\n  responseId: response.responseId,\n  language: response.language,\n  rawValues: response.values,\n  values: Object.fromEntries(\n    Object.entries(response.values).map(([key, value]) => [\n      toCamelCase(key),\n      value.length === 1 ? value[0].value : value.map(v => v.value),\n    ]),\n  ),\n});\n\nexport class HardcopyService implements IHardcopyService {\n  constructor(private config: HardcopyServiceConfig) {}\n\n  async getHardcopy(request: HardcopyRequest): Promise<HardcopyResponse> {\n    const overrideConfigVersion =\n      getQueryParam('spiffy_config_version') ||\n      getQueryParam('envive_config_version') ||\n      getAtomStore().get(resolvedBaseConfigVersionAtom) ||\n      undefined;\n\n    const widgetTextRequest: WidgetTextRequest = {\n      requestId: uuid(),\n      widgetType: request.widgetType,\n      context: this.config.getAppDetails(),\n      featureFlags: this.config.getFeatureFlags(),\n      language: navigator.languages[0] || 'en',\n      overrideConfigVersion,\n      url: window.location.href,\n    };\n\n    this.config.trackEvent?.({\n      eventName: EnviveMetricsEventName.WidgetTextRequest,\n      eventProps: {\n        widget_type: request.widgetType,\n        request_id: widgetTextRequest.requestId,\n      },\n    });\n\n    try {\n      const response = await CommerceApiClient.getHardcopy(widgetTextRequest);\n      if (response) {\n        const convertedResponse = convertToHardcopyResponse(response);\n        logger.logDebug('converted response', convertedResponse);\n        this.config.trackEvent?.({\n          eventName: EnviveMetricsEventName.WidgetTextResponse,\n          eventProps: {\n            widget_type: request.widgetType,\n            response_id: response.responseId,\n            widget_text: response.values,\n            request_id: widgetTextRequest.requestId,\n            // Which method served each overridden slot — training/attribution\n            // reads this from the analytics event; passed through verbatim.\n            ...(response.aiSuggestionsAttributionBySlot\n              ? { ai_suggestions_attribution_by_slot: response.aiSuggestionsAttributionBySlot }\n              : {}),\n          },\n        });\n        return convertedResponse;\n      }\n    } catch (error) {\n      logger.logError('error getting hardcopy from backend', error);\n    }\n\n    const mockResponse = MOCK_HARDCOPY_RESPONSE[request.widgetType];\n    if (mockResponse) {\n      logger.logDebug('no real response, using mock', mockResponse);\n      return mockResponse;\n    }\n    throw new Error(`No hardcopy response found for widget type: ${request.widgetType}`);\n  }\n}\n\nexport class MockHardcopyService implements IHardcopyService {\n  constructor(private overrides: Partial<Record<WidgetTypeV3, HardcopyResponse>> = {}) {}\n\n  async getHardcopy(request: HardcopyRequest): Promise<HardcopyResponse> {\n    const fallbackWidgetType =\n      request.widgetType === WidgetTypeV3.ProductCardV3\n        ? WidgetTypeV3.ImagePromptCardV3\n        : request.widgetType;\n\n    const response =\n      this.overrides[request.widgetType] ??\n      this.overrides[fallbackWidgetType] ??\n      MOCK_HARDCOPY_RESPONSE[request.widgetType];\n\n    if (!response) {\n      throw new Error(`No hardcopy response found for widget type: ${request.widgetType}`);\n    }\n    return response;\n  }\n}\n"],"mappings":"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"}

package/dist/services/hardcopyService/hardcopyService.d.cts

@@ -1,6 +1,6 @@
-import { WidgetTypeV3 } from "../../contexts/typesV3.cjs";
 import { WidgetString } from "../../application/models/api/widgetText.cjs";
 import { AppDetails } from "../../atoms/app/index.cjs";
+import { WidgetTypeV3 } from "../../contexts/typesV3.cjs";
 import { TrackEventParams } from "../amplitudeService/amplitudeService.cjs";
 import { UserEvent } from "../../application/models/api/userEvent.cjs";
 

package/dist/services/hardcopyService/hardcopyService.d.ts

@@ -1,6 +1,6 @@
-import { WidgetTypeV3 } from "../../contexts/typesV3.js";
 import { WidgetString } from "../../application/models/api/widgetText.js";
 import { AppDetails } from "../../atoms/app/index.js";
+import { WidgetTypeV3 } from "../../contexts/typesV3.js";
 import { TrackEventParams } from "../amplitudeService/amplitudeService.js";
 import { UserEvent } from "../../application/models/api/userEvent.js";