@epigraph/epigraph-std-lib 5.0.0-alpha.13 → 5.0.0-alpha.14

package/dist/EpigraphLibs/EpigraphAnalytics/epigraphAnalytics.js

@@ -1,2 +1,1057 @@
-import { A as e, C as t, D as n, E as r, F as i, I as a, L as o, M as s, N as c, O as l, P as u, R as d, S as f, T as p, _ as m, a as h, b as g, c as _, d as v, f as y, g as b, h as x, i as S, j as C, k as w, l as T, m as E, n as D, o as O, p as k, r as A, s as j, t as M, u as N, v as P, w as F, x as I, y as L } from "../../epigraphAnalytics-CF9Czp8C.js";
-export { D as ACTION_PERFORMED, A as BUTTON_TYPE, S as CONTENT_TYPES, h as CURRENCY, i as ConsentPluginNames, O as EpigraphAddToFavouritesEvent, M as EpigraphAnalytics, j as EpigraphArRequestedEvent, _ as EpigraphButtonClickEvent, T as EpigraphChangeRateEvent, N as EpigraphCheckoutEvent, v as EpigraphCompletionRateEvent, y as EpigraphContentSharedEvent, k as EpigraphConversionEvent, E as EpigraphCustomEvent, x as EpigraphEngagementRateEvent, b as EpigraphItemAddedEvent, m as EpigraphItemMovedEvent, P as EpigraphItemRemovedEvent, L as EpigraphKeyboardInteractionEvent, g as EpigraphModuleClosedEvent, I as EpigraphModuleFailedEvent, f as EpigraphModuleLoadingEvent, t as EpigraphModuleReadyEvent, F as EpigraphPanelClosedEvent, p as EpigraphPanelOpenedEvent, r as EpigraphSupportDetectedEvent, n as EpigraphTouchInteractionEvent, l as EpigraphVariantChangedEvent, d as GA4AnalyticsPlugin, w as MODULE_FAILED_ERRORS, o as NexusAnalyticsPlugin, a as OneTrustConsentPlugin, e as PANEL_TYPE, C as SHARE_DESTINATIONS, s as SUPPORT_TYPE, c as TRIGGER_SOURCE, u as VARIANT_CHANGE_TYPES };
+import { N as A } from "../../enums-CvOTKyNu.js";
+var o = /* @__PURE__ */ ((e) => (e.UNAVAILABLE = "unavailable", e.AVAILABLE = "available", e.RESTRICTED = "restricted", e))(o || {});
+const I = Symbol("data"), p = Symbol("next"), G = class C {
+  constructor(t) {
+    this[I] = t, this[p] = null;
+  }
+  get data() {
+    return this[I];
+  }
+  set next(t) {
+    if (!(t instanceof C) && t !== null)
+      throw new Error(
+        "This node is not an instance of the custom class 'Node'."
+      );
+    this[p] = t;
+  }
+  get next() {
+    return this[p];
+  }
+};
+let N = G;
+const g = Symbol("head");
+class M {
+  constructor() {
+    this[g] = null;
+  }
+  set head(t) {
+    this[g] = t;
+  }
+  get head() {
+    return this[g];
+  }
+  addToTail(t) {
+    let i = this.head;
+    if (i) {
+      for (; i.next !== null; )
+        i = i?.next;
+      return i.next = new N(t);
+    }
+    return this.head = new N(t);
+  }
+  removeHead() {
+    const t = this.head;
+    if (t)
+      return this.head = t.next, t.data;
+  }
+}
+const y = Symbol("queue"), l = Symbol("size");
+class v {
+  constructor() {
+    this[y] = new M(), this[l] = 0;
+  }
+  get queue() {
+    return this[y];
+  }
+  get size() {
+    return this[l];
+  }
+  enqueue(t) {
+    this.queue.addToTail(t), this[l]++;
+  }
+  dequeue() {
+    const t = this.queue.removeHead();
+    return this[l]--, t;
+  }
+}
+class u {
+  static {
+    this.NOTIFICATION_NAME = "epg-notification";
+  }
+  static {
+    this.ACTION_SEND_EVENT = "send-event";
+  }
+  static {
+    this.ACTION_INITIALIZED = "initialized";
+  }
+  static {
+    this.ACTION_FAILED_INITIALIZATION = "initialization-failed";
+  }
+  constructor(t, i, s, n, a, h) {
+    this._pluginName = t, this._trackingId = i, this._experienceId = s, this._solution = n, this._initializer = a, this._status = h;
+  }
+  updateStatus(t) {
+    this._status = t;
+  }
+  updateInitializer(t) {
+    this._initializer = t;
+  }
+  notify(t, i) {
+    const s = {
+      pluginName: this._pluginName,
+      trackingId: this._trackingId,
+      experienceId: this._experienceId,
+      solution: this._solution,
+      initializer: this._initializer,
+      status: this._status,
+      action: t,
+      eventDetails: i
+    };
+    window.dispatchEvent(new CustomEvent("epg-notification", { detail: s }));
+  }
+}
+class $ {
+  constructor({
+    trackingID: t,
+    experienceID: i,
+    solution: s,
+    verboseLogging: n = !1
+  }) {
+    this.__status = o.UNAVAILABLE, this.__sentEventCount = 0, this.__initializationAttempts = 0, this.__lastInitializationAttempt = performance.now(), this.__maxInitializationAttempts = 10, this.__initializationRetryDelay = 2e3, this.__isInitialized = !1, this.__initializationMethod = "NONE", this.__nexusFailureReported = !1, this.name = this.pluginName = "GA4-PLUGIN", this.trackingID = t, this.experienceID = i, this.solution = s, this.verboseLogging = n, this.__queue = new v(), this.__epigraphNotifier = new u(
+      this.pluginName,
+      this.pluginName,
+      this.experienceID,
+      this.solution,
+      this.__initializationMethod,
+      this.__status
+    ), this.initializePlugin();
+  }
+  setTrackingID(t) {
+    if (!t)
+      return;
+    const i = this.trackingID !== t;
+    this.trackingID = t, i && this.__isInitialized && (this.resetInitialization(), this.initializePlugin());
+  }
+  setExperienceID(t) {
+    this.experienceID = t;
+  }
+  setSolution(t) {
+    this.solution = t;
+  }
+  getStatus() {
+    return this.__status;
+  }
+  setStatus(t) {
+    this.__status = t, this.__epigraphNotifier.updateStatus(t);
+  }
+  getPendingEventCount() {
+    return this.__queue.size;
+  }
+  getSentEventCount() {
+    return this.__sentEventCount;
+  }
+  getTotalEventCount() {
+    return this.getPendingEventCount() + this.getSentEventCount();
+  }
+  /**
+   * Returns a unique plugin identifier so that tracking ID's can be the same across multiple plugins.
+   */
+  getUniquePluginIdentifier() {
+    return `${this.name}-${this.trackingID}`;
+  }
+  setupPlugin() {
+    this.__isInitialized && this.dataLayer !== void 0 && this.dequeueAndSendEvents();
+  }
+  /**
+   * This function will send an Event to Google Analytics 4.
+   *
+   * @param analyticsEvent
+   * @param consent boolean Whether consent is granted
+   */
+  async sendEvent(t, i) {
+    if (this.__queue.enqueue(t), !i) {
+      this.__status = o.RESTRICTED;
+      return;
+    }
+    if (!this.__isInitialized) {
+      this.logger("Cannot send analytics event: dataLayer not defined or plugin not initialized.");
+      return;
+    }
+    try {
+      await this.dequeueAndSendEvents();
+    } catch (s) {
+      this.logger(s), await this.reportFailureToNexus("EVENT_SEND_ERROR", s?.toString() || "Unknown error");
+    }
+  }
+  resetInitialization() {
+    this.__isInitialized = !1, this.__status = o.UNAVAILABLE, this.dataLayer = void 0, this.dataLayerName = void 0, this.__initializationMethod = "NONE", this.__initializationAttempts = 0, this.__nexusFailureReported = !1, this.__epigraphNotifier.updateStatus(this.__status);
+  }
+  initializePlugin() {
+    if (this.__isInitialized)
+      return;
+    if (this.__initializationAttempts >= this.__maxInitializationAttempts) {
+      this.__nexusFailureReported || (this.reportFailureToNexus("MAX_INITIALIZATION_ATTEMPTS", "Maximum initialization attempts reached"), this.__nexusFailureReported = !0, this.__epigraphNotifier.notify(u.ACTION_FAILED_INITIALIZATION, {}));
+      return;
+    }
+    const t = performance.now();
+    if (this.__initializationAttempts > 0 && t - this.__lastInitializationAttempt < this.__initializationRetryDelay)
+      return;
+    this.__lastInitializationAttempt = t, this.__initializationAttempts++;
+    const i = this.detectAndSetupAnalytics();
+    i.success ? (this.__isInitialized = !0, this.__status = o.AVAILABLE, this.__initializationMethod = i.method, this.dataLayerName = i.dataLayerName, this.dataLayer = window[this.dataLayerName], this.logger(`Successfully initialized ${i.method} with dataLayer: ${this.dataLayerName}`), this.__epigraphNotifier.notify(u.ACTION_INITIALIZED, {}), this.__queue.size > 0 && this.dequeueAndSendEvents()) : (this.logger(`Initialization attempt ${this.__initializationAttempts} failed: ${i.error}`), this.__initializationAttempts < this.__maxInitializationAttempts && setTimeout(() => {
+      this.initializePlugin();
+    }, this.__initializationRetryDelay));
+  }
+  detectAndSetupAnalytics() {
+    const t = this.detectGTM();
+    if (t)
+      return this.logger(`GTM detected with container ID: ${t.containerId}`), this.__epigraphNotifier.updateInitializer("GTM"), {
+        success: !0,
+        method: "GTM",
+        dataLayerName: t.dataLayerName
+      };
+    const i = this.findGA4Info(this.trackingID);
+    if (i) {
+      const s = i.l || "dataLayer";
+      return this.logger(`GA4 script found, setting up with dataLayer: ${s}`), this.__epigraphNotifier.updateInitializer("GA4"), {
+        success: !0,
+        method: "GA4",
+        dataLayerName: s
+      };
+    }
+    return {
+      success: !1,
+      method: "NONE",
+      dataLayerName: "dataLayer",
+      error: "No analytics setup found and unable to create one"
+    };
+  }
+  detectGTM() {
+    const t = document.querySelectorAll('script[src*="googletagmanager.com/gtm"]');
+    for (const i of Array.from(t)) {
+      const s = i.getAttribute("src");
+      if (s) {
+        const n = s.match(/gtm\.js\?id=([^&]+)/);
+        if (n && n.length > 0) {
+          const a = s.match(/&l=([^&]+)/), h = a ? a[1] : "dataLayer";
+          return {
+            containerId: n[1],
+            dataLayerName: h
+          };
+        }
+      }
+    }
+    return null;
+  }
+  /**
+   * Send all events that are in the queue
+   * @private
+   */
+  async dequeueAndSendEvents() {
+    if (!this.__isInitialized || !this.dataLayer)
+      return;
+    let t = this.__queue.size;
+    for (let i = 0; i < t; i++) {
+      const s = this.__queue.dequeue();
+      try {
+        this.__initializationMethod === "GTM" ? (this.sendGTMEvent(s), this.__sentEventCount++, this.logger(`Analytics event successfully sent via ${this.__initializationMethod}: ${s.eventName}`)) : this.__initializationMethod === "GA4" ? (this.sendGA4Event(s), this.__sentEventCount++, this.logger(`Analytics event successfully sent via ${this.__initializationMethod}: ${s.eventName}`)) : this.__queue.enqueue(s);
+      } catch (n) {
+        this.logger(`Error sending event ${s.eventName}: ${n}`), this.__queue.enqueue(s);
+      }
+    }
+  }
+  /**
+   * Send events to GTM based GA4
+   * @param event
+   * @private
+   */
+  async sendGTMEvent(t) {
+    let i = t.getGTMParameters(this.solution, this.experienceID, this.trackingID);
+    const s = i;
+    this.isValidPayload(i) || (i = await this.convertGTMParametersToEpgEventTag(t.eventName, i)), this.dataLayer && (this.dataLayer.push(i), this.__epigraphNotifier.notify(u.ACTION_SEND_EVENT, s));
+  }
+  /**
+   * Send events to GA4 via Google Analytics 4.
+   * @param event
+   * @private
+   */
+  async sendGA4Event(t) {
+    let i = t.getGa4Parameters(this.solution, this.experienceID, this.trackingID);
+    const s = i;
+    this.isValidPayload(i) || (i = await this.convertGA4ParametersToEpgEventTag(i)), window.gtag("event", t.eventName, i), this.__epigraphNotifier.notify(u.ACTION_SEND_EVENT, s);
+  }
+  /**
+   * Validates a payload by checking its parameter count and the constraints of parameter names and values.
+   * See docs here for requirements: https://support.google.com/analytics/answer/9267744?hl=en
+   *
+   * @param {Record<string, unknown>} parameterPayload - An object containing the parameters to validate.
+   * The keys represent parameter names and the values represent parameter values.
+   * @return {boolean} Returns true if the payload meets the validation criteria; false otherwise.
+   */
+  isValidPayload(t) {
+    if (Object.keys(t).length >= 25)
+      return !1;
+    for (const [n, a] of Object.entries(t))
+      if (n !== "items" && (n.length > 40 || String(a).length > 100))
+        return !1;
+    return !0;
+  }
+  /**
+   * Converts the given GTM parameters to an EPG event tag, sending specific parameter payloads
+   * for processing and returning the formatted result. Falls back to the original payload in case of errors.
+   *
+   * @param {string} eventName - The event name associated with the EPG event tag being processed.
+   * @param {Record<string, unknown>} parameterPayload - A key-value pair object containing the parameters to be converted.
+   * @return {Promise<Record<string, unknown>>} A promise that resolves to an object containing the event name and the generated EPG event tag, or the original payload upon failure.
+   */
+  async convertGTMParametersToEpgEventTag(t, i) {
+    try {
+      let s = await this.sendGA4LongParameters(i);
+      return {
+        event: t,
+        epg_event_tag: s,
+        send_to: this.trackingID
+      };
+    } catch {
+      return i;
+    }
+  }
+  /**
+   * Converts GA4 parameters into an EPG event tag.
+   *
+   * @param {Record<string, unknown>} parameterPayload - The GA4 parameters to be converted.
+   * @return {Promise<Record<string, any>>} A promise resolving to an object containing the EPG event tag or the original payload if the conversion fails.
+   */
+  async convertGA4ParametersToEpgEventTag(t) {
+    try {
+      return {
+        epg_event_tag: await this.sendGA4LongParameters(t),
+        send_to: this.trackingID
+      };
+    } catch {
+      return t;
+    }
+  }
+  /**
+   * Checks if verboseLogging is enabled, then logs the error
+   * @param err
+   */
+  logger(t) {
+    this.verboseLogging && console.warn(t);
+  }
+  async sendGA4LongParameters(t) {
+    const i = "https://api.myepigraph.com/api/analytics/ga4/custom", s = { parameters: t };
+    try {
+      const n = await fetch(i, {
+        method: "POST",
+        // Assuming it's a POST request, adjust if necessary
+        headers: {
+          "Content-Type": "application/json",
+          Accept: "application/json"
+        },
+        body: JSON.stringify(s)
+      });
+      return n.ok ? (await n.json())?.id ?? "" : "";
+    } catch {
+      return "";
+    }
+  }
+  async reportFailureToNexus(t, i) {
+    try {
+      const s = {
+        plugin: "GA4",
+        trackingId: this.trackingID,
+        solution: this.solution,
+        experienceId: this.experienceID,
+        failureType: t,
+        errorMessage: i,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        url: window.location.href,
+        userAgent: navigator.userAgent
+      };
+      this.logger(`Failure reported to Nexus: ${JSON.stringify(s)}`);
+    } catch (s) {
+      this.logger(`Error reporting failure to Nexus: ${s}`);
+    }
+  }
+  findGA4Info(t) {
+    if (window.google_tag_manager && window.google_tag_manager[t]) {
+      const s = window.google_tag_manager[t];
+      if (s && s.dataLayerName)
+        return {
+          fullSrc: "",
+          id: t,
+          l: s.dataLayerName
+        };
+    }
+    const i = document.querySelectorAll("script[src]");
+    for (const s of i) {
+      const n = s.getAttribute("src");
+      if (n && n.includes(t)) {
+        const a = new URL(n, location.href), h = Object.fromEntries(a.searchParams.entries());
+        return {
+          fullSrc: a.href,
+          id: h.id || void 0,
+          l: h.l || void 0
+        };
+      }
+    }
+    return null;
+  }
+}
+class V {
+  constructor({
+    trackingID: t,
+    experienceID: i,
+    solution: s,
+    sessionId: n,
+    xPath: a,
+    verboseLogging: h = !1,
+    baseUrl: _ = A.PRODUCTION
+  }) {
+    this.__status = o.UNAVAILABLE, this.__sentEventCount = 0, this.sessionId = n, this.xPath = a, this.name = this.pluginName = "NEXUS-PLUGIN", this.trackingID = t, this.experienceID = i, this.solution = s, this.verboseLogging = h, this.__queue = new v(), this.url = `${_}analytics/event`, this.__status = o.AVAILABLE, this.__epigraphNotifier = new u(
+      this.pluginName,
+      this.trackingID,
+      this.experienceID,
+      this.solution,
+      "NEXUS",
+      this.__status
+    ), this.__epigraphNotifier.notify(u.ACTION_INITIALIZED, {});
+  }
+  getStatus() {
+    return this.__status;
+  }
+  setStatus(t) {
+    this.__status = t, this.__epigraphNotifier.updateStatus(t);
+  }
+  getPendingEventCount() {
+    return this.__queue.size;
+  }
+  getSentEventCount() {
+    return this.__sentEventCount;
+  }
+  getTotalEventCount() {
+    return this.getPendingEventCount() + this.getSentEventCount();
+  }
+  getUniquePluginIdentifier() {
+    return this.name + "-" + this.trackingID;
+  }
+  setupPlugin() {
+  }
+  async sendEvent(t, i) {
+    if (this.__queue.enqueue(t), !i) {
+      this.__status = o.RESTRICTED, this.__epigraphNotifier.updateStatus(this.__status);
+      return;
+    }
+    await this.dequeueAndSendEvents();
+  }
+  async dequeueAndSendEvents() {
+    for (let t = 0; t < this.__queue.size; t++) {
+      const i = this.__queue.dequeue(), s = {
+        send_to: this.trackingID,
+        experience_id: this.experienceID,
+        solution: this.solution,
+        event: i.eventName,
+        parameters: i.getNexusParameters()
+      };
+      try {
+        return (await fetch(this.url, {
+          method: "POST",
+          // Assuming it's a POST request, adjust if necessary
+          headers: {
+            "Content-Type": "application/json",
+            Accept: "application/json",
+            "EPG-SESSION-ID": this.sessionId,
+            "EPG-XPATH": this.xPath,
+            Origin: typeof window < "u" ? window.location.origin : ""
+          },
+          body: JSON.stringify(s)
+        })).ok && this.__epigraphNotifier.notify(u.ACTION_SEND_EVENT, s), "";
+      } catch {
+        return "";
+      }
+      this.__sentEventCount++;
+    }
+    return "";
+  }
+}
+class U {
+  constructor({
+    productId: t,
+    identifier: i,
+    identifierType: s,
+    experienceType: n,
+    renderMode: a = "geo",
+    sessionId: h,
+    xPath: _,
+    solution: z = "",
+    verboseLogging: R = !1,
+    baseUrl: q = A.PRODUCTION
+  }) {
+    if (this.experienceID = "", this.__status = o.UNAVAILABLE, this.__sentEventCount = 0, t <= 0)
+      throw new Error("NexusSolutionsAnalyticsPlugin requires a valid productId greater than 0.");
+    this.sessionId = h, this.xPath = _, this.name = this.pluginName = "NEXUS-SOLUTIONS-PLUGIN", this.verboseLogging = R, this.__queue = new v(), this.productId = t, this.identifier = i, this.identifierType = s, this.experienceType = n, this.renderMode = a, this.solution = z, this.trackingID = String(t), this.url = `${q}analytics/event`, this.__status = o.AVAILABLE, this.__epigraphNotifier = new u(
+      this.pluginName,
+      this.trackingID,
+      `${i}@${s}`,
+      this.solution,
+      "NEXUS-SOLUTIONS",
+      this.__status
+    ), this.__epigraphNotifier.notify(u.ACTION_INITIALIZED, {});
+  }
+  setProductId(t) {
+    t <= 0 || (this.productId = t, this.trackingID = String(t));
+  }
+  setIdentifier(t) {
+    this.identifier = t;
+  }
+  setIdentifierType(t) {
+    this.identifierType = t;
+  }
+  setExperienceType(t) {
+    this.experienceType = t;
+  }
+  setRenderMode(t) {
+    this.renderMode = t;
+  }
+  getStatus() {
+    return this.__status;
+  }
+  setStatus(t) {
+    this.__status = t, this.__epigraphNotifier.updateStatus(t);
+  }
+  getPendingEventCount() {
+    return this.__queue.size;
+  }
+  getSentEventCount() {
+    return this.__sentEventCount;
+  }
+  getTotalEventCount() {
+    return this.getPendingEventCount() + this.getSentEventCount();
+  }
+  getUniquePluginIdentifier() {
+    return `${this.name}-${this.sessionId}`;
+  }
+  setupPlugin() {
+  }
+  async sendEvent(t, i) {
+    if (this.__queue.enqueue(t), !i) {
+      this.__status = o.RESTRICTED, this.__epigraphNotifier.updateStatus(this.__status);
+      return;
+    }
+    await this.dequeueAndSendEvents();
+  }
+  async dequeueAndSendEvents() {
+    for (; this.__queue.size > 0; ) {
+      const t = this.__queue.dequeue(), i = {
+        action: t.eventName,
+        product_id: this.productId,
+        identifier: this.identifier,
+        identifier_type: this.identifierType,
+        experience_type: this.experienceType,
+        render_mode: this.renderMode,
+        parameters: t.getNexusParameters()
+      };
+      try {
+        (await fetch(this.url, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Accept: "application/json",
+            "EPG-SESSION-ID": this.sessionId,
+            "EPG-XPATH": this.xPath,
+            Origin: typeof window < "u" ? window.location.origin : ""
+          },
+          body: JSON.stringify(i)
+        })).ok && (this.__sentEventCount++, this.__epigraphNotifier.notify(u.ACTION_SEND_EVENT, i));
+      } catch {
+        return;
+      }
+    }
+  }
+}
+class b {
+  constructor(t) {
+    this.consentSet = !1, this.consent = !1, this.pluginName = "OneTrustConsentPlugin", this.consentIdentifier = t, this.consent = !1, this.addConsentChangedListener();
+  }
+  /**
+   * Checks to see if the user has consented. If this is false, it will block all analytics
+   */
+  hasConsent() {
+    if (this.consentSet)
+      return this.consent;
+    if (window.OnetrustActiveGroups !== void 0) {
+      let t = window.OnetrustActiveGroups;
+      t !== void 0 && t.split(",").forEach((s) => {
+        s === this.consentIdentifier && (this.consent = !0, this.consentSet = !0);
+      });
+    }
+    return this.consent;
+  }
+  addConsentChangedListener() {
+    window.addEventListener("load", () => {
+      this.hasConsent(), window.OneTrust !== void 0 && typeof window.OneTrust == "object" && window.OneTrust.OnConsentChanged(() => {
+        this.consentSet = !1, this.hasConsent();
+      });
+    });
+  }
+}
+var S = /* @__PURE__ */ ((e) => (e.OneTrust = "onetrust", e))(S || {});
+class r {
+  constructor({
+    eventName: t,
+    interactiveEvent: i,
+    customParameters: s
+  }) {
+    this.eventName = t, this.interactiveEvent = i, this.customParameters = s;
+  }
+  getGa4Parameters(t, i, s) {
+    let n = {
+      solution: t,
+      experience_id: i,
+      interactive_event: this.interactiveEvent,
+      send_to: s
+    };
+    return n = Object.assign(n, JSON.parse(JSON.stringify(this.customParameters))), n;
+  }
+  getGTMParameters(t, i, s) {
+    let n = {
+      solution: t,
+      experience_id: i,
+      event: this.eventName,
+      interactive_event: this.interactiveEvent,
+      send_to: s
+    };
+    return n = Object.assign(n, JSON.parse(JSON.stringify(this.customParameters))), n;
+  }
+  getNexusParameters() {
+    let t = {
+      interactive_event: this.interactiveEvent
+    };
+    return t = Object.assign(t, JSON.parse(JSON.stringify(this.customParameters))), t;
+  }
+}
+var O = /* @__PURE__ */ ((e) => (e.VARIANT = "variant", e.CATEGORY_VARIANT = "category_variant", e.GEOMETRY = "geometry", e.CATEGORY_GEOMETRY = "category_geometry", e.GLOBAL = "global", e))(O || {}), m = /* @__PURE__ */ ((e) => (e.AR = "ar", e.QR = "qr", e.INFO = "info", e.INSTRUCTIONS = "instructions", e.DOWNLOAD = "download", e.PREVIEW_CART = "preview_cart", e.HOTSPOT_PANEL = "hotspot_panel", e.SHARE_MODAL = "share_modal", e.RESTART_MODAL = "restart_modal", e.REMOVE_MODAL = "remove_modal", e.LOAD_PRECONFIG_MODAL = "load_preconfig_modal", e.MOVE_MODAL = "move_modal", e.OUT_OF_STOCK_MODAL = "out_of_stock_modal", e))(m || {}), w = /* @__PURE__ */ ((e) => (e.NETWORK = "network", e.EXPERIENCE_CONFIG_ERROR = "experience-config-error", e.SCENE_LOAD_ERROR = "scene-load-error", e.INITIAL_SCENE_LOAD_ERROR = "initial-scene-load-error", e.AUTHENTICATION_FAILED = "authentication-failed", e))(w || {}), E = /* @__PURE__ */ ((e) => (e.AUTO = "auto", e.BUTTON = "button", e.HOTSPOT = "hotspot", e.GESTURE = "gesture", e))(E || {}), d = /* @__PURE__ */ ((e) => (e.USD = "USD", e.EUR = "EUR", e.GBP = "GBP", e.CAD = "CAD", e))(d || {}), L = /* @__PURE__ */ ((e) => (e.AR = "ar", e.QR = "qr", e.AR_WEBGL2 = "ar-webgl2", e.QR_WEBGL2 = "qr-webgl2", e))(L || {}), T = /* @__PURE__ */ ((e) => (e.AR_VIEW = "ar_view", e.DIMENSION_TOGGLE = "dimension_toggle", e.HOTSPOTS_TOGGLE = "hotspots_toggle", e.HELP_TOGGLE = "help_toggle", e.UTILITY_MENU_TOGGLE = "utility_menu_toggle", e.HOTSPOT_ENTER = "hotspot_enter", e.HOTSPOT_EXIT = "hotspot_exit", e.SHARE = "share", e.PDF_DOWNLOAD = "pdf_download", e.COPY = "copy", e.RESTART = "restart", e.INSTRUCTIONS_SHOW = "show_instructions", e.REVIEW_CART = "review_cart", e.SHOP_NOW = "shop_now", e.SUB_CATEGORY = "sub_category", e.NEXT_STEP = "next_step", e.PREVIOUS_STEP = "previous_step", e))(T || {}), f = /* @__PURE__ */ ((e) => (e.ZOOM = "zoom", e.ROTATE = "rotate", e.PAN = "pan", e))(f || {}), x = /* @__PURE__ */ ((e) => (e.CONFIGURATION = "configuration", e.SCENE = "scene", e.PRODUCT = "product", e))(x || {}), P = /* @__PURE__ */ ((e) => (e.FACEBOOK = "facebook", e.TWITTER = "twitter", e.EMAIL = "email", e.COPY_LINK = "copy_link", e.WHATSAPP = "whatsapp", e.LINKEDIN = "linkedin", e))(P || {});
+class F extends r {
+  constructor(t) {
+    super({
+      eventName: "epigraph_ar_requested",
+      interactiveEvent: !0,
+      customParameters: {
+        items: t
+      }
+    });
+  }
+}
+class j extends r {
+  constructor(t) {
+    super({
+      eventName: "epigraph_module_loading",
+      interactiveEvent: !1,
+      customParameters: {
+        is_pre_config: t
+      }
+    });
+  }
+}
+class W extends r {
+  constructor(t, i) {
+    super({
+      eventName: "epigraph_module_ready",
+      interactiveEvent: !1,
+      customParameters: {
+        is_pre_config: t,
+        load_time_ms: i
+      }
+    });
+  }
+}
+class J extends r {
+  static {
+    this.MODULE_FAILED_ERRORS = w;
+  }
+  constructor(t, i, s) {
+    super({
+      eventName: "epigraph_module_failed",
+      interactiveEvent: !1,
+      customParameters: {
+        is_pre_config: t,
+        load_time_ms: i,
+        error_type: s
+      }
+    });
+  }
+}
+class X extends r {
+  constructor(t) {
+    super({
+      eventName: "epigraph_module_closed",
+      interactiveEvent: !0,
+      customParameters: {
+        items: t
+      }
+    });
+  }
+}
+class H extends r {
+  static {
+    this.SUPPORT_TYPE = L;
+  }
+  constructor(t) {
+    super({
+      eventName: "epigraph_support_detected",
+      interactiveEvent: !1,
+      customParameters: {
+        support_type: t
+      }
+    });
+  }
+}
+class K extends r {
+  static {
+    this.BUTTON_TYPE = T;
+  }
+  constructor(t, i) {
+    super({
+      eventName: "epigraph_button_click",
+      interactiveEvent: !0,
+      customParameters: {
+        button_type: t,
+        button_name: i
+      }
+    });
+  }
+}
+class Z extends r {
+  static {
+    this.PANEL_TYPE = m;
+  }
+  static {
+    this.TRIGGER_SOURCE = E;
+  }
+  constructor(t, i, s, n) {
+    super({
+      eventName: "epigraph_panel_opened",
+      interactiveEvent: t,
+      customParameters: {
+        items: n,
+        panel_type: i,
+        trigger_source: s
+      }
+    });
+  }
+}
+class B extends r {
+  static {
+    this.PANEL_TYPE = m;
+  }
+  static {
+    this.TRIGGER_SOURCE = E;
+  }
+  constructor(t, i, s, n) {
+    super({
+      eventName: "epigraph_panel_closed",
+      interactiveEvent: t,
+      customParameters: {
+        items: n,
+        panel_type: i,
+        trigger_source: s
+      }
+    });
+  }
+}
+class Q extends r {
+  constructor(t) {
+    super({
+      eventName: "epigraph_add_to_favourites",
+      interactiveEvent: !0,
+      customParameters: {
+        items: t
+      }
+    });
+  }
+}
+class Y extends r {
+  static {
+    this.ACTION_PERFORMED = f;
+  }
+  constructor(t) {
+    super({
+      eventName: "epigraph_keyboard_interaction",
+      interactiveEvent: !0,
+      customParameters: {
+        action_performed: t
+      }
+    });
+  }
+}
+class tt extends r {
+  static {
+    this.INTERACTION_TYPE = f;
+  }
+  constructor(t) {
+    super({
+      eventName: "epigraph_touch_interaction",
+      interactiveEvent: !0,
+      customParameters: {
+        interaction_type: t
+      }
+    });
+  }
+}
+class et extends r {
+  static {
+    this.CURRENCY = d;
+  }
+  constructor(t, i, s, n, a) {
+    super({
+      eventName: "epigraph_item_added",
+      interactiveEvent: t,
+      customParameters: {
+        items: a,
+        value: i,
+        currency: s,
+        quantity: n
+      }
+    });
+  }
+}
+class it extends r {
+  constructor(t) {
+    super({
+      eventName: "epigraph_item_moved",
+      interactiveEvent: !0,
+      customParameters: {
+        items: t
+      }
+    });
+  }
+}
+class st extends r {
+  static {
+    this.CURRENCY = d;
+  }
+  constructor(t, i, s, n) {
+    super({
+      eventName: "epigraph_item_removed",
+      interactiveEvent: !0,
+      customParameters: {
+        items: n,
+        value: t,
+        currency: i,
+        quantity: s
+      }
+    });
+  }
+}
+class nt extends r {
+  static {
+    this.VARIANT_CHANGE_TYPES = O;
+  }
+  constructor(t, i) {
+    super({
+      eventName: "epigraph_variant_changed",
+      interactiveEvent: !0,
+      customParameters: {
+        items: i,
+        change_type: t
+      }
+    });
+  }
+}
+class rt extends r {
+  static {
+    this.CONTENT_TYPES = x;
+  }
+  static {
+    this.SHARE_DESTINATIONS = P;
+  }
+  constructor(t, i, s) {
+    super({
+      eventName: "epigraph_content_shared",
+      interactiveEvent: !0,
+      customParameters: {
+        items: s,
+        content_type: t,
+        share_destination: i
+      }
+    });
+  }
+}
+class at extends r {
+  static {
+    this.CURRENCY = d;
+  }
+  constructor(t, i, s) {
+    super({
+      eventName: "epigraph_checkout",
+      interactiveEvent: !0,
+      customParameters: {
+        items: s,
+        value: t,
+        currency: i
+      }
+    });
+  }
+}
+class ot extends r {
+  static {
+    this.CURRENCY = d;
+  }
+  constructor(t, i, s) {
+    super({
+      eventName: "epigraph_conversion",
+      interactiveEvent: !0,
+      customParameters: {
+        items: s,
+        value: t,
+        currency: i
+      }
+    });
+  }
+}
+class ut extends r {
+  constructor(t) {
+    super({
+      eventName: "epigraph_changeRate",
+      interactiveEvent: !1,
+      customParameters: {
+        value: t
+      }
+    });
+  }
+}
+class ht extends r {
+  constructor(t) {
+    super({
+      eventName: "epigraph_completionRate",
+      interactiveEvent: !1,
+      customParameters: {
+        value: t
+      }
+    });
+  }
+}
+class ct extends r {
+  constructor(t) {
+    super({
+      eventName: "epigraph_engagementRate",
+      interactiveEvent: !1,
+      customParameters: {
+        value: t
+      }
+    });
+  }
+}
+class dt extends r {
+  constructor(t, i, s) {
+    super({
+      eventName: t,
+      interactiveEvent: i,
+      customParameters: s
+    });
+  }
+}
+/**
+ * @license
+ * Copyright (c) 2023 Epigraph LLC. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the 'License');
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an 'AS IS' BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+var D;
+const c = Symbol("analyticsPluginsMap");
+D = c;
+class lt {
+  constructor(t, i) {
+    this[D] = /* @__PURE__ */ new Map(), this.__consentPlugin = null, t && i && (this.__consentPlugin = this.buildConsentPlugin(t, i)), window.addEventListener("epigraphAnalyticsConsentChange", this.__onConsentChangeFromEvent);
+  }
+  __onConsentChangeFromEvent(t) {
+    let i = t;
+    this.__overrideConsent = i.detail.hasConsent;
+    for (const s of this[c].values())
+      this.__hasConsent() || s.setStatus(o.RESTRICTED);
+  }
+  /**
+   * Epigraph Analytics uses plugins to send events to multiple trackers at a time. You can create a customer tracker
+   * by implementing the IAnalyticsPlugin and then adding it via this function. This will also hold only a single
+   * instance of a plugin with a given Tracking Identifier.
+   *
+   * @param plugin
+   */
+  addEventPlugin(t) {
+    this[c].has(t.getUniquePluginIdentifier()) || (this[c].set(
+      t.getUniquePluginIdentifier(),
+      t
+    ), t.setupPlugin());
+  }
+  /**
+   * Resolves session consent by prioritizing this._overrideConsent and if not found,
+   * getting the value from the consent plugin, if available.
+   *
+   * @returns {boolean} Whether the session has consent to track analytics or not.
+   */
+  __hasConsent() {
+    let t = !0;
+    return this.__overrideConsent !== void 0 ? (t = this.__overrideConsent, t) : (this.__consentPlugin && (t = this.__consentPlugin.hasConsent()), t);
+  }
+  /**
+   * Send an Event to all plugins
+   *
+   * @param eventData
+   */
+  sendEvent(t) {
+    this[c].forEach((i) => {
+      i.sendEvent(t, this.__hasConsent());
+    });
+  }
+  /**
+   * Returns an IConsentPlugin if something is passed to it. Returns null if we can't find the plugin named.
+   * @param consentPluginName
+   * @param consentIdentifier
+   * @private
+   */
+  buildConsentPlugin(t, i) {
+    return t.toLowerCase() === S.OneTrust.toLowerCase() ? new b(i) : null;
+  }
+}
+export {
+  f as ACTION_PERFORMED,
+  T as BUTTON_TYPE,
+  x as CONTENT_TYPES,
+  d as CURRENCY,
+  S as ConsentPluginNames,
+  Q as EpigraphAddToFavouritesEvent,
+  lt as EpigraphAnalytics,
+  F as EpigraphArRequestedEvent,
+  K as EpigraphButtonClickEvent,
+  ut as EpigraphChangeRateEvent,
+  at as EpigraphCheckoutEvent,
+  ht as EpigraphCompletionRateEvent,
+  rt as EpigraphContentSharedEvent,
+  ot as EpigraphConversionEvent,
+  dt as EpigraphCustomEvent,
+  ct as EpigraphEngagementRateEvent,
+  et as EpigraphItemAddedEvent,
+  it as EpigraphItemMovedEvent,
+  st as EpigraphItemRemovedEvent,
+  Y as EpigraphKeyboardInteractionEvent,
+  X as EpigraphModuleClosedEvent,
+  J as EpigraphModuleFailedEvent,
+  j as EpigraphModuleLoadingEvent,
+  W as EpigraphModuleReadyEvent,
+  B as EpigraphPanelClosedEvent,
+  Z as EpigraphPanelOpenedEvent,
+  H as EpigraphSupportDetectedEvent,
+  tt as EpigraphTouchInteractionEvent,
+  nt as EpigraphVariantChangedEvent,
+  $ as GA4AnalyticsPlugin,
+  w as MODULE_FAILED_ERRORS,
+  V as NexusAnalyticsPlugin,
+  U as NexusSolutionsAnalyticsPlugin,
+  b as OneTrustConsentPlugin,
+  m as PANEL_TYPE,
+  P as SHARE_DESTINATIONS,
+  L as SUPPORT_TYPE,
+  E as TRIGGER_SOURCE,
+  O as VARIANT_CHANGE_TYPES
+};