@envive-ai/react-hooks 0.1.5 → 0.1.7

package/dist/app-D_upYeqF.js

@@ -0,0 +1,132 @@
+import { OrgShortName } from "./models-Dn8Emdzc.js";
+import { FeatureGates } from "./featureGates-Blx10fwB.js";
+import { contextSourceAtom, enviveConfigAtom } from "./enviveConfig-BJZ4zTJo.js";
+import { sessionStorageUtil } from "./atomStore-DnPEioF4.js";
+import { ContextSourceEnum, SupportedEventProductCategory } from "@spiffy-ai/commerce-api-client";
+import { atom } from "jotai";
+import { atomWithStorage } from "jotai/utils";
+import { v4 } from "uuid";
+
+//#region src/atoms/app/variant.ts
+const internalStorageUrlResolverAtom = atomWithStorage("spiffy-url-resolver", void 0, sessionStorageUtil, { getOnInit: true });
+const urlResolverAtom = atom((get) => {
+	const maybeUrlResolver = get(internalStorageUrlResolverAtom);
+	if (maybeUrlResolver == null) return {};
+	return JSON.parse(maybeUrlResolver);
+}, (get, set, value) => {
+	const newCache = {
+		...get(urlResolverAtom),
+		[value.url]: value.response
+	};
+	set(internalStorageUrlResolverAtom, JSON.stringify(newCache));
+});
+const internalStorageSupportedEventAtom = atomWithStorage("spiffy-supported-event", void 0, sessionStorageUtil, { getOnInit: true });
+const internalSupportedEventAtom = atom(void 0);
+const featureFlagServiceAtom = atom((get) => {
+	const featureOverrides = get(enviveConfigAtom)?.featureOverrides;
+	return { isFeatureGateEnabled: (gate) => featureOverrides?.[gate] || false };
+});
+const supportedEventAtom = atom((get) => {
+	const maybeSupportedEvent = get(internalStorageSupportedEventAtom);
+	if (maybeSupportedEvent == null) return;
+	return JSON.parse(maybeSupportedEvent);
+}, (get, set, value) => {
+	if (value == null) {
+		set(internalStorageSupportedEventAtom, void 0);
+		set(internalSupportedEventAtom, void 0);
+		return;
+	}
+	const featureFlagService = get(featureFlagServiceAtom);
+	const variantCategory = get(internalSupportedEventAtom)?.category;
+	const orgShortName = get(enviveConfigAtom)?.orgShortName;
+	if (featureFlagService && !featureFlagService.isFeatureGateEnabled(FeatureGates.IsNonShapewearEnabled) && variantCategory && variantCategory !== SupportedEventProductCategory.Shapewear && (orgShortName === OrgShortName.Spanx || orgShortName === OrgShortName.SpanxStaging)) {
+		const modifiedSupportedEvent = {
+			supported: false,
+			ready: value.ready,
+			category: value.category,
+			numberOfReviews: value.numberOfReviews,
+			collections: value.collections,
+			top_category: value.top_category,
+			merchant_tags: value.merchant_tags
+		};
+		set(internalSupportedEventAtom, modifiedSupportedEvent);
+		set(internalStorageSupportedEventAtom, JSON.stringify(modifiedSupportedEvent));
+		return;
+	}
+	set(internalSupportedEventAtom, value);
+	set(internalStorageSupportedEventAtom, JSON.stringify(value));
+});
+const internalVariantIdAtom = atom();
+const internalProductIdAtom = atom();
+const internalParentProductIdAtom = atom();
+const internalProductUrlAtom = atom();
+const internalPlpIdAtom = atom();
+const internalUrlAtom = atom();
+const internalPageVisitCategoryAtom = atom();
+const internalVariantAtom = atom("pdp");
+const variantIdAtom = atom((get) => get(internalVariantIdAtom));
+const productIdAtom = atom((get) => get(internalProductIdAtom));
+const parentProductIdAtom = atom((get) => get(internalParentProductIdAtom));
+const productUrlAtom = atom((get) => get(internalProductUrlAtom));
+const plpIdAtom = atom((get) => get(internalPlpIdAtom));
+const urlAtom = atom((get) => get(internalUrlAtom));
+const pageVisitCategoryAtom = atom((get) => get(internalPageVisitCategoryAtom));
+const variantAtom = atom((get) => get(internalVariantAtom));
+const hasParsedVariantInfoAtom = atom(false);
+const variantInfoAtom = atom((get) => {
+	const variant = get(variantAtom);
+	if (variant === "pdp") return {
+		variantId: get(variantIdAtom),
+		variant,
+		productId: get(productIdAtom),
+		parentProductId: get(parentProductIdAtom),
+		url: get(urlAtom)
+	};
+	if (variant === "plp") return {
+		variantId: get(variantIdAtom),
+		variant,
+		plpId: get(plpIdAtom),
+		url: get(urlAtom)
+	};
+	if (variant === "page_visit") return {
+		variantId: get(variantIdAtom),
+		variant,
+		url: get(urlAtom),
+		pageVisitCategory: get(pageVisitCategoryAtom)
+	};
+	throw new Error("Invalid variantInfo details");
+}, (_, set, newVariant) => {
+	set(internalVariantAtom, newVariant.variant);
+	set(internalVariantIdAtom, newVariant.variantId);
+	if (newVariant.variant === "pdp") {
+		set(internalProductIdAtom, newVariant.productId);
+		set(internalParentProductIdAtom, newVariant.parentProductId);
+		set(internalUrlAtom, newVariant.url);
+	}
+	if (newVariant.variant === "plp") {
+		set(internalPlpIdAtom, newVariant.plpId);
+		set(internalUrlAtom, newVariant.url);
+	}
+	if (newVariant.variant === "page_visit") {
+		set(internalUrlAtom, newVariant.url);
+		set(internalPageVisitCategoryAtom, newVariant.pageVisitCategory);
+	}
+});
+
+//#endregion
+//#region src/atoms/app/index.ts
+const internalUserIdAtom = atom(void 0);
+const userIdAtom = atom((get) => {
+	const maybeUserId = get(internalUserIdAtom);
+	if (maybeUserId) return maybeUserId;
+	return get(userIdentityAtom)?.getUserIdOrDefault() ?? "";
+}, (_, set, value) => {
+	set(internalUserIdAtom, value);
+});
+const userIdentityAtom = atom(void 0);
+const appSourceAtom = atom((get) => get(contextSourceAtom) ?? ContextSourceEnum.App);
+const chatIdAtom = atomWithStorage("v1-spiffy-chat-session-id", v4(), void 0, { getOnInit: true });
+
+//#endregion
+export { appSourceAtom, chatIdAtom, hasParsedVariantInfoAtom, supportedEventAtom, userIdAtom, userIdentityAtom, variantInfoAtom };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"app-D_upYeqF.js","names":["uuid"],"sources":["../src/atoms/app/variant.ts","../src/atoms/app/index.ts"],"sourcesContent":["import { atomWithStorage } from \"jotai/utils\";\nimport { atom } from \"jotai\";\nimport {\n  SupportedEventProductCategory,\n  SupportedEventResponse,\n  PageVisitCategory,\n} from \"@spiffy-ai/commerce-api-client\";\nimport {\n  PageVisitVariantInfo,\n  PDPVariantInfo,\n  PLPVariantInfo,\n  VariantInfo,\n  FeatureGates,\n  OrgShortName,\n} from \"src/application/models\";\nimport { sessionStorageUtil } from \"src/atoms/atomStore/atomStore\";\nimport { enviveConfigAtom } from \"src/atoms/envive/enviveConfig\";\n\nexport interface SupportedEvent\n  extends Pick<\n    SupportedEventResponse,\n    \"supported\" | \"ready\" | \"category\" | \"collections\" | \"top_category\"\n  > {\n  numberOfReviews: number | undefined;\n  merchant_tags?: string[];\n}\n\ninterface PDPAttributes {\n  product_id?: string;\n}\n\ninterface PLPAttributes {\n  attributes?: {\n    id?: string;\n  };\n}\n\nexport interface UrlResolvingPDPConfig {\n  pdp_attributes: PDPAttributes;\n  number_of_reviews?: number;\n  collections?: string[];\n  merchant_tags?: string[];\n}\n\nexport interface UrlResolvingPLPConfig {\n  plp_attributes: PLPAttributes;\n  top_category?: string;\n}\n\ninterface UrlResolvingGenericConfig {\n  details?: string;\n}\n\nexport type PageVariantCheckConfig = {\n  check_type: string;\n  feature_gate?: string;\n  extractor?: {\n    type: string;\n    map?: Record<string, string[]>;\n    value?: string;\n  };\n  product_id_extractor?: string;\n  product_ids?: string[];\n  plp_id_extractor?: string;\n  plp_ids?: string[];\n  collections?: string[];\n  query_param?: string;\n  category?: string;\n  top_category?: string[];\n  review_minimum?: number;\n  merchant_tags?: string[];\n};\n\nexport type BackendWidgetMountingConfig = {\n  mounting_config_id: string;\n  widget_config_id?: string;\n  mounting_point_widgets?: Array<{\n    checks: PageVariantCheckConfig[];\n    widget_config_id: string;\n  }>;\n};\n\nexport type BackendPageVariantConfig = {\n  variant_id: string;\n  variant_type: string;\n  variant_checks: PageVariantCheckConfig[];\n  widget_mounting: BackendWidgetMountingConfig[];\n  plp_id_extractor?: string;\n  product_id_extractor?: string;\n  parent_product_id_extractor?: string;\n};\n\nexport interface UrlResolverResponse {\n  variant_type: string;\n  specific_details:\n    | UrlResolvingPDPConfig\n    | UrlResolvingPLPConfig\n    | UrlResolvingGenericConfig;\n  ready: boolean;\n  user_event?: {\n    event_id?: string;\n    attributes?: PDPAttributes | PLPAttributes;\n    category?: string;\n    created_at?: string;\n  };\n  page_variant?: BackendPageVariantConfig;\n}\n\n// Use a map for per-URL cache\nexport type UrlResolverCache = Record<string, UrlResolverResponse | undefined>;\n\nconst internalStorageUrlResolverAtom = atomWithStorage<string | undefined>(\n  \"spiffy-url-resolver\",\n  undefined,\n  sessionStorageUtil,\n  {\n    getOnInit: true,\n  }\n);\n\nexport const urlResolverAtom = atom(\n  (get): UrlResolverCache => {\n    const maybeUrlResolver = get(internalStorageUrlResolverAtom);\n    if (maybeUrlResolver == null) {\n      return {};\n    }\n    return JSON.parse(maybeUrlResolver);\n  },\n  (\n    get,\n    set,\n    value: { url: string; response: UrlResolverResponse | undefined }\n  ) => {\n    // Get current cache from storage\n    const currentCache = get(urlResolverAtom);\n    const newCache = { ...currentCache, [value.url]: value.response };\n\n    set(internalStorageUrlResolverAtom, JSON.stringify(newCache));\n  }\n);\n\nconst internalStorageSupportedEventAtom = atomWithStorage<string | undefined>(\n  \"spiffy-supported-event\",\n  undefined,\n  sessionStorageUtil,\n  {\n    getOnInit: true,\n  }\n);\nconst internalSupportedEventAtom = atom<SupportedEvent | undefined>(undefined);\n\nconst featureFlagServiceAtom = atom((get) => {\n  const config = get(enviveConfigAtom);\n  const featureOverrides = config?.featureOverrides;\n  return {\n    isFeatureGateEnabled: (gate: string) => featureOverrides?.[gate] || false,\n  };\n});\n\nexport const supportedEventAtom = atom(\n  (get): SupportedEvent | undefined => {\n    const maybeSupportedEvent = get(internalStorageSupportedEventAtom);\n    if (maybeSupportedEvent == null) {\n      return undefined;\n    }\n\n    // TODO this is an unvalidated parse. It may be better to implement a custom storage util\n    // and perform the object validation on \"get\" there.\n    return JSON.parse(maybeSupportedEvent);\n  },\n  (get, set, value: SupportedEvent | undefined) => {\n    if (value == null) {\n      set(internalStorageSupportedEventAtom, undefined);\n      set(internalSupportedEventAtom, undefined);\n      return;\n    }\n\n    const featureFlagService = get(featureFlagServiceAtom);\n    const maybeSupportedEvent = get(internalSupportedEventAtom);\n    const variantCategory = maybeSupportedEvent?.category;\n    const config = get(enviveConfigAtom);\n    const orgShortName = config?.orgShortName;\n\n    // TODO: clean up this logic & the feature gate when we've fully rolled out\n    if (\n      featureFlagService &&\n      !featureFlagService.isFeatureGateEnabled(\n        FeatureGates.IsNonShapewearEnabled\n      ) &&\n      variantCategory &&\n      variantCategory !== SupportedEventProductCategory.Shapewear &&\n      (orgShortName === OrgShortName.Spanx ||\n        orgShortName === OrgShortName.SpanxStaging)\n    ) {\n      const modifiedSupportedEvent = {\n        supported: false,\n        ready: value.ready,\n        category: value.category,\n        numberOfReviews: value.numberOfReviews,\n        collections: value.collections,\n        top_category: value.top_category,\n        merchant_tags: value.merchant_tags,\n      };\n      set(internalSupportedEventAtom, modifiedSupportedEvent);\n      set(\n        internalStorageSupportedEventAtom,\n        JSON.stringify(modifiedSupportedEvent)\n      );\n\n      return;\n    }\n\n    set(internalSupportedEventAtom, value);\n    set(internalStorageSupportedEventAtom, JSON.stringify(value));\n  }\n);\n\nconst internalVariantIdAtom = atom<string>();\nconst internalProductIdAtom = atom<string>();\nconst internalParentProductIdAtom = atom<string>();\nconst internalProductUrlAtom = atom<string>();\nconst internalPlpIdAtom = atom<string>();\nconst internalUrlAtom = atom<string>();\nconst internalPageVisitCategoryAtom = atom<PageVisitCategory>();\nconst internalVariantAtom = atom<\"pdp\" | \"plp\" | \"search\" | \"page_visit\">(\n  \"pdp\"\n);\n\nexport const variantIdAtom = atom((get) => get(internalVariantIdAtom));\nexport const productIdAtom = atom((get) => get(internalProductIdAtom));\nexport const parentProductIdAtom = atom((get) =>\n  get(internalParentProductIdAtom)\n);\nexport const productUrlAtom = atom((get) => get(internalProductUrlAtom));\nexport const plpIdAtom = atom((get) => get(internalPlpIdAtom));\nexport const urlAtom = atom((get) => get(internalUrlAtom));\nexport const pageVisitCategoryAtom = atom((get) =>\n  get(internalPageVisitCategoryAtom)\n);\nexport const variantAtom = atom((get) => get(internalVariantAtom));\nexport const hasParsedVariantInfoAtom = atom(false);\n\nexport const variantInfoAtom = atom(\n  (get): VariantInfo => {\n    const variant = get(variantAtom);\n    if (variant === \"pdp\") {\n      return {\n        variantId: get(variantIdAtom),\n        variant,\n        productId: get(productIdAtom),\n        parentProductId: get(parentProductIdAtom),\n        url: get(urlAtom),\n      } as PDPVariantInfo;\n    }\n    if (variant === \"plp\") {\n      return {\n        variantId: get(variantIdAtom),\n        variant,\n        plpId: get(plpIdAtom),\n        url: get(urlAtom),\n      } as PLPVariantInfo;\n    }\n    if (variant === \"page_visit\") {\n      return {\n        variantId: get(variantIdAtom),\n        variant,\n        url: get(urlAtom),\n        pageVisitCategory: get(pageVisitCategoryAtom),\n      } as PageVisitVariantInfo;\n    }\n    throw new Error(\"Invalid variantInfo details\");\n  },\n  (_, set, newVariant: VariantInfo) => {\n    set(internalVariantAtom, newVariant.variant);\n    set(internalVariantIdAtom, newVariant.variantId);\n    if (newVariant.variant === \"pdp\") {\n      set(internalProductIdAtom, newVariant.productId);\n      set(internalParentProductIdAtom, newVariant.parentProductId);\n      set(internalUrlAtom, newVariant.url);\n    }\n    if (newVariant.variant === \"plp\") {\n      set(internalPlpIdAtom, newVariant.plpId);\n      set(internalUrlAtom, newVariant.url);\n    }\n    if (newVariant.variant === \"page_visit\") {\n      set(internalUrlAtom, newVariant.url);\n      set(internalPageVisitCategoryAtom, newVariant.pageVisitCategory);\n    }\n  }\n);\n","import {\n  ContextEnvEnum,\n  ContextSourceEnum,\n} from \"@spiffy-ai/commerce-api-client\";\nimport { atom } from \"jotai\";\nimport { atomWithStorage } from \"jotai/utils\";\nimport { VariantInfo } from \"src/application/models\";\nimport { UserIdentityContextType } from \"src/contexts/userIdentityContext/userIdentityContext\";\nimport { variantInfoAtom } from \"src/atoms/app/variant\";\nimport { v4 as uuid } from \"uuid\";\nimport { contextSourceAtom } from \"../envive/enviveConfig\";\n\nexport interface AppDetails {\n  orgId: string;\n  orgShortName: string;\n  chatId: string;\n  userId: string;\n  source: ContextSourceEnum;\n  env: ContextEnvEnum;\n  variantInfo: VariantInfo;\n}\n\nexport { variantInfoAtom } from \"./variant\";\n\nconst internalUserIdAtom = atom<string | undefined>(undefined);\n\nexport const userIdAtom = atom(\n  (get) => {\n    const maybeUserId = get(internalUserIdAtom);\n\n    if (maybeUserId) {\n      return maybeUserId;\n    }\n\n    return get(userIdentityAtom)?.getUserIdOrDefault() ?? \"\";\n  },\n  (_, set, value: string | undefined) => {\n    set(internalUserIdAtom, value);\n  }\n);\n\nexport const userIdentityAtom = atom<UserIdentityContextType | undefined>(\n  undefined\n);\n\nexport const appSourceAtom = atom<ContextSourceEnum>(\n  (get): ContextSourceEnum => get(contextSourceAtom) ?? ContextSourceEnum.App\n);\nexport const chatIdAtom = atomWithStorage<string>(\n  \"v1-spiffy-chat-session-id\",\n  uuid(),\n  undefined,\n  {\n    getOnInit: true,\n  }\n);\n"],"mappings":"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"}

