@adv-re/segment-wrapper 4.36.0-beta.0

package/dist/index.js

@@ -0,0 +1,1145 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  CONSENT_STATES: () => CONSENT_STATES,
+  EVENTS: () => EVENTS,
+  TCFEvents: () => TCFEvents,
+  UserGDPR: () => UserGDPR,
+  checkAnonymousId: () => checkAnonymousId,
+  clearConfig: () => clearConfig,
+  createUniversalId: () => createUniversalId,
+  default: () => index_default,
+  getAdobeMCVisitorID: () => getAdobeMCVisitorID,
+  getAdobeVisitorData: () => getAdobeVisitorData,
+  getConfig: () => getConfig,
+  getStorageItem: () => getStorageItem,
+  getUniversalId: () => getUniversalId,
+  hashEmail: () => hashEmail,
+  initConfig: () => initConfig,
+  isClient: () => isClient,
+  normalizeEmail: () => normalizeEmail,
+  readCookie: () => readCookie2,
+  removeCookie: () => removeCookie,
+  removeStorageItem: () => removeStorageItem,
+  saveCookie: () => saveCookie,
+  setConfig: () => setConfig,
+  setStorageItem: () => setStorageItem,
+  storage: () => storage,
+  toCookieDomain: () => toCookieDomain
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/config.ts
+var MPI_CONFIG_KEY = "__mpi";
+var isClient = typeof window !== "undefined";
+var getWindowWithMPI = () => {
+  return isClient ? window : void 0;
+};
+function getConfig(key) {
+  const win = getWindowWithMPI();
+  const config = win?.[MPI_CONFIG_KEY]?.segmentWrapper || {};
+  return key ? config[key] : config;
+}
+var setConfig = (key, value) => {
+  const win = getWindowWithMPI();
+  if (!win) {
+    console.warn("[segment-wrapper] Cannot set config in non-browser environment");
+    return;
+  }
+  win[MPI_CONFIG_KEY] = win[MPI_CONFIG_KEY] || {};
+  win[MPI_CONFIG_KEY].segmentWrapper = win[MPI_CONFIG_KEY].segmentWrapper || {};
+  win[MPI_CONFIG_KEY].segmentWrapper[key] = value;
+};
+var initConfig = (config) => {
+  const win = getWindowWithMPI();
+  if (!win) {
+    console.warn("[segment-wrapper] Cannot initialize config in non-browser environment");
+    return;
+  }
+  win[MPI_CONFIG_KEY] = win[MPI_CONFIG_KEY] || {};
+  win[MPI_CONFIG_KEY].segmentWrapper = {
+    ...win[MPI_CONFIG_KEY].segmentWrapper,
+    ...config
+  };
+};
+var clearConfig = () => {
+  const win = getWindowWithMPI();
+  if (!win || !win[MPI_CONFIG_KEY]) return;
+  win[MPI_CONFIG_KEY].segmentWrapper = {};
+};
+
+// src/repositories/adobeRepository.ts
+var mcvid;
+var getGlobalConfig = () => {
+  return {
+    ADOBE_ORG_ID: window.__SEGMENT_WRAPPER?.ADOBE_ORG_ID,
+    DEFAULT_DEMDEX_VERSION: window.__SEGMENT_WRAPPER?.DEFAULT_DEMDEX_VERSION ?? "3.3.0",
+    TIME_BETWEEN_RETRIES: window.__SEGMENT_WRAPPER?.TIME_BETWEEN_RETRIES ?? 15,
+    TIMES_TO_RETRY: window.__SEGMENT_WRAPPER?.TIMES_TO_RETRY ?? 80,
+    SERVERS: {
+      trackingServer: window.__SEGMENT_WRAPPER?.TRACKING_SERVER,
+      trackingServerSecure: window.__SEGMENT_WRAPPER?.TRACKING_SERVER
+    }
+  };
+};
+var getDemdex = () => {
+  const config = getGlobalConfig();
+  if (window.Visitor && config.ADOBE_ORG_ID) {
+    return window.Visitor.getInstance(config.ADOBE_ORG_ID, config.SERVERS);
+  }
+  return void 0;
+};
+var getMarketingCloudVisitorID = (demdex) => {
+  const mcvid2 = demdex?.getMarketingCloudVisitorID();
+  return mcvid2;
+};
+var getAdobeVisitorData = () => {
+  const demdex = getDemdex();
+  const config = getGlobalConfig();
+  const version = demdex?.version ?? config.DEFAULT_DEMDEX_VERSION;
+  const { trackingServer } = config.SERVERS;
+  return Promise.resolve({ trackingServer, version });
+};
+var getAdobeMarketingCloudVisitorIdFromWindow = () => {
+  if (mcvid) return Promise.resolve(mcvid);
+  const config = getGlobalConfig();
+  return new Promise((resolve) => {
+    function retry(retries) {
+      if (retries === 0) return resolve("");
+      const demdex = getDemdex();
+      mcvid = getMarketingCloudVisitorID(demdex);
+      if (mcvid) {
+        resolve(mcvid);
+      } else {
+        window.setTimeout(() => retry(--retries), config.TIME_BETWEEN_RETRIES);
+      }
+    }
+    retry(config.TIMES_TO_RETRY);
+  });
+};
+var importVisitorApiAndGetAdobeMCVisitorID = async () => {
+  return getAdobeMarketingCloudVisitorIdFromWindow();
+};
+var getAdobeMCVisitorID = async () => {
+  const getCustomAdobeVisitorId = getConfig("getCustomAdobeVisitorId");
+  if (typeof getCustomAdobeVisitorId === "function") {
+    return getCustomAdobeVisitorId();
+  }
+  return getConfig("importAdobeVisitorId") === true ? importVisitorApiAndGetAdobeMCVisitorID() : getAdobeMarketingCloudVisitorIdFromWindow();
+};
+
+// src/events.ts
+var EVENTS = {
+  GA4_INIT_EVENT_SENT: "ga4InitEventSent"
+};
+
+// src/middlewares/source/pageReferrer.ts
+var referrerState = {
+  spaReferrer: "",
+  referrer: ""
+};
+var utils = {
+  /**
+   * @returns The referrer of the document
+   */
+  getDocumentReferrer: () => document.referrer,
+  /**
+   * @returns The actual location with protocol, domain and pathname
+   */
+  getActualLocation: () => {
+    const { origin, pathname } = window.location;
+    return `${origin}${pathname}`;
+  },
+  /**
+   * @returns The actual query string
+   */
+  getActualQueryString: () => {
+    const { search } = window.location;
+    return search;
+  }
+};
+var getPageReferrer = ({ isPageTrack = false } = {}) => {
+  const { referrer, spaReferrer } = referrerState;
+  const referrerToUse = isPageTrack ? referrer : spaReferrer;
+  return referrerToUse || utils.getDocumentReferrer();
+};
+var updatePageReferrer = () => {
+  referrerState.spaReferrer = getPageReferrer({ isPageTrack: true });
+  referrerState.referrer = utils.getActualLocation();
+};
+var pageReferrer = ({ payload, next }) => {
+  const {
+    obj: { context }
+  } = payload;
+  const { isPageTrack } = context;
+  const referrer = getPageReferrer({ isPageTrack });
+  payload.obj.context = {
+    ...context,
+    page: {
+      ...context.page,
+      referrer
+    }
+  };
+  if (isPageTrack) {
+    updatePageReferrer();
+  }
+  next(payload);
+};
+
+// src/repositories/googleRepository.ts
+var FIELDS = {
+  clientId: "client_id",
+  sessionId: "session_id"
+};
+var DEFAULT_DATA_LAYER_NAME = "dataLayer";
+var CONSENT_STATES = {
+  granted: "granted",
+  denied: "denied"
+};
+var CONSENT_STATE_GRANTED_VALUE = 1;
+var CONSENT_STATE_DENIED_VALUE = 2;
+var STC = {
+  QUERY: "stc",
+  SPLIT_SYMBOL: "-",
+  CAMPAIGN_SPLIT_SYMBOL: ":"
+};
+var UTM_CAMPAIGN = "utm_campaign";
+var UTM_MEDIUM = "utm_medium";
+var UTM_SOURCE = "utm_source";
+var UTM_CONTENT = "utm_content";
+var UTM_CAMPAIGN_ID = "utm_id";
+var UTM_TERM = "utm_term";
+var STC_MEDIUM_TRANSFORMATIONS = {
+  aff: "affiliate",
+  dis: "display",
+  em: "email",
+  met: "paid-metasearch",
+  sem: "paid-search",
+  rt: "display",
+  sm: "social-media",
+  sp: "paid-social",
+  pn: "push-notification",
+  cs: "cross-sites"
+};
+var STC_INVALID_CONTENT = "na";
+var DEFAULT_GA_INIT_EVENT = "sui";
+var EMPTY_STC = { medium: null, source: null, campaign: null };
+var loadScript = async (src) => new Promise(function(resolve, reject) {
+  const script = document.createElement("script");
+  script.src = src;
+  script.onload = () => resolve();
+  script.onerror = reject;
+  document.head.appendChild(script);
+});
+var loadGoogleAnalytics = async () => {
+  const googleAnalyticsMeasurementId = getConfig("googleAnalyticsMeasurementId");
+  const dataLayerName = getConfig("googleAnalyticsDataLayer") || DEFAULT_DATA_LAYER_NAME;
+  if (!googleAnalyticsMeasurementId) return Promise.resolve(false);
+  const gtagScript = `https://www.googletagmanager.com/gtag/js?id=${googleAnalyticsMeasurementId}&l=${dataLayerName}`;
+  return loadScript(gtagScript).then(() => true);
+};
+var triggerGoogleAnalyticsInitEvent = (sessionId) => {
+  const eventName = getConfig("googleAnalyticsInitEvent") ?? DEFAULT_GA_INIT_EVENT;
+  const eventPrefix = `ga_event_${eventName}_`;
+  const eventKey = `${eventPrefix}${sessionId}`;
+  if (typeof window.gtag === "undefined") return;
+  if (!localStorage.getItem(eventKey)) {
+    window.gtag("event", eventName);
+    console.log(`Sending GA4 event "${eventName}" for the session "${sessionId}"`);
+    localStorage.setItem(eventKey, "true");
+    if (typeof window.dispatchEvent === "function") {
+      const event = new CustomEvent(EVENTS.GA4_INIT_EVENT_SENT, {
+        detail: { eventName, sessionId }
+      });
+      window.dispatchEvent(event);
+    }
+  }
+  Object.keys(localStorage).forEach((key) => {
+    if (key.startsWith(eventPrefix) && key !== eventKey) {
+      localStorage.removeItem(key);
+    }
+  });
+};
+var getGoogleField = async (field) => {
+  const googleAnalyticsMeasurementId = getConfig("googleAnalyticsMeasurementId");
+  if (!googleAnalyticsMeasurementId) return Promise.resolve(void 0);
+  return new Promise((resolve) => {
+    window.gtag?.("get", googleAnalyticsMeasurementId, field, resolve);
+  });
+};
+var trackingTagsTypes = {
+  STC: "stc",
+  UTM: "utm"
+};
+var getCampaignDetails = ({ needsTransformation = true } = {}) => {
+  const { medium, source, campaign, content, term } = readQueryParams();
+  if (!medium || !source || !campaign) return null;
+  const [id, name] = campaign.split(STC.CAMPAIGN_SPLIT_SYMBOL);
+  if (!id && !name) return null;
+  const needsContent = typeof content !== "undefined" && content !== STC_INVALID_CONTENT;
+  return {
+    campaign: {
+      medium: needsTransformation && STC_MEDIUM_TRANSFORMATIONS[medium] || medium,
+      ...typeof name !== "undefined" && { id },
+      name: name ?? id,
+      source,
+      ...needsContent && { content },
+      ...typeof term !== "undefined" && { term }
+    }
+  };
+};
+function readQueryParams() {
+  const search = utils.getActualQueryString();
+  const searchParams = new URLSearchParams(search);
+  return getConfig("trackingTagsType") === trackingTagsTypes.UTM ? readFromUtm(searchParams) : readFromStc(searchParams);
+}
+function readFromStc(searchParams) {
+  if (!hasStc(searchParams)) return EMPTY_STC;
+  const stc = searchParams.get(STC.QUERY);
+  const [medium, source, campaign, content, term] = stc?.split(STC.SPLIT_SYMBOL) || [];
+  return { medium, source, campaign, content, term };
+}
+function hasStc(searchParams) {
+  return searchParams.has(STC.QUERY);
+}
+function readFromUtm(searchParams) {
+  const campaignId = searchParams.get(UTM_CAMPAIGN_ID);
+  const campaignName = searchParams.get(UTM_CAMPAIGN);
+  const medium = searchParams.get(UTM_MEDIUM);
+  const source = searchParams.get(UTM_SOURCE);
+  const content = searchParams.get(UTM_CONTENT);
+  const term = searchParams.get(UTM_TERM);
+  const campaign = campaignId ? `${campaignId}${STC.CAMPAIGN_SPLIT_SYMBOL}${campaignName}` : campaignName;
+  const missingAnyMandatoryFields = !medium || !source || !campaign;
+  if (missingAnyMandatoryFields && hasStc(searchParams)) {
+    return readFromStc(searchParams);
+  }
+  return {
+    campaign,
+    medium,
+    source,
+    content: content ?? void 0,
+    term: term ?? void 0
+  };
+}
+var getGoogleClientId = async () => getGoogleField(FIELDS.clientId);
+var getGoogleSessionId = async () => {
+  const sessionId = await getGoogleField(FIELDS.sessionId);
+  if (sessionId) {
+    triggerGoogleAnalyticsInitEvent(sessionId);
+  }
+  return sessionId;
+};
+function getGoogleConsentValue(consentType = "analytics_storage") {
+  try {
+    const value = window.google_tag_data?.ics?.getConsentState?.(consentType);
+    if (value === CONSENT_STATE_GRANTED_VALUE) return CONSENT_STATES.granted;
+    if (value === CONSENT_STATE_DENIED_VALUE) return CONSENT_STATES.denied;
+    return void 0;
+  } catch {
+    return void 0;
+  }
+}
+var getConsentState = () => getGoogleConsentValue() ?? CONSENT_STATES.denied;
+var setGoogleUserId = (userId) => {
+  const googleAnalyticsMeasurementId = getConfig("googleAnalyticsMeasurementId");
+  if (!googleAnalyticsMeasurementId || !userId) return;
+  window.gtag?.("set", "user_id", userId);
+};
+var sendGoogleConsents = (mode = "default", consents) => {
+  window.gtag?.(
+    "consent",
+    mode,
+    consents || {
+      analytics_storage: CONSENT_STATES.denied,
+      ad_user_data: CONSENT_STATES.denied,
+      ad_personalization: CONSENT_STATES.denied,
+      ad_storage: CONSENT_STATES.denied
+    }
+  );
+};
+
+// src/tcf.ts
+var TCF_COOKIE_KEY = "borosTcf";
+var TCF_API_VERSION = 2;
+var TCF_TRACK_PROPERTIES = {
+  channel: "GDPR"
+};
+var NEEDED_PURPOSES = {
+  analytics: [1, 8, 10],
+  advertising: [3]
+};
+var TCF_EVENTS = {
+  /** Event that determines that the tcData has been loaded */
+  LOADED: "tcloaded",
+  /** Event that determines that the user has performed an action */
+  USER_ACTION_COMPLETE: "useractioncomplete"
+};
+var CMP_TRACK_EVENT = "CMP Submitted";
+var USER_GDPR = {
+  ACCEPTED: "accepted",
+  DECLINED: "declined",
+  UNKNOWN: "unknown"
+};
+var gdprState = {
+  listeners: [],
+  value: void 0,
+  addListener: (callback) => gdprState.listeners.push(callback),
+  get: () => gdprState.value,
+  set: (value) => {
+    const { analytics, advertising } = value || {};
+    gdprState.value = {
+      analytics,
+      advertising
+    };
+    gdprState.listeners.forEach((fn) => fn(value));
+    gdprState.listeners = [];
+  }
+};
+function readCookie(key) {
+  if (!isClient) return null;
+  const re = new RegExp(key + "=([^;]+)");
+  const value = re.exec(document.cookie);
+  return value !== null ? unescape(value[1]) : null;
+}
+var checkTcfIsAvailable = () => {
+  if (getConfig("initialized")) return false;
+  const isTcfApiAvailable = !!window.__tcfapi;
+  if (!isTcfApiAvailable) {
+    console.warn("[tcfTracking] window.__tcfapi is not available on client and TCF won't be tracked.");
+  }
+  return isTcfApiAvailable;
+};
+var checkHasUserConsentedAnalytics = (userConsents) => NEEDED_PURPOSES.analytics.every((purposeId) => userConsents[`${purposeId}`]);
+var checkHasUserConsentedAdvertising = (userConsents) => NEEDED_PURPOSES.advertising.every((purposeId) => userConsents[`${purposeId}`]);
+var trackTcf = ({ gdprPrivacy }) => segmentWrapper_default.track(
+  CMP_TRACK_EVENT,
+  {
+    ...TCF_TRACK_PROPERTIES,
+    ...getConfig("tcfTrackDefaultProperties") || {}
+  },
+  {
+    gdpr_privacy: gdprPrivacy.analytics,
+    gdpr_privacy_advertising: gdprPrivacy.advertising
+  }
+);
+var getGdprPrivacyValue = () => {
+  const gdprPrivacyValue = gdprState.get();
+  if (gdprPrivacyValue !== void 0) return Promise.resolve(gdprPrivacyValue);
+  return new Promise((resolve) => {
+    gdprState.addListener((gdprPrivacyValue2) => resolve(gdprPrivacyValue2));
+  });
+};
+var checkAnalyticsGdprIsAccepted = (gdprPrivacyValue) => {
+  return gdprPrivacyValue?.analytics === USER_GDPR.ACCEPTED;
+};
+var setGdprStateBy = (purposeConsents) => {
+  const hasAnalyticsConsents = checkHasUserConsentedAnalytics(purposeConsents);
+  const hasAdvertisingConsents = checkHasUserConsentedAdvertising(purposeConsents);
+  const gdprAnalyticsStateKey = hasAnalyticsConsents ? USER_GDPR.ACCEPTED : USER_GDPR.DECLINED;
+  const gdprAdvertisingStateKey = hasAdvertisingConsents ? USER_GDPR.ACCEPTED : USER_GDPR.DECLINED;
+  gdprState.set({
+    analytics: gdprAnalyticsStateKey,
+    advertising: gdprAdvertisingStateKey
+  });
+  return {
+    analytics: gdprAnalyticsStateKey,
+    advertising: gdprAdvertisingStateKey
+  };
+};
+var getConsentsFromCookie = () => {
+  const cookieValue = readCookie(TCF_COOKIE_KEY);
+  if (!cookieValue) return;
+  try {
+    const { purpose } = JSON.parse(window.atob(cookieValue));
+    const { consents } = purpose;
+    return consents;
+  } catch (e) {
+    console.error(e);
+    return void 0;
+  }
+};
+var initializeGdprState = () => {
+  const consents = getConsentsFromCookie();
+  if (consents) setGdprStateBy(consents);
+};
+var initializeIsFirstVisit = () => {
+  const consents = getConsentsFromCookie();
+  setConfig("isFirstVisit", !consents);
+};
+function initTcfTracking() {
+  if (!isClient) return;
+  initializeGdprState();
+  initializeIsFirstVisit();
+  if (!checkTcfIsAvailable()) {
+    const analyticsGdprState = gdprState.get()?.analytics;
+    if (analyticsGdprState === void 0)
+      gdprState.set({
+        analytics: USER_GDPR.UNKNOWN,
+        advertising: USER_GDPR.UNKNOWN
+      });
+    return;
+  }
+  setConfig("initialized", true);
+  window.__tcfapi?.("addEventListener", TCF_API_VERSION, ({ eventStatus, purpose }, success) => {
+    if (!success) return Promise.resolve();
+    if (eventStatus === TCF_EVENTS.USER_ACTION_COMPLETE || eventStatus === TCF_EVENTS.LOADED) {
+      const { consents } = purpose;
+      const gdprStateKey = setGdprStateBy(consents);
+      if (eventStatus === TCF_EVENTS.USER_ACTION_COMPLETE) {
+        const { analytics: analyticsStateKey, advertising: advertisingStateKey } = gdprStateKey;
+        const gdprPrivacy = {
+          analytics: analyticsStateKey,
+          advertising: advertisingStateKey
+        };
+        const MIGRATION_DIDOMI_SEGMENT_WRAPPER_FLAG = "didomi-migration";
+        const isDidomiMigration = isClient && window.sessionStorage.getItem(MIGRATION_DIDOMI_SEGMENT_WRAPPER_FLAG);
+        return !isDidomiMigration && trackTcf({
+          gdprPrivacy
+        });
+      }
+    }
+  });
+}
+
+// src/utils/cookies.ts
+var ONE_YEAR = 31536e3;
+var DEFAULT_PATH = "/";
+var DEFAULT_SAME_SITE = "Lax";
+function readCookie2(cookieName) {
+  if (typeof document === "undefined") return null;
+  const re = new RegExp(`${cookieName}=([^;]+)`);
+  const value = re.exec(document.cookie);
+  return value !== null ? unescape(value[1]) : null;
+}
+function saveCookie(cookieName, data, options = {}) {
+  if (typeof document === "undefined" || typeof window === "undefined") return;
+  const { maxAge = ONE_YEAR, path = DEFAULT_PATH, reduceDomain = true, sameSite = DEFAULT_SAME_SITE } = options;
+  const domain = reduceDomain ? toCookieDomain() : window.location.hostname;
+  const cookieValue = [
+    `${cookieName}=${data}`,
+    `domain=${domain}`,
+    `path=${path}`,
+    `max-age=${maxAge}`,
+    `SameSite=${sameSite}`
+  ].join(";");
+  document.cookie = cookieValue;
+}
+function removeCookie(cookieName, options = {}) {
+  if (typeof document === "undefined" || typeof window === "undefined") return;
+  const { path = DEFAULT_PATH, reduceDomain = true } = options;
+  const domain = reduceDomain ? toCookieDomain() : window.location.hostname;
+  document.cookie = `${cookieName}=; expires=Thu, 01 Jan 1970 00:00:00 UTC; path=${path}; domain=${domain}`;
+}
+var toCookieDomain = (domain) => {
+  const hostname = domain !== void 0 ? domain : typeof window !== "undefined" ? window.location.hostname : "";
+  const DOT = ".";
+  const hostDomainParts = hostname.split(DOT).reverse();
+  if (hostDomainParts.length === 1) {
+    return hostDomainParts[0];
+  }
+  const cookieDomainParts = [];
+  for (const part of hostDomainParts) {
+    cookieDomainParts.push(part);
+    if (part.length > 3) break;
+  }
+  return `${DOT}${cookieDomainParts.reverse().join(DOT)}`;
+};
+
+// src/repositories/xandrRepository.ts
+var XANDR_ID_SERVER_URL = "https://secure.adnxs.com/getuidj?consent=1";
+var XANDR_ID_COOKIE = "adit-xandr-id";
+var USER_OPTED_OUT_XANDR_ID_VALUE = 0;
+function getRemoteXandrId() {
+  if (!isClient) return Promise.resolve(null);
+  return window.fetch(XANDR_ID_SERVER_URL, {
+    credentials: "include"
+  }).then((response) => response.json()).then((json) => json?.uid).catch(() => null);
+}
+function getXandrId({ gdprPrivacyValueAdvertising }) {
+  if (!isClient) return null;
+  if (gdprPrivacyValueAdvertising !== USER_GDPR.ACCEPTED) {
+    removeCookie(XANDR_ID_COOKIE);
+    return null;
+  }
+  const checkValid = (xandrId) => xandrId !== null && Number(xandrId) > USER_OPTED_OUT_XANDR_ID_VALUE;
+  const storedXandrId = readCookie2(XANDR_ID_COOKIE);
+  const isValidXandrId = checkValid(storedXandrId);
+  if (!isValidXandrId) {
+    getRemoteXandrId().then((xandrId) => {
+      if (typeof xandrId === "string") {
+        saveCookie(XANDR_ID_COOKIE, xandrId);
+      }
+    });
+  }
+  setConfig("xandrId", storedXandrId);
+  return isValidXandrId ? storedXandrId : null;
+}
+
+// src/segmentWrapper.ts
+var DEFAULT_PROPERTIES = { platform: "web" };
+var INTEGRATIONS_WHEN_NO_CONSENTS = {
+  All: false
+};
+var INTEGRATIONS_WHEN_NO_CONSENTS_CMP_SUBMITTED = {
+  All: true
+};
+var getUserId = (userId) => {
+  const prefix = getConfig("userIdPrefix");
+  if (!prefix) {
+    return userId;
+  }
+  if (typeof userId === "number" || typeof userId === "string" && !userId.startsWith(prefix)) {
+    return `${prefix}${userId}`;
+  }
+  return userId;
+};
+var getDefaultProperties = () => ({
+  ...DEFAULT_PROPERTIES,
+  ...getConfig("defaultProperties")
+});
+var getTrackIntegrations = async ({
+  gdprPrivacyValue,
+  event
+}) => {
+  const isGdprAccepted = checkAnalyticsGdprIsAccepted(gdprPrivacyValue);
+  let marketingCloudVisitorId;
+  let sessionId;
+  let clientId;
+  try {
+    if (isGdprAccepted) {
+      marketingCloudVisitorId = await getAdobeMCVisitorID();
+    }
+    sessionId = await getGoogleSessionId();
+    clientId = await getGoogleClientId();
+  } catch (error) {
+    console.error(error);
+  }
+  const restOfIntegrations = getRestOfIntegrations({ isGdprAccepted, event });
+  return {
+    ...restOfIntegrations,
+    "Adobe Analytics": marketingCloudVisitorId ? { marketingCloudVisitorId } : true,
+    "Google Analytics 4": clientId && sessionId ? {
+      clientId,
+      sessionId
+    } : true
+  };
+};
+var getRestOfIntegrations = ({
+  isGdprAccepted,
+  event
+}) => {
+  const isCMPSubmittedEvent = event === "CMP Submitted";
+  if (isCMPSubmittedEvent) {
+    return INTEGRATIONS_WHEN_NO_CONSENTS_CMP_SUBMITTED;
+  }
+  return isGdprAccepted ? {} : INTEGRATIONS_WHEN_NO_CONSENTS;
+};
+var getExternalIds = ({
+  context,
+  xandrId
+}) => {
+  const shouldSendXandrId = getConfig("sendXandrId") !== false;
+  const isValidXandrId = xandrId && parseInt(xandrId) !== 0;
+  if (!shouldSendXandrId || !isValidXandrId) {
+    return {};
+  }
+  const SEGMENT_COLLECTION = "users";
+  const SEGMENT_ENCODING = "none";
+  const SEGMENT_TYPE = "xandr_id";
+  const externalIds = [
+    ...Array.isArray(context?.externalIds) ? context.externalIds : [],
+    {
+      collection: SEGMENT_COLLECTION,
+      encoding: SEGMENT_ENCODING,
+      id: xandrId,
+      type: SEGMENT_TYPE
+    }
+  ];
+  const uniqueExternalIds = externalIds.filter(
+    ({ id: idFilter, type: typeFilter }, index) => index === externalIds.findIndex(({ id: idFind, type: typeFind }) => idFilter === idFind && typeFilter === typeFind)
+  );
+  return { externalIds: uniqueExternalIds };
+};
+var getConsentValue = (gdprValue) => {
+  return gdprValue === USER_GDPR.ACCEPTED ? CONSENT_STATES.granted : CONSENT_STATES.denied;
+};
+var decorateContextWithNeededData = async ({
+  event = "",
+  context = {}
+}) => {
+  const gdprPrivacyValue = await getGdprPrivacyValue();
+  const { analytics: gdprPrivacyValueAnalytics, advertising: gdprPrivacyValueAdvertising } = gdprPrivacyValue || {};
+  const isGdprAccepted = checkAnalyticsGdprIsAccepted(gdprPrivacyValue);
+  const [integrations, xandrId] = await Promise.all([
+    getTrackIntegrations({ gdprPrivacyValue, event }),
+    getXandrId({ gdprPrivacyValueAdvertising })
+  ]);
+  const analyticsConsentValue = getGoogleConsentValue("analytics_storage") ?? getConsentValue(gdprPrivacyValueAnalytics);
+  const adUserDataConsentValue = getGoogleConsentValue("ad_user_data") ?? getConsentValue(gdprPrivacyValueAdvertising);
+  const adPersonalizationConsentValue = getGoogleConsentValue("ad_personalization") ?? getConsentValue(gdprPrivacyValueAdvertising);
+  const adStorageConsentValue = getGoogleConsentValue("ad_storage") ?? getConsentValue(gdprPrivacyValueAdvertising);
+  if (!isGdprAccepted) {
+    context.integrations = {
+      ...context.integrations ?? {},
+      Personas: false,
+      Webhooks: true,
+      Webhook: true
+    };
+  }
+  const google_consents = {
+    analytics_storage: analyticsConsentValue,
+    ad_user_data: adUserDataConsentValue,
+    ad_personalization: adPersonalizationConsentValue,
+    ad_storage: adStorageConsentValue
+  };
+  return {
+    ...context,
+    ...!isGdprAccepted && { ip: "0.0.0.0" },
+    ...getExternalIds({ context, xandrId }),
+    analytics_storage: getConsentState(),
+    clientVersion: `segment-wrapper@${"4.36.0-beta.0"}`,
+    gdpr_privacy: gdprPrivacyValueAnalytics,
+    gdpr_privacy_advertising: gdprPrivacyValueAdvertising,
+    google_consents,
+    integrations: {
+      ...context.integrations,
+      ...integrations
+    }
+  };
+};
+var track = (event, properties, context = {}, callback) => new Promise((resolve) => {
+  const initTrack = async () => {
+    const newContext = await decorateContextWithNeededData({
+      context,
+      event
+    });
+    const newProperties = {
+      ...getDefaultProperties(),
+      ...properties
+    };
+    const newCallback = async (...args) => {
+      if (callback) callback(...args);
+      const [gdprPrivacyValue] = await Promise.all([getGdprPrivacyValue()]);
+      if (checkAnalyticsGdprIsAccepted(gdprPrivacyValue)) {
+        resolve();
+      } else {
+        resolve();
+      }
+    };
+    const needsConsentManagement = getConfig("googleAnalyticsConsentManagement");
+    if (needsConsentManagement && event === CMP_TRACK_EVENT) {
+      sendGoogleConsents("update", newContext.google_consents);
+    }
+    window.analytics.track(
+      event,
+      newProperties,
+      {
+        ...newContext,
+        context: {
+          integrations: {
+            ...newContext.integrations
+          }
+        }
+      },
+      newCallback
+    );
+  };
+  initTrack();
+});
+var identify = async (userIdParam, traits, options, callback) => {
+  const gdprPrivacyValue = await getGdprPrivacyValue();
+  const userId = getUserId(userIdParam);
+  setGoogleUserId(userId);
+  return window.analytics.identify(
+    userId,
+    checkAnalyticsGdprIsAccepted(gdprPrivacyValue) ? traits : {},
+    options,
+    callback
+  );
+};
+var page = (event, properties, context = {}, callback) => {
+  ;
+  context.isPageTrack = true;
+  return track(event ?? "", properties, context, callback);
+};
+var reset = () => Promise.resolve(window.analytics.reset());
+var segmentWrapper_default = { page, identify, track, reset };
+
+// src/utils/patchAnalytics.ts
+var MPI_PATCH_FIELD = "__mpi_patch";
+function monkeyPatchAnalyticsTrack() {
+  const { track: originalTrack } = window.analytics;
+  window.analytics.track = (...args) => {
+    const [event, properties, contextFromArgs, fn] = args;
+    const newProperties = {
+      ...getDefaultProperties(),
+      ...properties
+    };
+    decorateContextWithNeededData({
+      context: contextFromArgs,
+      event
+    }).then((context) => {
+      originalTrack.call(window.analytics, event, newProperties, context, fn);
+    });
+    return window.analytics;
+  };
+  window.analytics[MPI_PATCH_FIELD] = true;
+}
+if (isClient) {
+  if (!window.analytics) {
+    console.warn("[segment-wrapper] Segment Analytics is not loaded so patch is not applied.");
+  } else if (!window.analytics[MPI_PATCH_FIELD]) {
+    void (window.analytics.initialized ? monkeyPatchAnalyticsTrack() : window.analytics.ready(monkeyPatchAnalyticsTrack));
+  }
+}
+
+// src/middlewares/source/campaignContext.ts
+var campaignContext = ({ payload, next }) => {
+  const googleAnalyticsMeasurementId = getConfig("googleAnalyticsMeasurementId");
+  if (googleAnalyticsMeasurementId) {
+    const campaignDetails = getCampaignDetails();
+    payload.obj.context = {
+      ...payload.obj.context,
+      ...campaignDetails
+    };
+  }
+  next(payload);
+};
+
+// src/middlewares/source/defaultContextProperties.ts
+var DEFAULT_CONTEXT = { platform: "web" };
+var defaultContextProperties = ({ payload, next }) => {
+  const defaultContext = getConfig("defaultContext") || {};
+  payload.obj.context = {
+    ...DEFAULT_CONTEXT,
+    ...defaultContext,
+    ...payload.obj.context
+  };
+  next(payload);
+};
+
+// src/middlewares/source/pageData.ts
+var createPageDataMiddleware = () => {
+  let last = null;
+  return ({ payload, next }) => {
+    try {
+      const { obj } = payload;
+      const { event, type } = obj;
+      if (type !== "track") {
+        next(payload);
+        return;
+      }
+      if (typeof event === "string" && event.endsWith("Viewed")) {
+        const { page_name: name, page_type: type2 } = obj.properties || {};
+        last = { name, type: type2 };
+        next(payload);
+        return;
+      }
+      if (!last) {
+        next(payload);
+        return;
+      }
+      next({
+        ...payload,
+        obj: {
+          ...obj,
+          properties: {
+            ...obj.properties,
+            page_name_origin: last.name,
+            page_type: obj.properties?.page_type || last.type
+          }
+        }
+      });
+    } catch (error) {
+      console.error(error);
+      next(payload);
+    }
+  };
+};
+var pageData = createPageDataMiddleware();
+
+// src/middlewares/source/userScreenInfo.ts
+var userScreenInfo = ({ payload, next }) => {
+  payload.obj.context = {
+    ...payload.obj.context,
+    screen: {
+      height: window.innerHeight,
+      width: window.innerWidth,
+      density: window.devicePixelRatio
+    }
+  };
+  next(payload);
+};
+
+// src/middlewares/source/userTraits.ts
+var getUserTraits = (gdprPrivacyValue) => {
+  const isUserTraitsEnabled = getConfig("isUserTraitsEnabled");
+  const user = window.analytics.user?.();
+  const isGdprAccepted = checkAnalyticsGdprIsAccepted(gdprPrivacyValue);
+  const userId = user?.id();
+  return {
+    anonymousId: user?.anonymousId(),
+    ...userId && { userId },
+    ...isGdprAccepted && isUserTraitsEnabled && user?.traits() || {}
+  };
+};
+var userTraits = async ({ payload, next }) => {
+  const gdprPrivacyValue = await getGdprPrivacyValue();
+  let traits;
+  try {
+    traits = getUserTraits(gdprPrivacyValue);
+  } catch (error) {
+    console.error(error);
+  }
+  payload.obj.context = {
+    ...payload.obj.context,
+    traits: {
+      ...payload.obj.context.traits || {},
+      ...traits
+    }
+  };
+  next(payload);
+};
+
+// src/utils/hashEmail.ts
+var import_md5 = __toESM(require("tiny-hashes/md5"));
+var import_sha256 = __toESM(require("tiny-hashes/sha256"));
+var PLUS_AND_DOT = /\.|\+.*$/g;
+function normalizeEmail(email) {
+  if (typeof email !== "string") return "";
+  const lowercaseEmail = email.toLowerCase();
+  const emailParts = lowercaseEmail.split(/@/);
+  if (emailParts.length !== 2) return "";
+  const [usernameRaw, domain] = emailParts;
+  const username = usernameRaw.replace(PLUS_AND_DOT, "");
+  return `${username}@${domain}`;
+}
+function createUniversalId(email) {
+  const normalizedEmail = normalizeEmail(email);
+  return normalizedEmail ? (0, import_sha256.default)(normalizedEmail) : "";
+}
+function hashEmail(email) {
+  const normalizedEmail = normalizeEmail(email);
+  return normalizedEmail ? (0, import_md5.default)(normalizedEmail) : "";
+}
+
+// src/universalId.ts
+var USER_DATA_READY_EVENT = "USER_DATA_READY";
+var getUniversalIdFromConfig = () => getConfig("universalId");
+var getUniversalId = () => {
+  let universalId = getUniversalIdFromConfig();
+  if (universalId) {
+    setUniversalIdInitialized();
+    return universalId;
+  }
+  const userEmail = getConfig("userEmail");
+  if (userEmail) {
+    universalId = createUniversalId(userEmail);
+    setUniversalId(universalId);
+    setUniversalIdInitialized();
+    return universalId;
+  }
+  setUniversalIdInitialized();
+  return void 0;
+};
+var getUserDataAndNotify = () => {
+  if (!isClient) return void 0;
+  const universalId = getUniversalId();
+  const userEmail = getConfig("userEmail");
+  if (typeof window !== "undefined" && typeof window.dispatchEvent === "function") {
+    const event = new CustomEvent(USER_DATA_READY_EVENT, {
+      detail: { universalId, userEmail }
+    });
+    window.dispatchEvent(event);
+  }
+  return { universalId, userEmail };
+};
+var setUniversalIdInitialized = () => {
+  setConfig("universalIdInitialized", true);
+};
+var setUniversalId = (universalId) => {
+  setConfig("universalId", universalId);
+};
+
+// src/utils/checkAnonymousId.ts
+var checkAnonymousId = () => {
+  if (typeof window === "undefined") return;
+  const win = window;
+  const analytics = win.analytics;
+  if (!analytics) {
+    console.warn("[segment-wrapper] Analytics is not available");
+    return;
+  }
+  const SEGMENT_ID_USER_WITHOUT_CONSENTS = win.__SEGMENT_WRAPPER?.SEGMENT_ID_USER_WITHOUT_CONSENTS ?? "anonymous_user";
+  const anonymousId = analytics.user?.()?.anonymousId();
+  if (anonymousId === SEGMENT_ID_USER_WITHOUT_CONSENTS) {
+    if ("setAnonymousId" in analytics && typeof analytics.setAnonymousId === "function") {
+      ;
+      analytics.setAnonymousId(null);
+    }
+  }
+};
+
+// src/types/tcf.ts
+var UserGDPR = /* @__PURE__ */ ((UserGDPR2) => {
+  UserGDPR2["ACCEPTED"] = "accepted";
+  UserGDPR2["DECLINED"] = "declined";
+  UserGDPR2["UNKNOWN"] = "unknown";
+  return UserGDPR2;
+})(UserGDPR || {});
+var TCFEvents = /* @__PURE__ */ ((TCFEvents2) => {
+  TCFEvents2["LOADED"] = "tcloaded";
+  TCFEvents2["USER_ACTION_COMPLETE"] = "useractioncomplete";
+  return TCFEvents2;
+})(TCFEvents || {});
+
+// src/utils/storage.ts
+var storage = ({
+  type = "localStorage",
+  method = "getItem",
+  key,
+  value
+}) => {
+  try {
+    if (typeof window === "undefined") {
+      return null;
+    }
+    const storageObj = window[type];
+    if (!storageObj) {
+      console.warn(`[segment-wrapper] ${type} is not available`);
+      return null;
+    }
+    if (method === "getItem") {
+      return storageObj.getItem(key);
+    }
+    if (method === "setItem") {
+      if (value === void 0) {
+        console.warn("[segment-wrapper] storage.setItem requires a value");
+        return;
+      }
+      storageObj.setItem(key, value);
+      return;
+    }
+    if (method === "removeItem") {
+      storageObj.removeItem(key);
+      return;
+    }
+  } catch (e) {
+    console.error("[segment-wrapper] Storage error:", e);
+    return null;
+  }
+};
+var getStorageItem = (key, type = "localStorage") => {
+  return storage({ key, type, method: "getItem" }) || null;
+};
+var setStorageItem = (key, value, type = "localStorage") => {
+  storage({ key, value, type, method: "setItem" });
+};
+var removeStorageItem = (key, type = "localStorage") => {
+  storage({ key, type, method: "removeItem" });
+};
+
+// src/index.ts
+initTcfTracking();
+try {
+  getUserDataAndNotify();
+} catch (error) {
+  console.error("[segment-wrapper] UniversalID could not be initialized", error);
+}
+var addMiddlewares = () => {
+  const experimentalPageDataMiddleware = getConfig("experimentalPageDataMiddleware");
+  window.analytics.addSourceMiddleware?.(userTraits);
+  window.analytics.addSourceMiddleware?.(defaultContextProperties);
+  window.analytics.addSourceMiddleware?.(campaignContext);
+  window.analytics.addSourceMiddleware?.(userScreenInfo);
+  window.analytics.addSourceMiddleware?.(pageReferrer);
+  if (experimentalPageDataMiddleware) {
+    window.analytics.addSourceMiddleware?.(pageData);
+  }
+};
+if (isClient && window.analytics) {
+  const googleAnalyticsMeasurementId = getConfig("googleAnalyticsMeasurementId");
+  const dataLayerName = getConfig("googleAnalyticsDataLayer") || DEFAULT_DATA_LAYER_NAME;
+  const needsConsentManagement = getConfig("googleAnalyticsConsentManagement");
+  if (googleAnalyticsMeasurementId) {
+    const googleAnalyticsConfig = getConfig("googleAnalyticsConfig");
+    window[dataLayerName] = window[dataLayerName] || [];
+    window.gtag = window.gtag || function gtag() {
+      ;
+      window[dataLayerName].push(arguments);
+    };
+    window.gtag("js", /* @__PURE__ */ new Date());
+    if (needsConsentManagement) {
+      sendGoogleConsents();
+    }
+    window.gtag("config", googleAnalyticsMeasurementId, {
+      cookie_prefix: "segment",
+      send_page_view: false,
+      ...googleAnalyticsConfig,
+      ...getCampaignDetails()
+    });
+    loadGoogleAnalytics().catch((error) => {
+      console.error("[segment-wrapper] Failed to load Google Analytics", error);
+    });
+  }
+  window.analytics.ready(checkAnonymousId);
+  window.analytics.addSourceMiddleware ? addMiddlewares() : window.analytics.ready(addMiddlewares);
+}
+var index_default = segmentWrapper_default;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CONSENT_STATES,
+  EVENTS,
+  TCFEvents,
+  UserGDPR,
+  checkAnonymousId,
+  clearConfig,
+  createUniversalId,
+  getAdobeMCVisitorID,
+  getAdobeVisitorData,
+  getConfig,
+  getStorageItem,
+  getUniversalId,
+  hashEmail,
+  initConfig,
+  isClient,
+  normalizeEmail,
+  readCookie,
+  removeCookie,
+  removeStorageItem,
+  saveCookie,
+  setConfig,
+  setStorageItem,
+  storage,
+  toCookieDomain
+});