@epigraph/epigraph-std-lib 3.3.1-alpha → 4.0.0-alpha

package/README.md

@@ -13,8 +13,8 @@ A global object that must only be initialized once per session and provides some
 | EpigraphBaseSolutionLitElement | A base class intended to enforce some common functionalities across our solutions, built by extending the LitElement |
 | EpigraphLogger | A logger class that provides a convenient way for logging info, warning or errors in any given session |
 | EpigraphQrCoreGenerator | A Utility class that allows the generation of a QR code from a give string input |
-| EpigraphUnitsConverter | A Utility class that allows conversion between different standard unit, including but not limited to Distance, Color, etc. |
-| EpigraphUrlProcessor | A Utility class that provides various methods to generate, process, manipulate URLs |
+| EpigraphUnitsConverter |  |
+| EpigraphUrlProcessor |  |
 
 
 ### 3rd PARTY LIBRARY EXPORTS
@@ -23,8 +23,6 @@ A global object that must only be initialized once per session and provides some
 |---|---|
 | [three](https://threejs.org/) | ![three version](https://img.shields.io/badge/three-0.169.0-green) |
 | [model-viewer](https://modelviewer.dev/) | ![@google/model-viewer version](https://img.shields.io/badge/model--viewer-4.0.0-green) |
-| [@epigraph/epigraph-analytics](https://www.npmjs.com/package/@epigraph/epigraph-analytics)  |![@epigraph/epigraph-analytics version](https://img.shields.io/badge/epigraph--analytics-1.0.0-green)|
-| [qr-creator](https://www.npmjs.com/package/qr-creator)  |![qr-creator version](https://img.shields.io/badge/qr--creator-1.0.0-green)|
 
 
 # HOW TO:
@@ -32,8 +30,42 @@ A global object that must only be initialized once per session and provides some
 ### Add a new EpigraphLibrary:
 1. Create a new directory under lib/EpigraphLibs/`<MyEpigraphLibrary>`
 2. Create the module file/s. Ensure that the names of these files are in camelCase.
-3. Export this module in lib/EpigraphLibs/epigraph-std-lib.ts as `export * from "./ThirdPartyLibs/main";`
-4. Write a test for this Library under tests/<MyEpigraphLibrary.test.ts>
+3. Write a test for this Library under tests/<MyEpigraphLibrary.test.ts>
+4. Add the module that you wish to export as an entry in vite.config.ts > defineConfig > build > entry, similar to other entries in there. This will bundle the new module on build.
+5. Go to package.json:
+    - Add the new module entry under exports similar to other entries in that field.
+    - Add the new module entry under typesVersions similar to other entries in that field.
+
+### Use the library
+This library exports the module into submodules to allow for better tree shaking when bundling the final product. Here is how you can import the submodules individually.
+
+```javascript
+// Epigraph Object
+import { Epigraph } from "@epigraph/epigraph-std-lib/dist/Epigraph/epigraph";
+
+// Epigraph libs
+import { EpigraphAnalytics } from "@epigraph/epigraph-std-lib/dist/EpigraphLibs/epigraphAnalytics";
+
+// Third Party libs
+import { Scene } from "@epigraph/epigraph-std-lib/dist/ThirdPartyLibs/threejs";
+
+```
+
+Exported Submodules:
+| Name  | Description  |
+|---|---|
+| @epigraph/epigraph-std-lib/dist/Epigraph/epigraph | A base class intended to enforce some common functionalities across our solutions, built by extending the HTMLElement |
+| @epigraph/epigraph-std-lib/dist/EpigraphLibs/epigraphAnalytics | An Analytics modules that exports handy ways to log analytics across our solutions |
+| @epigraph/epigraph-std-lib/dist/EpigraphLibs/epigraphLogger | A Logger modules that exports handy ways to log across our solutions |
+| @epigraph/epigraph-std-lib/dist/EpigraphLibs/epigraphNexusApi | A Nexus API modules that exports handy ways to interact with the Nexus API across our solutions |
+| @epigraph/epigraph-std-lib/dist/EpigraphLibs/epigraphQrCodeGenerator | A QR Code generator modules that exports handy ways to generate QR Codes across our solutions |
+| @epigraph/epigraph-std-lib/dist/EpigraphLibs/epigraphResultFactory | A Result Factory modules that exports handy ways to generate Result objects across our solutions |
+| @epigraph/epigraph-std-lib/dist/EpigraphLibs/epigraphUnitsConverter | A Utility class that allows conversion between different standard unit, including but not limited to Distance, Color, etc. |
+| @epigraph/epigraph-std-lib/dist/EpigraphLibs/epigraphUrlProcessor | A Utility class that provides various methods to generate, process, manipulate URLs |
+| @epigraph/epigraph-std-lib/dist/ThirdPartyLibs/threejs | A three.js modules that exports the three.js library |
+| @epigraph/epigraph-std-lib/dist/ThirdPartyLibs/modelViewer | A model-viewer modules that exports the model-viewer library |
+
+
 
 ### Write a test: 
 We use [vitest](https://vitest.dev/guide/) to write tests in this repository using [happy-dom](https://www.npmjs.com/package/happy-dom) to support some but not all browser functionalities. In order to write a new test:

package/dist/Epigraph/epigraph.d.ts

@@ -1,6 +1,6 @@
 import { EpigraphLogger, LoggerModeNames } from '../EpigraphLibs/EpigraphLogger/epigraphLogger';
 import { ENVIRONMENT_TYPE } from './constants/enums';
-import { UrlProcessor } from '../EpigraphLibs/EpigraphUrlProcessor/epigraphUrlProcessor';
+import { EpigraphUrlProcessor } from '../EpigraphLibs/EpigraphUrlProcessor/epigraphUrlProcessor';
 import { EpigraphBaseSolutionTypes, EpigraphBaseSolutionHtmlElement, EpigraphBaseSolutionLitElement } from './epigraphBaseSolution';
 /**
  * Epigraph component is intended to be a global source of truth/tracker in a given session for all of our components.
@@ -24,7 +24,7 @@ export declare class Epigraph {
     constructor(initializer: EpigraphBaseSolutionTypes);
     get isReady(): boolean;
     get logger(): EpigraphLogger;
-    get urlProcessor(): UrlProcessor;
+    get urlProcessor(): EpigraphUrlProcessor;
     get epigraphSessionId(): string;
     get environment(): ENVIRONMENT_TYPE;
     get initializer(): EpigraphBaseSolutionTypes;

package/dist/Epigraph/epigraph.js

@@ -0,0 +1,178 @@
+import { EpigraphLogger as h, LoggerModeNames as g } from "../EpigraphLibs/epigraphLogger.js";
+import { EpigraphUrlProcessor as l, QUERY_PARAMETER_NAMES as d } from "../EpigraphLibs/epigraphUrlProcessor.js";
+import { LitElement as p } from "lit";
+var o = /* @__PURE__ */ ((r) => (r.DEVELOPMENT = "development", r.STAGING = "staging", r.PRODUCTION = "production", r))(o || {});
+class w extends HTMLElement {
+  constructor(e, t) {
+    super(), this._isReady = !1, this._elementName = "epigraph-base-solution-html", this._solutionVersion = "", this._loggerContextOverride = "[EPIGRAPH BASE SOLUTION]", this.attachShadow({ mode: "open" }), this._environment = t, this._solutionVersion = e, this._xPath = i.generateXPath(this), this._uuid = i.safeGenerateUuid() ?? this._xPath, new i(this), window.epigraph.logger.info({
+      title: "Epigraph Base Solution Ready",
+      contextOverride: this._loggerContextOverride
+    });
+  }
+  get isReady() {
+    return this._isReady;
+  }
+  get environment() {
+    return this._environment;
+  }
+  get elementName() {
+    return this._elementName;
+  }
+  /**
+   * This is the npm package version of this solution.
+   */
+  get solutionVersion() {
+    return this._solutionVersion;
+  }
+  get uuid() {
+    return this._uuid;
+  }
+  get xPath() {
+    return this._xPath;
+  }
+  disconnectedCallback() {
+    window.epigraph.deregisterActiveComponent(this);
+  }
+}
+class C extends p {
+  constructor(e, t) {
+    super(), this._isReady = !1, this._elementName = "epigraph-base-solution-lit", this._solutionVersion = "", this._loggerContextOverride = "[EPIGRAPH BASE SOLUTION]", this._environment = t, this._solutionVersion = e, this._xPath = i.generateXPath(this), this._uuid = i.safeGenerateUuid() ?? this._xPath, new i(this), this._isReady = !0, window.epigraph.logger.info({
+      title: "Epigraph Base Solution Ready",
+      contextOverride: this._loggerContextOverride
+    });
+  }
+  get isReady() {
+    return this._isReady;
+  }
+  get environment() {
+    return this._environment;
+  }
+  get elementName() {
+    return this._elementName;
+  }
+  /**
+   * This is the npm package version of this solution.
+   */
+  get solutionVersion() {
+    return this._solutionVersion;
+  }
+  get uuid() {
+    return this._uuid;
+  }
+  get xPath() {
+    return this._xPath;
+  }
+  disconnectedCallback() {
+    window.epigraph.deregisterActiveComponent(this);
+  }
+}
+class i {
+  constructor(e) {
+    if (this._loggerContext = "EPIGRAPH", this._isReady = !1, this._logger = new h("EPIGRAPH LOGGER"), this._environment = o.DEVELOPMENT, this._activeComponentsInSession = /* @__PURE__ */ new Map(), this._staleComponentsInSession = /* @__PURE__ */ new Map(), window.epigraph)
+      return window.epigraph.registerActiveComponent(e), window.epigraph;
+    window.epigraph = this, window.epigraph.registerActiveComponent(e), this.logBranding(), this._initializer = e, this._environment = this._initializer.environment;
+    const t = this.getLoggerModeNameFromEnvironment();
+    this._logger.setCurrentMode(t), this._urlProcessor = new l(), this.id = i.safeGenerateUuid();
+    const n = this._urlProcessor.getParameterInUrl(d.epigraphSessionId);
+    this._epigraphSessionId = n ?? i.safeGenerateUuid(), this._logger.info({ title: "Epigraph Object Ready!!", details: this, contextOverride: this._loggerContext }), this._isReady = !0;
+  }
+  get isReady() {
+    return this._isReady;
+  }
+  get logger() {
+    return this._logger;
+  }
+  get urlProcessor() {
+    return this._urlProcessor;
+  }
+  get epigraphSessionId() {
+    return this._epigraphSessionId;
+  }
+  get environment() {
+    return this._environment;
+  }
+  get initializer() {
+    return this._initializer;
+  }
+  get activeComponentsInSession() {
+    return this._activeComponentsInSession;
+  }
+  get staleComponentsInSession() {
+    return this._staleComponentsInSession;
+  }
+  /**
+   * Logs Epigraph Branding in the console to help redirect potential interests in the right direction.
+   */
+  logBranding() {
+    console.group("Powered by: "), console.log("%cEPIGRAPH", "font-weight: bold; font-size: 50px; text-shadow: 3px 3px 0 rgb(100,100,100)"), console.log("Visit for more details: www.epigraph.us"), console.groupEnd();
+  }
+  /**
+   * Registers a new component that was initialized on this page.
+   * This is optional from the perspective of the initialization flow but highly recommend
+   * registering any component that gets initialized in this session.
+   * Any component that inherits from EpigraphBaseSolution should automatically register itself on initialization.
+   *
+   * @param {EpigraphBaseSolutionTypes} solutionRef A type of Epigraph base component that is initialized in the session.
+   */
+  registerActiveComponent(e) {
+    this._activeComponentsInSession.set(e.uuid, e), this._logger.info({ title: "Registered a new Active Component", details: e, contextOverride: this._loggerContext });
+  }
+  /**
+   * De-Registers a component that was initialized on this page.
+   * This is optional from the perspective of the unmount flow but highly recommend
+   * de-registering any component that gets removed in this session.
+   * Any component that inherits from EpigraphBaseSolution should automatically de-register itself on unmount.
+   *
+   * @param {EpigraphBaseSolutionTypes} solutionRef A type of Epigraph base component that is initialized in the session.
+   */
+  deregisterActiveComponent(e) {
+    const t = this._activeComponentsInSession.get(e.uuid);
+    t && (this._staleComponentsInSession.set(t.uuid, t), this._activeComponentsInSession.delete(t.uuid), this._logger.info({ title: "Deregistered a new Active Component", details: e, contextOverride: this._loggerContext }));
+  }
+  /**
+   * Gets the mode that the logger should be executed in, based on the runtime environment.
+   *
+   * @returns {LoggerModeNames} A valid logger mode name.
+   */
+  getLoggerModeNameFromEnvironment() {
+    let e = g.Dev;
+    return this._environment === o.STAGING ? e = g.Staging : this._environment === o.PRODUCTION && (e = g.Release), e;
+  }
+  /**
+   * Generates a random UUID using crypto.randomUUID with a fallback on custom generator,
+   * if the first option fails for any reason in an environment.1
+   *
+   * @returns {string} A random generated ID.
+   */
+  static safeGenerateUuid() {
+    let e = "";
+    try {
+      e = crypto.randomUUID();
+    } catch {
+      console.error("crypto not available. Not generating a UUID");
+    }
+    return e;
+  }
+  /**
+   * Generates an XPath based on a DOM nodes location on the page.
+   *
+   * @param {HTMLElement} element The element that we need the XPath for.
+   * @returns {string} The generated XPath.
+   */
+  static generateXPath(e) {
+    let t = "", n = e;
+    for (; n; ) {
+      let a = 1, s = n.previousSibling;
+      for (; s; )
+        s.nodeName === n.nodeName && a++, s = s.previousSibling;
+      t = `/${n.nodeName.toLowerCase() + (a > 1 ? `[${a}]` : "")}${t}`, n = n.parentNode;
+    }
+    return t;
+  }
+}
+export {
+  o as ENVIRONMENT_TYPE,
+  i as Epigraph,
+  w as EpigraphBaseSolutionHtmlElement,
+  C as EpigraphBaseSolutionLitElement
+};

package/dist/EpigraphLibs/EpigraphLogger/epigraphLogger.d.ts

@@ -1,8 +1,8 @@
-interface LoggerMode {
+export interface LoggerMode {
     name: string;
     allows: Array<string>;
 }
-interface LoggerModes {
+export interface LoggerModes {
     release: LoggerMode;
     staging: LoggerMode;
     dev: LoggerMode;
@@ -51,7 +51,7 @@ export interface ILoggerGroup {
  * Mode: A logger's mode defines what log types would be automatically executed and
  *       what would be ignored.
  */
-declare class EpigraphLogger {
+export declare class EpigraphLogger {
     context: string;
     private _allModes;
     private _currentMode;
@@ -153,4 +153,3 @@ declare class EpigraphLogger {
      */
     groupEnd(): void;
 }
-export { EpigraphLogger };

package/dist/EpigraphLibs/EpigraphUrlProcessor/epigraphUrlProcessor.d.ts

@@ -8,7 +8,7 @@ export declare const enum QUERY_PARAMETER_NAMES {
     epigraphSessionId = "eid",
     action = "a"
 }
-export declare class UrlProcessor {
+export declare class EpigraphUrlProcessor {
     private _baseUrl;
     constructor(baseUrl?: string);
     get baseUrl(): string;

package/dist/EpigraphLibs/epigraphAnalytics.js

@@ -0,0 +1,399 @@
+const l = Symbol("data"), u = Symbol("next"), v = class y {
+  constructor(e) {
+    this[l] = e, this[u] = null;
+  }
+  get data() {
+    return this[l];
+  }
+  set next(e) {
+    if (!(e instanceof y) && e !== null)
+      throw new Error(
+        "This node is not an instance of the custom class 'Node'."
+      );
+    this[u] = e;
+  }
+  get next() {
+    return this[u];
+  }
+};
+let g = v;
+const h = Symbol("head");
+class m {
+  constructor() {
+    this[h] = null;
+  }
+  set head(e) {
+    this[h] = e;
+  }
+  get head() {
+    return this[h];
+  }
+  addToTail(e) {
+    let t = this.head;
+    if (t) {
+      for (; t.next !== null; )
+        t = t == null ? void 0 : t.next;
+      return t.next = new g(e);
+    }
+    return this.head = new g(e);
+  }
+  removeHead() {
+    const e = this.head;
+    if (e)
+      return this.head = e.next, e.data;
+  }
+}
+const f = Symbol("queue"), o = Symbol("size");
+class d {
+  constructor() {
+    this[f] = new m(), this[o] = 0;
+  }
+  get queue() {
+    return this[f];
+  }
+  get size() {
+    return this[o];
+  }
+  enqueue(e) {
+    this.queue.addToTail(e), this[o]++;
+  }
+  dequeue() {
+    const e = this.queue.removeHead();
+    return this[o]--, e;
+  }
+}
+class I {
+  constructor(e, t, n, s) {
+    this.name = this.pluginName = "GA3-PLUGIN", this.trackingID = e, this.verboseLogging = t, this.user = n, this.trackerName = s, this.queue = new d(), this.trackerInterval = 0, this.trackerCreated = !1;
+  }
+  /**
+   * This function will send an Event to GA3.
+   *
+   * @param eventData AnalyticsEvent The event to be tracked
+   */
+  sendEvent(e) {
+    if (this.queue.enqueue(e), window.ga !== void 0 && typeof ga == "function")
+      try {
+        this.dequeueAndSendEvents();
+      } catch (t) {
+        this.logger(t);
+      }
+    else
+      this.logger("Cannot send Google Analytics 3 event: ga function is not defined.");
+    return !0;
+  }
+  /**
+   * Send all events that are in the queue
+   * @private
+   */
+  dequeueAndSendEvents() {
+    if (this.trackerCreated) {
+      let e = this.queue.size;
+      for (let t = 0; t < e; t++) {
+        const n = this.queue.dequeue();
+        ga(
+          `${this.trackerName}.send`,
+          n.type,
+          n.category,
+          n.action,
+          n.label,
+          n.interaction
+        ), this.logger(`Google Analytics 3 event successfully sent: ${n.action}`);
+      }
+    } else
+      this.logger("Cannot sent Google Analytics 3 event: tracker was not created.");
+  }
+  /**
+   * GA3 requires that a tracker be created prior to being sent. This is called from the constructor. It is
+   * important to note that the promise that is inherently returned is ignored in the constructor at this
+   * time. This is due to the events that are added will be queued from the page. This script requires
+   * that the GA script has been imported on the page already as it does not check for it today.
+   *
+   * @private
+   */
+  async createTracker() {
+    if (window.ga !== void 0 && typeof ga == "function")
+      try {
+        ga("create", this.trackingID, "auto", this.trackerName, {
+          userId: this.user
+        });
+        const e = new URL(window.location.href);
+        ga(`${this.trackerName}.set`, "page", e.pathname), ga(`${this.trackerName}.set`, "location", e.href), this.trackerCreated = !0, this.logger("Google Analytics 3 tracker successfully created."), this.dequeueAndSendEvents(), window.clearInterval(this.trackerInterval);
+      } catch (e) {
+        this.logger(e);
+      }
+    else
+      this.logger("Error: Cannot create tracker, ga function is not defined.");
+  }
+  /**
+   * Checks if verboseLogging is enabled, then logs the error
+   * @param err 
+   */
+  logger(e) {
+    this.verboseLogging && console.warn(e);
+  }
+  /**
+   * Returns a unique plugin identifier so that tracking ID's can be the same across multiple plugins.
+   */
+  getUniquePluginIdentifier() {
+    return this.pluginName + "-" + this.trackingID;
+  }
+  setupPlugin() {
+    var e = 0;
+    this.trackerInterval = window.setInterval(() => {
+      this.createTracker(), ++e === 10 && (window.clearInterval(this.trackerInterval), this.logger("Error: Failed to create Google Analytics tracker in the allotted timeframe."));
+    }, 1e3);
+  }
+}
+class A {
+  constructor(e, t) {
+    this.name = this.pluginName = "GA4-PLUGIN", this.trackingID = e, this.verboseLogging = t, this.queue = new d(), this.dataLayer = window.dataLayer, this.dataLayerName = "dataLayer", this.setupDataLayer(), this.initGtag(this.dataLayerName, this.trackingID);
+  }
+  setupDataLayer() {
+    if (this.dataLayer) return;
+    const e = this.findGA4ScriptInfo(this.trackingID), t = e == null ? void 0 : e.l;
+    t && (this.dataLayerName = t, this.dataLayer = window[t]);
+  }
+  initGtag(e = "dataLayer", t) {
+    typeof window.gtag != "function" && (window.gtag = function() {
+      window[e].push(arguments), gtag("js", /* @__PURE__ */ new Date()), gtag("config", t);
+    });
+  }
+  /**
+   * This function will send an Event to GA3.
+   *
+   * @param eventData AnalyticsEvent The event to be tracked
+   * @param consentPlugin
+   */
+  async sendEvent(e, t) {
+    this.queue.enqueue(e);
+    let n = !0;
+    if (t && (n = t.hasConsent()), this.dataLayer !== void 0 && n)
+      try {
+        await this.dequeueAndSendEvents();
+      } catch (s) {
+        this.logger(s);
+      }
+    else
+      this.logger("Cannot send Google Analytics 4 event: dataLayer is not defined.");
+  }
+  /**
+   * Send all events that are in the queue
+   * @private
+   */
+  async dequeueAndSendEvents() {
+    let e = this.queue.size;
+    for (let t = 0; t < e; t++) {
+      const n = this.queue.dequeue();
+      let s = {
+        send_to: this.trackingID,
+        event_action: n.action,
+        event_category: n.category,
+        event_label: n.label,
+        epg_event_tag: ""
+      };
+      if ("parameters" in n && (s = {
+        ...s,
+        ...n.parameters
+      }), JSON.stringify(s).length > 459)
+        try {
+          let a = await this.sendGA4LongParameters(s);
+          s = {
+            send_to: this.trackingID,
+            event_action: n.action,
+            event_category: n.category,
+            event_label: n.label,
+            epg_event_tag: a
+          };
+        } catch {
+        }
+      gtag("event", n.action, s), this.logger(`Google Analytics 4 event successfully sent: ${n.action}`);
+    }
+  }
+  /**
+   * Checks if verboseLogging is enabled, then logs the error
+   * @param err
+   */
+  logger(e) {
+    this.verboseLogging && console.warn(e);
+  }
+  /**
+   * 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.dataLayer !== void 0 && this.dequeueAndSendEvents();
+  }
+  async sendGA4LongParameters(e) {
+    const t = "https://api.myepigraph.com/api/analytics/ga4/custom", n = {
+      parameters: e
+    };
+    try {
+      const s = await fetch(t, {
+        method: "POST",
+        // Assuming it's a POST request, adjust if necessary
+        headers: {
+          "Content-Type": "application/json",
+          Accept: "application/json"
+        },
+        body: JSON.stringify(n)
+      });
+      if (s.ok) {
+        const r = await s.json();
+        return r && r.id ? r.id : "";
+      } else
+        return "";
+    } catch {
+      return "";
+    }
+  }
+  findGA4ScriptInfo(e) {
+    const t = document.querySelectorAll("script[src]");
+    for (const n of t) {
+      const s = n.getAttribute("src");
+      if (s && s.includes(e)) {
+        const r = new URL(s, location.href), a = Object.fromEntries(r.searchParams.entries());
+        return {
+          fullSrc: r.href,
+          id: a.id || void 0,
+          l: a.l || void 0
+        };
+      }
+    }
+    return null;
+  }
+}
+class L {
+  constructor(e, t, n, s, r = !1) {
+    this.sessionId = t, this.xPath = n, this.name = this.pluginName = "NEXUS-PLUGIN", this.trackingID = e, this.verboseLogging = s, this.queue = new d(), this.url = r ? "https://nexus.epigraph.dev/api/analytics/event" : "https://api.myepigraph.com/api/analytics/event";
+  }
+  async sendEvent(e, t) {
+    this.queue.enqueue(e);
+    let n = !0;
+    t && (n = t.hasConsent()), n && await this.dequeueAndSendEvents();
+  }
+  async dequeueAndSendEvents() {
+    for (let e = 0; e < this.queue.size; e++) {
+      const t = this.queue.dequeue(), n = {
+        experience_id: this.trackingID,
+        action: t.action,
+        parameters: t.parameters
+      };
+      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(n)
+        })).status === 204, "";
+      } catch {
+        return "";
+      }
+    }
+    return "";
+  }
+  getUniquePluginIdentifier() {
+    return this.name + "-" + this.trackingID;
+  }
+  setupPlugin() {
+  }
+}
+class q {
+  constructor(e) {
+    this.consentSet = !1, this.consent = !1, this.pluginName = "OneTrustConsentPlugin", this.consentIdentifier = e, 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.OnetrustActiveGroup !== void 0) {
+      let e = window.OnetrustActiveGroup;
+      e !== void 0 && e.split(",").forEach((n) => {
+        n === 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 p = /* @__PURE__ */ ((i) => (i.OneTrust = "onetrust", i))(p || {});
+/**
+ * @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 w;
+const c = Symbol("analyticsPluginsMap");
+w = c;
+class S {
+  constructor(e, t) {
+    this[w] = /* @__PURE__ */ new Map(), this._consentPlugin = null, e && t && (this._consentPlugin = this.buildConsentPlugin(e, t));
+  }
+  /**
+   * 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(e) {
+    this[c].has(e.getUniquePluginIdentifier()) || (this[c].set(
+      e.getUniquePluginIdentifier(),
+      e
+    ), e.setupPlugin());
+  }
+  /**
+   * Send an Event to all plugins
+   *
+   * @param eventData
+   */
+  sendEvent(e) {
+    this[c].forEach((t) => {
+      t.sendEvent(e, this._consentPlugin);
+    });
+  }
+  /**
+   * 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(e, t) {
+    return e.toLowerCase() === p.OneTrust.toLowerCase() ? new q(t) : null;
+  }
+}
+export {
+  p as ConsentPluginNames,
+  S as EpigraphAnalytics,
+  I as GA3AnalyticsPlugin,
+  A as GA4AnalyticsPlugin,
+  L as NexusAnalyticsPlugin,
+  q as OneTrustConsentPlugin
+};