package/dist/app-KXTMPa4s.cjs

@@ -0,0 +1,178 @@
+const require_chunk = require('./chunk-CUT6urMc.cjs');
+const require_models = require('./models-ZpQcRZQK.cjs');
+const require_featureGates = require('./featureGates-DcZNrUma.cjs');
+const require_enviveConfig = require('./enviveConfig-DdBrcGSQ.cjs');
+const require_atomStore = require('./atomStore-DEZyFCNz.cjs');
+let __spiffy_ai_commerce_api_client = require("@spiffy-ai/commerce-api-client");
+__spiffy_ai_commerce_api_client = require_chunk.__toESM(__spiffy_ai_commerce_api_client);
+let jotai = require("jotai");
+jotai = require_chunk.__toESM(jotai);
+let jotai_utils = require("jotai/utils");
+jotai_utils = require_chunk.__toESM(jotai_utils);
+let uuid = require("uuid");
+uuid = require_chunk.__toESM(uuid);
+
+//#region src/atoms/app/variant.ts
+const internalStorageUrlResolverAtom = (0, jotai_utils.atomWithStorage)("spiffy-url-resolver", void 0, require_atomStore.sessionStorageUtil, { getOnInit: true });
+const urlResolverAtom = (0, jotai.atom)((get) => {
+	const maybeUrlResolver = get(internalStorageUrlResolverAtom);
+	if (maybeUrlResolver == null) return {};
+	return JSON.parse(maybeUrlResolver);
+}, (get, set, value) => {
+	const newCache = {
+		...get(urlResolverAtom),
+		[value.url]: value.response
+	};
+	set(internalStorageUrlResolverAtom, JSON.stringify(newCache));
+});
+const internalStorageSupportedEventAtom = (0, jotai_utils.atomWithStorage)("spiffy-supported-event", void 0, require_atomStore.sessionStorageUtil, { getOnInit: true });
+const internalSupportedEventAtom = (0, jotai.atom)(void 0);
+const featureFlagServiceAtom = (0, jotai.atom)((get) => {
+	const featureOverrides = get(require_enviveConfig.enviveConfigAtom)?.featureOverrides;
+	return { isFeatureGateEnabled: (gate) => featureOverrides?.[gate] || false };
+});
+const supportedEventAtom = (0, jotai.atom)((get) => {
+	const maybeSupportedEvent = get(internalStorageSupportedEventAtom);
+	if (maybeSupportedEvent == null) return;
+	return JSON.parse(maybeSupportedEvent);
+}, (get, set, value) => {
+	if (value == null) {
+		set(internalStorageSupportedEventAtom, void 0);
+		set(internalSupportedEventAtom, void 0);
+		return;
+	}
+	const featureFlagService = get(featureFlagServiceAtom);
+	const variantCategory = get(internalSupportedEventAtom)?.category;
+	const orgShortName = get(require_enviveConfig.enviveConfigAtom)?.orgShortName;
+	if (featureFlagService && !featureFlagService.isFeatureGateEnabled(require_featureGates.FeatureGates.IsNonShapewearEnabled) && variantCategory && variantCategory !== __spiffy_ai_commerce_api_client.SupportedEventProductCategory.Shapewear && (orgShortName === require_models.OrgShortName.Spanx || orgShortName === require_models.OrgShortName.SpanxStaging)) {
+		const modifiedSupportedEvent = {
+			supported: false,
+			ready: value.ready,
+			category: value.category,
+			numberOfReviews: value.numberOfReviews,
+			collections: value.collections,
+			top_category: value.top_category,
+			merchant_tags: value.merchant_tags
+		};
+		set(internalSupportedEventAtom, modifiedSupportedEvent);
+		set(internalStorageSupportedEventAtom, JSON.stringify(modifiedSupportedEvent));
+		return;
+	}
+	set(internalSupportedEventAtom, value);
+	set(internalStorageSupportedEventAtom, JSON.stringify(value));
+});
+const internalVariantIdAtom = (0, jotai.atom)();
+const internalProductIdAtom = (0, jotai.atom)();
+const internalParentProductIdAtom = (0, jotai.atom)();
+const internalProductUrlAtom = (0, jotai.atom)();
+const internalPlpIdAtom = (0, jotai.atom)();
+const internalUrlAtom = (0, jotai.atom)();
+const internalPageVisitCategoryAtom = (0, jotai.atom)();
+const internalVariantAtom = (0, jotai.atom)("pdp");
+const variantIdAtom = (0, jotai.atom)((get) => get(internalVariantIdAtom));
+const productIdAtom = (0, jotai.atom)((get) => get(internalProductIdAtom));
+const parentProductIdAtom = (0, jotai.atom)((get) => get(internalParentProductIdAtom));
+const productUrlAtom = (0, jotai.atom)((get) => get(internalProductUrlAtom));
+const plpIdAtom = (0, jotai.atom)((get) => get(internalPlpIdAtom));
+const urlAtom = (0, jotai.atom)((get) => get(internalUrlAtom));
+const pageVisitCategoryAtom = (0, jotai.atom)((get) => get(internalPageVisitCategoryAtom));
+const variantAtom = (0, jotai.atom)((get) => get(internalVariantAtom));
+const hasParsedVariantInfoAtom = (0, jotai.atom)(false);
+const variantInfoAtom = (0, jotai.atom)((get) => {
+	const variant = get(variantAtom);
+	if (variant === "pdp") return {
+		variantId: get(variantIdAtom),
+		variant,
+		productId: get(productIdAtom),
+		parentProductId: get(parentProductIdAtom),
+		url: get(urlAtom)
+	};
+	if (variant === "plp") return {
+		variantId: get(variantIdAtom),
+		variant,
+		plpId: get(plpIdAtom),
+		url: get(urlAtom)
+	};
+	if (variant === "page_visit") return {
+		variantId: get(variantIdAtom),
+		variant,
+		url: get(urlAtom),
+		pageVisitCategory: get(pageVisitCategoryAtom)
+	};
+	throw new Error("Invalid variantInfo details");
+}, (_, set, newVariant) => {
+	set(internalVariantAtom, newVariant.variant);
+	set(internalVariantIdAtom, newVariant.variantId);
+	if (newVariant.variant === "pdp") {
+		set(internalProductIdAtom, newVariant.productId);
+		set(internalParentProductIdAtom, newVariant.parentProductId);
+		set(internalUrlAtom, newVariant.url);
+	}
+	if (newVariant.variant === "plp") {
+		set(internalPlpIdAtom, newVariant.plpId);
+		set(internalUrlAtom, newVariant.url);
+	}
+	if (newVariant.variant === "page_visit") {
+		set(internalUrlAtom, newVariant.url);
+		set(internalPageVisitCategoryAtom, newVariant.pageVisitCategory);
+	}
+});
+
+//#endregion
+//#region src/atoms/app/index.ts
+const internalUserIdAtom = (0, jotai.atom)(void 0);
+const userIdAtom = (0, jotai.atom)((get) => {
+	const maybeUserId = get(internalUserIdAtom);
+	if (maybeUserId) return maybeUserId;
+	return get(userIdentityAtom)?.getUserIdOrDefault() ?? "";
+}, (_, set, value) => {
+	set(internalUserIdAtom, value);
+});
+const userIdentityAtom = (0, jotai.atom)(void 0);
+const appSourceAtom = (0, jotai.atom)((get) => get(require_enviveConfig.contextSourceAtom) ?? __spiffy_ai_commerce_api_client.ContextSourceEnum.App);
+const chatIdAtom = (0, jotai_utils.atomWithStorage)("v1-spiffy-chat-session-id", (0, uuid.v4)(), void 0, { getOnInit: true });
+
+//#endregion
+Object.defineProperty(exports, 'appSourceAtom', {
+  enumerable: true,
+  get: function () {
+    return appSourceAtom;
+  }
+});
+Object.defineProperty(exports, 'chatIdAtom', {
+  enumerable: true,
+  get: function () {
+    return chatIdAtom;
+  }
+});
+Object.defineProperty(exports, 'hasParsedVariantInfoAtom', {
+  enumerable: true,
+  get: function () {
+    return hasParsedVariantInfoAtom;
+  }
+});
+Object.defineProperty(exports, 'supportedEventAtom', {
+  enumerable: true,
+  get: function () {
+    return supportedEventAtom;
+  }
+});
+Object.defineProperty(exports, 'userIdAtom', {
+  enumerable: true,
+  get: function () {
+    return userIdAtom;
+  }
+});
+Object.defineProperty(exports, 'userIdentityAtom', {
+  enumerable: true,
+  get: function () {
+    return userIdentityAtom;
+  }
+});
+Object.defineProperty(exports, 'variantInfoAtom', {
+  enumerable: true,
+  get: function () {
+    return variantInfoAtom;
+  }
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"app-KXTMPa4s.cjs","names":["sessionStorageUtil","enviveConfigAtom","FeatureGates","SupportedEventProductCategory","OrgShortName","contextSourceAtom","ContextSourceEnum"],"sources":["../src/atoms/app/variant.ts","../src/atoms/app/index.ts"],"sourcesContent":["import { atomWithStorage } from \"jotai/utils\";\nimport { atom } from \"jotai\";\nimport {\n  SupportedEventProductCategory,\n  SupportedEventResponse,\n  PageVisitCategory,\n} from \"@spiffy-ai/commerce-api-client\";\nimport {\n  PageVisitVariantInfo,\n  PDPVariantInfo,\n  PLPVariantInfo,\n  VariantInfo,\n  FeatureGates,\n  OrgShortName,\n} from \"src/application/models\";\nimport { sessionStorageUtil } from \"src/atoms/atomStore/atomStore\";\nimport { enviveConfigAtom } from \"src/atoms/envive/enviveConfig\";\n\nexport interface SupportedEvent\n  extends Pick<\n    SupportedEventResponse,\n    \"supported\" | \"ready\" | \"category\" | \"collections\" | \"top_category\"\n  > {\n  numberOfReviews: number | undefined;\n  merchant_tags?: string[];\n}\n\ninterface PDPAttributes {\n  product_id?: string;\n}\n\ninterface PLPAttributes {\n  attributes?: {\n    id?: string;\n  };\n}\n\nexport interface UrlResolvingPDPConfig {\n  pdp_attributes: PDPAttributes;\n  number_of_reviews?: number;\n  collections?: string[];\n  merchant_tags?: string[];\n}\n\nexport interface UrlResolvingPLPConfig {\n  plp_attributes: PLPAttributes;\n  top_category?: string;\n}\n\ninterface UrlResolvingGenericConfig {\n  details?: string;\n}\n\nexport type PageVariantCheckConfig = {\n  check_type: string;\n  feature_gate?: string;\n  extractor?: {\n    type: string;\n    map?: Record<string, string[]>;\n    value?: string;\n  };\n  product_id_extractor?: string;\n  product_ids?: string[];\n  plp_id_extractor?: string;\n  plp_ids?: string[];\n  collections?: string[];\n  query_param?: string;\n  category?: string;\n  top_category?: string[];\n  review_minimum?: number;\n  merchant_tags?: string[];\n};\n\nexport type BackendWidgetMountingConfig = {\n  mounting_config_id: string;\n  widget_config_id?: string;\n  mounting_point_widgets?: Array<{\n    checks: PageVariantCheckConfig[];\n    widget_config_id: string;\n  }>;\n};\n\nexport type BackendPageVariantConfig = {\n  variant_id: string;\n  variant_type: string;\n  variant_checks: PageVariantCheckConfig[];\n  widget_mounting: BackendWidgetMountingConfig[];\n  plp_id_extractor?: string;\n  product_id_extractor?: string;\n  parent_product_id_extractor?: string;\n};\n\nexport interface UrlResolverResponse {\n  variant_type: string;\n  specific_details:\n    | UrlResolvingPDPConfig\n    | UrlResolvingPLPConfig\n    | UrlResolvingGenericConfig;\n  ready: boolean;\n  user_event?: {\n    event_id?: string;\n    attributes?: PDPAttributes | PLPAttributes;\n    category?: string;\n    created_at?: string;\n  };\n  page_variant?: BackendPageVariantConfig;\n}\n\n// Use a map for per-URL cache\nexport type UrlResolverCache = Record<string, UrlResolverResponse | undefined>;\n\nconst internalStorageUrlResolverAtom = atomWithStorage<string | undefined>(\n  \"spiffy-url-resolver\",\n  undefined,\n  sessionStorageUtil,\n  {\n    getOnInit: true,\n  }\n);\n\nexport const urlResolverAtom = atom(\n  (get): UrlResolverCache => {\n    const maybeUrlResolver = get(internalStorageUrlResolverAtom);\n    if (maybeUrlResolver == null) {\n      return {};\n    }\n    return JSON.parse(maybeUrlResolver);\n  },\n  (\n    get,\n    set,\n    value: { url: string; response: UrlResolverResponse | undefined }\n  ) => {\n    // Get current cache from storage\n    const currentCache = get(urlResolverAtom);\n    const newCache = { ...currentCache, [value.url]: value.response };\n\n    set(internalStorageUrlResolverAtom, JSON.stringify(newCache));\n  }\n);\n\nconst internalStorageSupportedEventAtom = atomWithStorage<string | undefined>(\n  \"spiffy-supported-event\",\n  undefined,\n  sessionStorageUtil,\n  {\n    getOnInit: true,\n  }\n);\nconst internalSupportedEventAtom = atom<SupportedEvent | undefined>(undefined);\n\nconst featureFlagServiceAtom = atom((get) => {\n  const config = get(enviveConfigAtom);\n  const featureOverrides = config?.featureOverrides;\n  return {\n    isFeatureGateEnabled: (gate: string) => featureOverrides?.[gate] || false,\n  };\n});\n\nexport const supportedEventAtom = atom(\n  (get): SupportedEvent | undefined => {\n    const maybeSupportedEvent = get(internalStorageSupportedEventAtom);\n    if (maybeSupportedEvent == null) {\n      return undefined;\n    }\n\n    // TODO this is an unvalidated parse. It may be better to implement a custom storage util\n    // and perform the object validation on \"get\" there.\n    return JSON.parse(maybeSupportedEvent);\n  },\n  (get, set, value: SupportedEvent | undefined) => {\n    if (value == null) {\n      set(internalStorageSupportedEventAtom, undefined);\n      set(internalSupportedEventAtom, undefined);\n      return;\n    }\n\n    const featureFlagService = get(featureFlagServiceAtom);\n    const maybeSupportedEvent = get(internalSupportedEventAtom);\n    const variantCategory = maybeSupportedEvent?.category;\n    const config = get(enviveConfigAtom);\n    const orgShortName = config?.orgShortName;\n\n    // TODO: clean up this logic & the feature gate when we've fully rolled out\n    if (\n      featureFlagService &&\n      !featureFlagService.isFeatureGateEnabled(\n        FeatureGates.IsNonShapewearEnabled\n      ) &&\n      variantCategory &&\n      variantCategory !== SupportedEventProductCategory.Shapewear &&\n      (orgShortName === OrgShortName.Spanx ||\n        orgShortName === OrgShortName.SpanxStaging)\n    ) {\n      const modifiedSupportedEvent = {\n        supported: false,\n        ready: value.ready,\n        category: value.category,\n        numberOfReviews: value.numberOfReviews,\n        collections: value.collections,\n        top_category: value.top_category,\n        merchant_tags: value.merchant_tags,\n      };\n      set(internalSupportedEventAtom, modifiedSupportedEvent);\n      set(\n        internalStorageSupportedEventAtom,\n        JSON.stringify(modifiedSupportedEvent)\n      );\n\n      return;\n    }\n\n    set(internalSupportedEventAtom, value);\n    set(internalStorageSupportedEventAtom, JSON.stringify(value));\n  }\n);\n\nconst internalVariantIdAtom = atom<string>();\nconst internalProductIdAtom = atom<string>();\nconst internalParentProductIdAtom = atom<string>();\nconst internalProductUrlAtom = atom<string>();\nconst internalPlpIdAtom = atom<string>();\nconst internalUrlAtom = atom<string>();\nconst internalPageVisitCategoryAtom = atom<PageVisitCategory>();\nconst internalVariantAtom = atom<\"pdp\" | \"plp\" | \"search\" | \"page_visit\">(\n  \"pdp\"\n);\n\nexport const variantIdAtom = atom((get) => get(internalVariantIdAtom));\nexport const productIdAtom = atom((get) => get(internalProductIdAtom));\nexport const parentProductIdAtom = atom((get) =>\n  get(internalParentProductIdAtom)\n);\nexport const productUrlAtom = atom((get) => get(internalProductUrlAtom));\nexport const plpIdAtom = atom((get) => get(internalPlpIdAtom));\nexport const urlAtom = atom((get) => get(internalUrlAtom));\nexport const pageVisitCategoryAtom = atom((get) =>\n  get(internalPageVisitCategoryAtom)\n);\nexport const variantAtom = atom((get) => get(internalVariantAtom));\nexport const hasParsedVariantInfoAtom = atom(false);\n\nexport const variantInfoAtom = atom(\n  (get): VariantInfo => {\n    const variant = get(variantAtom);\n    if (variant === \"pdp\") {\n      return {\n        variantId: get(variantIdAtom),\n        variant,\n        productId: get(productIdAtom),\n        parentProductId: get(parentProductIdAtom),\n        url: get(urlAtom),\n      } as PDPVariantInfo;\n    }\n    if (variant === \"plp\") {\n      return {\n        variantId: get(variantIdAtom),\n        variant,\n        plpId: get(plpIdAtom),\n        url: get(urlAtom),\n      } as PLPVariantInfo;\n    }\n    if (variant === \"page_visit\") {\n      return {\n        variantId: get(variantIdAtom),\n        variant,\n        url: get(urlAtom),\n        pageVisitCategory: get(pageVisitCategoryAtom),\n      } as PageVisitVariantInfo;\n    }\n    throw new Error(\"Invalid variantInfo details\");\n  },\n  (_, set, newVariant: VariantInfo) => {\n    set(internalVariantAtom, newVariant.variant);\n    set(internalVariantIdAtom, newVariant.variantId);\n    if (newVariant.variant === \"pdp\") {\n      set(internalProductIdAtom, newVariant.productId);\n      set(internalParentProductIdAtom, newVariant.parentProductId);\n      set(internalUrlAtom, newVariant.url);\n    }\n    if (newVariant.variant === \"plp\") {\n      set(internalPlpIdAtom, newVariant.plpId);\n      set(internalUrlAtom, newVariant.url);\n    }\n    if (newVariant.variant === \"page_visit\") {\n      set(internalUrlAtom, newVariant.url);\n      set(internalPageVisitCategoryAtom, newVariant.pageVisitCategory);\n    }\n  }\n);\n","import {\n  ContextEnvEnum,\n  ContextSourceEnum,\n} from \"@spiffy-ai/commerce-api-client\";\nimport { atom } from \"jotai\";\nimport { atomWithStorage } from \"jotai/utils\";\nimport { VariantInfo } from \"src/application/models\";\nimport { UserIdentityContextType } from \"src/contexts/userIdentityContext/userIdentityContext\";\nimport { variantInfoAtom } from \"src/atoms/app/variant\";\nimport { v4 as uuid } from \"uuid\";\nimport { contextSourceAtom } from \"../envive/enviveConfig\";\n\nexport interface AppDetails {\n  orgId: string;\n  orgShortName: string;\n  chatId: string;\n  userId: string;\n  source: ContextSourceEnum;\n  env: ContextEnvEnum;\n  variantInfo: VariantInfo;\n}\n\nexport { variantInfoAtom } from \"./variant\";\n\nconst internalUserIdAtom = atom<string | undefined>(undefined);\n\nexport const userIdAtom = atom(\n  (get) => {\n    const maybeUserId = get(internalUserIdAtom);\n\n    if (maybeUserId) {\n      return maybeUserId;\n    }\n\n    return get(userIdentityAtom)?.getUserIdOrDefault() ?? \"\";\n  },\n  (_, set, value: string | undefined) => {\n    set(internalUserIdAtom, value);\n  }\n);\n\nexport const userIdentityAtom = atom<UserIdentityContextType | undefined>(\n  undefined\n);\n\nexport const appSourceAtom = atom<ContextSourceEnum>(\n  (get): ContextSourceEnum => get(contextSourceAtom) ?? ContextSourceEnum.App\n);\nexport const chatIdAtom = atomWithStorage<string>(\n  \"v1-spiffy-chat-session-id\",\n  uuid(),\n  undefined,\n  {\n    getOnInit: true,\n  }\n);\n"],"mappings":"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"}

package/dist/application/models/graphql/index.cjs

@@ -1,13 +1,5 @@
-require('../../../logger-Dln20ans.cjs');
-require('../../../api-B2euFL-5.cjs');
-const require_contexts = require('../../../contexts-CtgmnYNn.cjs');
-require('../../../types-CGC6Oozp.cjs');
-require('../../../atomStore-JwGb7pcy.cjs');
-require('../../../customerService-BG1uNZZ1.cjs');
-require('../../../globalSearch-BTeZxvk1.cjs');
-require('../../../utilityTypes-C4h2wgAK.cjs');
-require('../../../variantInfo-CNRTY0gH.cjs');
-require('../../../events-Da7gpmGv.cjs');
+require('../../../urlsParser-BV5yF8sa.cjs');
+const require_graphql = require('../../../graphql-B9HhDXYt.cjs');
 
-exports.getMerchantColorsQuery = require_contexts.getMerchantColorsQuery;
-exports.getMerchantFrontendConfigQuery = require_contexts.getMerchantFrontendConfigQuery;
+exports.getMerchantColorsQuery = require_graphql.getMerchantColorsQuery;
+exports.getMerchantFrontendConfigQuery = require_graphql.getMerchantFrontendConfigQuery;

package/dist/application/models/graphql/index.d.cts

@@ -1,2 +1,2 @@
-import { GetMerchantColorsQueryData, GetMerchantFrontendConfigQueryData, MountingConfigQueryData, PageVariantCheckQueryData, PageVariantQueryData, UIConfigQueryData, WidgetConfigQueryData, WidgetMountingQueryData, getMerchantColorsQuery, getMerchantFrontendConfigQuery } from "../../../index-BTK5uzs6.cjs";
+import { GetMerchantColorsQueryData, GetMerchantFrontendConfigQueryData, MountingConfigQueryData, PageVariantCheckQueryData, PageVariantQueryData, UIConfigQueryData, WidgetConfigQueryData, WidgetMountingQueryData, getMerchantColorsQuery, getMerchantFrontendConfigQuery } from "../../../index-Bmub8e38.cjs";
 export { GetMerchantColorsQueryData, GetMerchantFrontendConfigQueryData, MountingConfigQueryData, PageVariantCheckQueryData, PageVariantQueryData, UIConfigQueryData, WidgetConfigQueryData, WidgetMountingQueryData, getMerchantColorsQuery, getMerchantFrontendConfigQuery };

package/dist/application/models/graphql/index.d.ts

@@ -1,2 +1,2 @@
-import { GetMerchantColorsQueryData, GetMerchantFrontendConfigQueryData, MountingConfigQueryData, PageVariantCheckQueryData, PageVariantQueryData, UIConfigQueryData, WidgetConfigQueryData, WidgetMountingQueryData, getMerchantColorsQuery, getMerchantFrontendConfigQuery } from "../../../index-D2VaMPA3.js";
+import { GetMerchantColorsQueryData, GetMerchantFrontendConfigQueryData, MountingConfigQueryData, PageVariantCheckQueryData, PageVariantQueryData, UIConfigQueryData, WidgetConfigQueryData, WidgetMountingQueryData, getMerchantColorsQuery, getMerchantFrontendConfigQuery } from "../../../index-BS7-_CW4.js";
 export { GetMerchantColorsQueryData, GetMerchantFrontendConfigQueryData, MountingConfigQueryData, PageVariantCheckQueryData, PageVariantQueryData, UIConfigQueryData, WidgetConfigQueryData, WidgetMountingQueryData, getMerchantColorsQuery, getMerchantFrontendConfigQuery };

package/dist/application/models/graphql/index.js

@@ -1,12 +1,4 @@
-import "../../../logger-pdEEY8T2.js";
-import "../../../api-XRr_lAG6.js";
-import { getMerchantColorsQuery, getMerchantFrontendConfigQuery } from "../../../contexts-CtRlNXaS.js";
-import "../../../types-CnTCkyvK.js";
-import "../../../atomStore-B1cgmbP0.js";
-import "../../../customerService-BHQRnLhC.js";
-import "../../../globalSearch-b0wC7ZEO.js";
-import "../../../utilityTypes-BVikejDo.js";
-import "../../../variantInfo-CzhR5W6h.js";
-import "../../../events-ClCDFK7t.js";
+import "../../../urlsParser-DUgV_Qy9.js";
+import { getMerchantColorsQuery, getMerchantFrontendConfigQuery } from "../../../graphql-W7GMIHUu.js";
 
 export { getMerchantColorsQuery, getMerchantFrontendConfigQuery };

package/dist/application/models/guards/api/index.cjs

@@ -1,5 +1,5 @@
-require('../../../../logger-Dln20ans.cjs');
-const require_api = require('../../../../api-B2euFL-5.cjs');
+require('../../../../logger-CSL2jqI9.cjs');
+const require_api = require('../../../../api-DSFlctlc.cjs');
 
 exports.isApiPDPAttributes = require_api.isApiPDPAttributes;
 exports.isApiProductResponseAttributes = require_api.isApiProductResponseAttributes;

package/dist/application/models/guards/api/index.d.cts

@@ -1,3 +1,3 @@
-import { isApiPDPAttributes, isApiProductResponseAttributes, isApiProductSearchResponseAttributes, isApiQueryTypedAttributes, isApiResponse, isApiReviewResponseAttributes, isApiReviewRichInformation, isApiSearchAttributes, isApiSuggestionClickedAttributes, isApiTextResponseAttributes, isApiUserEvent, isSuggestion } from "../../../../index-ClJ0nMsR.cjs";
-import "../../../../index-BzgkfbNO.cjs";
+import { isApiPDPAttributes, isApiProductResponseAttributes, isApiProductSearchResponseAttributes, isApiQueryTypedAttributes, isApiResponse, isApiReviewResponseAttributes, isApiReviewRichInformation, isApiSearchAttributes, isApiSuggestionClickedAttributes, isApiTextResponseAttributes, isApiUserEvent, isSuggestion } from "../../../../index-CiWEYzXl.cjs";
+import "../../../../index-CESxqFso.cjs";
 export { isApiPDPAttributes, isApiProductResponseAttributes, isApiProductSearchResponseAttributes, isApiQueryTypedAttributes, isApiResponse, isApiReviewResponseAttributes, isApiReviewRichInformation, isApiSearchAttributes, isApiSuggestionClickedAttributes, isApiTextResponseAttributes, isApiUserEvent, isSuggestion };

package/dist/application/models/guards/api/index.d.ts

@@ -1,3 +1,3 @@
-import { isApiPDPAttributes, isApiProductResponseAttributes, isApiProductSearchResponseAttributes, isApiQueryTypedAttributes, isApiResponse, isApiReviewResponseAttributes, isApiReviewRichInformation, isApiSearchAttributes, isApiSuggestionClickedAttributes, isApiTextResponseAttributes, isApiUserEvent, isSuggestion } from "../../../../index-Cx9e-fRi.js";
-import "../../../../index-Dxpscrvz.js";
+import { isApiPDPAttributes, isApiProductResponseAttributes, isApiProductSearchResponseAttributes, isApiQueryTypedAttributes, isApiResponse, isApiReviewResponseAttributes, isApiReviewRichInformation, isApiSearchAttributes, isApiSuggestionClickedAttributes, isApiTextResponseAttributes, isApiUserEvent, isSuggestion } from "../../../../index-DuyZQOE1.js";
+import "../../../../index-D9VegTU-.js";
 export { isApiPDPAttributes, isApiProductResponseAttributes, isApiProductSearchResponseAttributes, isApiQueryTypedAttributes, isApiResponse, isApiReviewResponseAttributes, isApiReviewRichInformation, isApiSearchAttributes, isApiSuggestionClickedAttributes, isApiTextResponseAttributes, isApiUserEvent, isSuggestion };

package/dist/application/models/guards/api/index.js

@@ -1,4 +1,4 @@
-import "../../../../logger-pdEEY8T2.js";
-import { isApiPDPAttributes, isApiProductResponseAttributes, isApiProductSearchResponseAttributes, isApiQueryTypedAttributes, isApiResponse, isApiReviewResponseAttributes, isApiReviewRichInformation, isApiSearchAttributes, isApiSuggestionClickedAttributes, isApiTextResponseAttributes, isApiUserEvent, isSuggestion } from "../../../../api-XRr_lAG6.js";
+import "../../../../logger-D5MFf3nW.js";
+import { isApiPDPAttributes, isApiProductResponseAttributes, isApiProductSearchResponseAttributes, isApiQueryTypedAttributes, isApiResponse, isApiReviewResponseAttributes, isApiReviewRichInformation, isApiSearchAttributes, isApiSuggestionClickedAttributes, isApiTextResponseAttributes, isApiUserEvent, isSuggestion } from "../../../../api-JTNjuOfc.js";
 
 export { isApiPDPAttributes, isApiProductResponseAttributes, isApiProductSearchResponseAttributes, isApiQueryTypedAttributes, isApiResponse, isApiReviewResponseAttributes, isApiReviewRichInformation, isApiSearchAttributes, isApiSuggestionClickedAttributes, isApiTextResponseAttributes, isApiUserEvent, isSuggestion };

package/dist/application/models/index.cjs

@@ -1,43 +1,39 @@
-require('../../logger-Dln20ans.cjs');
-const require_api = require('../../api-B2euFL-5.cjs');
-const require_contexts = require('../../contexts-CtgmnYNn.cjs');
-const require_types = require('../../types-CGC6Oozp.cjs');
-require('../../atomStore-JwGb7pcy.cjs');
-require('../../customerService-BG1uNZZ1.cjs');
-require('../../globalSearch-BTeZxvk1.cjs');
-require('../../utilityTypes-C4h2wgAK.cjs');
-require('../../variantInfo-CNRTY0gH.cjs');
-require('../../events-Da7gpmGv.cjs');
+const require_types = require('../../types-BwNrLPSZ.cjs');
+require('../../logger-CSL2jqI9.cjs');
+const require_models = require('../../models-ZpQcRZQK.cjs');
+const require_featureGates = require('../../featureGates-DcZNrUma.cjs');
+require('../../urlsParser-BV5yF8sa.cjs');
+const require_graphql = require('../../graphql-B9HhDXYt.cjs');
+const require_api = require('../../api-DSFlctlc.cjs');
+require('../../utilityTypes-YGiMSyV7.cjs');
+require('../../variantInfo-DRFLcGc7.cjs');
 
-exports.ChatElementDisplayLocation = require_contexts.ChatElementDisplayLocation;
+exports.ChatElementDisplayLocation = require_models.ChatElementDisplayLocation;
 exports.ColorNames = require_types.ColorNames;
-exports.DomMutationObserverContinuation = require_contexts.DomMutationObserverContinuation;
-exports.DomObservationStrategy = require_contexts.DomObservationStrategy;
-exports.FeatureGates = require_contexts.FeatureGates;
-exports.GoogleAnalyticsEvents = require_contexts.GoogleAnalyticsEvents;
-exports.MessageRole = require_contexts.MessageRole;
-exports.MessageType = require_contexts.MessageType;
-exports.OrgShortName = require_types.OrgShortName;
-exports.ProductExperiment = require_contexts.ProductExperiment;
-exports.SpiffyEventName = require_contexts.SpiffyEventName;
-exports.SpiffyWidgets = require_contexts.SpiffyWidgets;
+exports.FeatureGates = require_featureGates.FeatureGates;
+exports.GoogleAnalyticsEvents = require_models.GoogleAnalyticsEvents;
+exports.MessageRole = require_models.MessageRole;
+exports.MessageType = require_models.MessageType;
+exports.OrgShortName = require_models.OrgShortName;
+exports.ProductExperiment = require_models.ProductExperiment;
+exports.SpiffyEventName = require_models.SpiffyEventName;
+exports.SpiffyWidgets = require_models.SpiffyWidgets;
 exports.colorVar = require_types.colorVar;
-exports.getMerchantColorsQuery = require_contexts.getMerchantColorsQuery;
-exports.getMerchantFrontendConfigQuery = require_contexts.getMerchantFrontendConfigQuery;
-exports.getMerchantOrgIdQuery = require_contexts.getMerchantOrgIdQuery;
-exports.getOrgInfo = require_types.getOrgInfo;
+exports.getMerchantColorsQuery = require_graphql.getMerchantColorsQuery;
+exports.getMerchantFrontendConfigQuery = require_graphql.getMerchantFrontendConfigQuery;
+exports.getMerchantOrgIdQuery = require_models.getMerchantOrgIdQuery;
 exports.hasPropertyOfType = require_api.hasPropertyOfType;
-exports.isApiFormResponseAttributes = require_contexts.isApiFormResponseAttributes;
-exports.isApiFormSubmittedResponseAttributes = require_contexts.isApiFormSubmittedResponseAttributes;
-exports.isApiOrderResponseAttributes = require_contexts.isApiOrderResponseAttributes;
-exports.isApiOrgConfigResults = require_contexts.isApiOrgConfigResults;
-exports.isApiOrganizationConfig = require_contexts.isApiOrganizationConfig;
+exports.isApiFormResponseAttributes = require_models.isApiFormResponseAttributes;
+exports.isApiFormSubmittedResponseAttributes = require_models.isApiFormSubmittedResponseAttributes;
+exports.isApiOrderResponseAttributes = require_models.isApiOrderResponseAttributes;
+exports.isApiOrgConfigResults = require_models.isApiOrgConfigResults;
+exports.isApiOrganizationConfig = require_models.isApiOrganizationConfig;
 exports.isApiPDPAttributes = require_api.isApiPDPAttributes;
-exports.isApiPLPEventAttributes = require_contexts.isApiPLPEventAttributes;
-exports.isApiPLPIdAttribute = require_contexts.isApiPLPIdAttribute;
-exports.isApiPageResponseAttributes = require_contexts.isApiPageResponseAttributes;
+exports.isApiPLPEventAttributes = require_models.isApiPLPEventAttributes;
+exports.isApiPLPIdAttribute = require_models.isApiPLPIdAttribute;
+exports.isApiPageResponseAttributes = require_models.isApiPageResponseAttributes;
 exports.isApiProductResponseAttributes = require_api.isApiProductResponseAttributes;
-exports.isApiProductSearchFilterResponseAttributes = require_contexts.isApiProductSearchFilterResponseAttributes;
+exports.isApiProductSearchFilterResponseAttributes = require_models.isApiProductSearchFilterResponseAttributes;
 exports.isApiProductSearchResponseAttributes = require_api.isApiProductSearchResponseAttributes;
 exports.isApiQueryTypedAttributes = require_api.isApiQueryTypedAttributes;
 exports.isApiResponse = require_api.isApiResponse;
@@ -47,26 +43,26 @@ exports.isApiSearchAttributes = require_api.isApiSearchAttributes;
 exports.isApiSuggestionClickedAttributes = require_api.isApiSuggestionClickedAttributes;
 exports.isApiTextResponseAttributes = require_api.isApiTextResponseAttributes;
 exports.isApiUserEvent = require_api.isApiUserEvent;
-exports.isBaseEcommerceEvent = require_contexts.isBaseEcommerceEvent;
-exports.isGA4EcommerceEvent = require_contexts.isGA4EcommerceEvent;
-exports.isGraphQLColorsConfig = require_contexts.isGraphQLColorsConfig;
-exports.isLegacyUAEcommerceEvent = require_contexts.isLegacyUAEcommerceEvent;
-exports.isMobilePLPChatPlacementParameter = require_contexts.isMobilePLPChatPlacementParameter;
-exports.isSpanxTakeAQuizCtaParameter = require_contexts.isSpanxTakeAQuizCtaParameter;
+exports.isBaseEcommerceEvent = require_models.isBaseEcommerceEvent;
+exports.isGA4EcommerceEvent = require_models.isGA4EcommerceEvent;
+exports.isGraphQLColorsConfig = require_models.isGraphQLColorsConfig;
+exports.isLegacyUAEcommerceEvent = require_models.isLegacyUAEcommerceEvent;
+exports.isMobilePLPChatPlacementParameter = require_models.isMobilePLPChatPlacementParameter;
+exports.isSpanxTakeAQuizCtaParameter = require_models.isSpanxTakeAQuizCtaParameter;
 exports.isSuggestion = require_api.isSuggestion;
-exports.isVariantInfo = require_contexts.isVariantInfo;
-exports.stringToFulfillmentDisplayStatusEnumValue = require_contexts.stringToFulfillmentDisplayStatusEnumValue;
-exports.transformCamelToSnake = require_contexts.transformCamelToSnake;
-exports.transformSnakeToCamel = require_contexts.transformSnakeToCamel;
-exports.validateAndTransformMountingConfig = require_contexts.validateAndTransformMountingConfig;
-exports.validateAndTransformPageVariants = require_contexts.validateAndTransformPageVariants;
-exports.validateAndTransformWidgetConfig = require_contexts.validateAndTransformWidgetConfig;
-exports.validateGraphQLColorsConfig = require_contexts.validateGraphQLColorsConfig;
-exports.validateGraphQLFrontendConfig = require_contexts.validateGraphQLFrontendConfig;
-exports.validateGraphQLOrgId = require_contexts.validateGraphQLOrgId;
-exports.validateMobilePLPChatPlacementParameter = require_contexts.validateMobilePLPChatPlacementParameter;
-exports.validateOrgConfigResults = require_contexts.validateOrgConfigResults;
-exports.validateOrganizationConfig = require_contexts.validateOrganizationConfig;
-exports.validateResponse = require_contexts.validateResponse;
-exports.validateSuggestion = require_contexts.validateSuggestion;
-exports.validateUserEvent = require_contexts.validateUserEvent;
+exports.isVariantInfo = require_models.isVariantInfo;
+exports.stringToFulfillmentDisplayStatusEnumValue = require_models.stringToFulfillmentDisplayStatusEnumValue;
+exports.transformCamelToSnake = require_models.transformCamelToSnake;
+exports.transformSnakeToCamel = require_models.transformSnakeToCamel;
+exports.validateAndTransformMountingConfig = require_models.validateAndTransformMountingConfig;
+exports.validateAndTransformPageVariants = require_models.validateAndTransformPageVariants;
+exports.validateAndTransformWidgetConfig = require_models.validateAndTransformWidgetConfig;
+exports.validateGraphQLColorsConfig = require_models.validateGraphQLColorsConfig;
+exports.validateGraphQLFrontendConfig = require_models.validateGraphQLFrontendConfig;
+exports.validateGraphQLOrgId = require_models.validateGraphQLOrgId;
+exports.validateMobilePLPChatPlacementParameter = require_models.validateMobilePLPChatPlacementParameter;
+exports.validateOrgConfigResults = require_models.validateOrgConfigResults;
+exports.validateOrganizationConfig = require_models.validateOrganizationConfig;
+exports.validateResponse = require_models.validateResponse;
+exports.validateSuggestion = require_models.validateSuggestion;
+exports.validateUserEvent = require_models.validateUserEvent;