@ariestools/sdk-react 10.0.2

package/dist/_pkg/pixel/browser/index.mjs

@@ -0,0 +1,1211 @@
+// src/contexts/UserEvents/Context.ts
+import { createContext } from "react";
+var UserEventsContext = createContext({});
+var DebugUserEventsContext = createContext({
+  isDebugging: false,
+  setIsDebugging: (value) => {
+    console.warn("set is debugging is not set", value);
+  }
+});
+
+// src/contexts/UserEvents/Provider.tsx
+import { useMemo } from "react";
+
+// src/lib/Tracking/Drip/BaseEvent.ts
+import { delay } from "@ariestools/sdk";
+var DripBaseEvent = class {
+  dcq;
+  dcs;
+  name;
+  param;
+  constructor(name, param) {
+    this.name = name;
+    this.param = param;
+    this.dcq = this.getDcq();
+    this.dcs = this.getDcs();
+  }
+  async send(data) {
+    const payload = [this.name];
+    if (this.param !== void 0 && this.param.length > 0) {
+      payload.push(this.param);
+    }
+    payload.push(data);
+    console.log("sdk-react", payload);
+    this.dcq.push(payload);
+    await delay(0);
+  }
+  getDcq() {
+    if (!globalThis._dcq) {
+      throw new Error("DCQ not found");
+    }
+    return globalThis._dcq;
+  }
+  getDcs() {
+    if (!globalThis._dcs) {
+      throw new Error("DCS not found");
+    }
+    return globalThis._dcs;
+  }
+};
+
+// src/lib/Tracking/Drip/CustomEvent.ts
+var DripCustomEvent = class extends DripBaseEvent {
+};
+
+// src/lib/Tracking/Drip/StandardEvents.ts
+var DripStandardEvents = class {
+  identify() {
+    return new DripBaseEvent("identify");
+  }
+};
+
+// src/lib/Tracking/Facebook/BaseEvent.ts
+import { delay as delay2 } from "@ariestools/sdk";
+
+// src/lib/Tracking/Facebook/Fbq.ts
+var Fbq = class _Fbq {
+  pixelId;
+  constructor(pixelId) {
+    this.pixelId = pixelId;
+    this.fbq("init", pixelId);
+    this.track("PageView");
+  }
+  /**
+   * Gets the instance of the Facebook Pixel (fbq).
+   *
+   * @returns {FbqFunction} The global fbq instance.
+   * @throws Will throw an error if the Fbq instance is not initialized.
+   */
+  static get fbq() {
+    if (globalThis.fbq === void 0) {
+      throw new Error("Fbq instance not initialized");
+    }
+    return globalThis.fbq;
+  }
+  /**
+   * Gets the instance of the Facebook Pixel (fbq).
+   *
+   * @returns {FbqFunction} The global fbq instance.
+   * @throws Will throw an error if the Fbq instance is not initialized.
+   */
+  get fbq() {
+    return _Fbq.fbq;
+  }
+  /**
+   * Initializes the Fbq instance with the given pixel ID.
+   *
+   * @param pixelId - The Facebook Pixel ID to initialize the Fbq instance with.
+   * @returns A new instance of Fbq.
+   * @throws Will throw an error if the Fbq instance is not initialized.
+   */
+  static init(pixelId) {
+    if (globalThis.fbq === void 0) {
+      throw new Error("Fbq instance not initialized");
+    }
+    return new _Fbq(pixelId);
+  }
+  /**
+   * Tracks a Facebook standard event using the Facebook Pixel.
+   * This will call all initialized pixels.
+   *
+   * @param event - The Facebook standard event to track.
+   * @param data - Optional additional data to send with the event.
+   * @param eventID - An optional unique identifier for the event.
+   */
+  static track(event, data, eventID) {
+    this.fbq(
+      "track",
+      event,
+      data,
+      { eventID }
+    );
+  }
+  /**
+   * Tracks a custom event using Facebook's tracking pixel.
+   * This will call all initialized pixels.
+   *
+   * @param event - The name of the custom event to track.
+   * @param data - An object containing additional data to send with the event.
+   * @param eventID - An optional unique identifier for the event.
+   */
+  static trackCustom(event, data, eventID) {
+    this.fbq(
+      "trackCustom",
+      event,
+      data,
+      { eventID }
+    );
+  }
+  /**
+   * Tracks a specified Facebook standard event using the Facebook Pixel.
+   * This will only call the pixel with the specified eventID.
+   *
+   * @param event - The Facebook standard event to track.
+   * @param data - Optional additional data to send with the event.
+   * @param eventID - An optional unique identifier for the event.
+   */
+  track(event, data, eventID) {
+    this.fbq(
+      "trackSingle",
+      this.pixelId,
+      event,
+      data,
+      { eventID }
+    );
+  }
+  /**
+   * Tracks a custom event using Facebook's tracking pixel.
+   * This will only call the pixel with the specified eventID.
+   *
+   * @param event - The name of the custom event to track.
+   * @param data - An object containing additional data to send with the event.
+   * @param eventID - An optional unique identifier for the event.
+   */
+  trackCustom(event, data, eventID) {
+    this.fbq(
+      "trackSingleCustom",
+      this.pixelId,
+      event,
+      data,
+      { eventID }
+    );
+  }
+};
+
+// src/lib/Tracking/Facebook/BaseEvent.ts
+var FacebookBaseEvent = class {
+  fbq;
+  name;
+  constructor(name, fbq) {
+    this.name = name;
+    this.fbq = fbq ?? Fbq;
+  }
+  async send(_data) {
+    await delay2(0);
+  }
+};
+
+// src/lib/Tracking/Facebook/CustomEvent.ts
+import { delay as delay3 } from "@ariestools/sdk";
+import { toSafeJsonObject } from "@ariestools/sdk";
+var FacebookCustomEvent = class extends FacebookBaseEvent {
+  async send(data, eventId) {
+    this.fbq.trackCustom(this.name, toSafeJsonObject(data, void 0, 10), eventId);
+    await delay3(0);
+  }
+};
+
+// src/lib/Tracking/Facebook/StandardEvent.ts
+import { delay as delay4 } from "@ariestools/sdk";
+import { toSafeJsonObject as toSafeJsonObject2 } from "@ariestools/sdk";
+var FacebookStandardEvent = class extends FacebookBaseEvent {
+  async send(data, eventId) {
+    this.fbq.track(this.name, toSafeJsonObject2(data, void 0, 10), eventId);
+    await delay4(0);
+  }
+};
+
+// src/lib/Tracking/Facebook/StandardEvents.ts
+var FacebookStandardEvents = class {
+  addPaymentInfo() {
+    return new FacebookStandardEvent("AddPaymentInfo");
+  }
+  addToCart() {
+    return new FacebookStandardEvent("AddToCart");
+  }
+  addToWishlist() {
+    return new FacebookStandardEvent("AddToWishlist");
+  }
+  completedRegistration() {
+    return new FacebookStandardEvent("CompleteRegistration");
+  }
+  contact() {
+    return new FacebookStandardEvent("Contact");
+  }
+  customizeProduct() {
+    return new FacebookStandardEvent("CustomizeProduct");
+  }
+  donate() {
+    return new FacebookStandardEvent("Donate");
+  }
+  findLocation() {
+    return new FacebookStandardEvent("FindLocation");
+  }
+  initiateCheckout() {
+    return new FacebookStandardEvent("InitiateCheckout");
+  }
+  lead() {
+    return new FacebookStandardEvent("Lead");
+  }
+  pageView() {
+    return new FacebookStandardEvent("PageView");
+  }
+  purchase() {
+    return new FacebookStandardEvent("Purchase");
+  }
+  schedule() {
+    return new FacebookStandardEvent("Schedule");
+  }
+  search() {
+    return new FacebookStandardEvent("Search");
+  }
+  startTrial() {
+    return new FacebookStandardEvent("StartTrial");
+  }
+  submitApplication() {
+    return new FacebookStandardEvent("SubmitApplication");
+  }
+  subscribe() {
+    return new FacebookStandardEvent("Subscribe");
+  }
+  viewContent() {
+    return new FacebookStandardEvent("ViewContent");
+  }
+};
+
+// src/lib/Tracking/Facebook/UserEventHandler.ts
+var FacebookUserEventHandler = class {
+  async funnelStarted(data) {
+    const event = new FacebookCustomEvent("FunnelStarted");
+    return await event.send(data);
+  }
+  async testStarted(data) {
+    const event = new FacebookCustomEvent("TestStarted");
+    return await event.send(data);
+  }
+  async userClick(data) {
+    const event = new FacebookCustomEvent("UserClick");
+    return await event.send(data);
+  }
+  async viewContent(data) {
+    const event = new FacebookCustomEvent("ViewContent");
+    return await event.send(data);
+  }
+};
+
+// src/lib/Tracking/Google/BaseEvent.ts
+import { assertEx as assertEx2 } from "@ariestools/sdk";
+import { toSafeJsonObject as toSafeJsonObject3 } from "@ariestools/sdk";
+
+// src/lib/Tracking/Google/Gtag.ts
+import { assertEx } from "@ariestools/sdk";
+import queryString from "query-string";
+
+// src/lib/Tracking/Google/DataLayer.ts
+var getDataLayer = () => {
+  if (globalThis.dataLayer === void 0) {
+    const dataLayer = [];
+    Reflect.set(globalThis, "dataLayer", dataLayer);
+    return dataLayer;
+  }
+  return globalThis.dataLayer;
+};
+var clearGlobalDataLayer = () => {
+  getDataLayer().length = 0;
+};
+
+// src/lib/Tracking/Google/Gtag.ts
+var Gtag = class _Gtag {
+  // disabling since this is a singleton
+  static instance;
+  awid;
+  domains;
+  ga4id;
+  constructor(ga4id, awid, domains) {
+    this.gtag("init", ga4id);
+    this.gtag("init", awid);
+    this.gtag("domains", domains);
+    this.gtag("event", "page_view");
+    const parsedQueryString = queryString.parse(document.location.search);
+    sessionStorage.setItem("initialReferrer", decodeURIComponent(parsedQueryString.utm_referrer?.toString() ?? document.referrer));
+    delete parsedQueryString.utm_referrer;
+    const remainingSearch = Object.keys(parsedQueryString).length > 0 ? queryString.stringify(parsedQueryString) : "";
+    sessionStorage.setItem("initialQuery", remainingSearch);
+    sessionStorage.setItem("initialPage", document.location.href);
+  }
+  static get gtag() {
+    if (!globalThis.gtag) {
+      throw new Error("Gtag instance not initialized");
+    }
+    return globalThis.gtag;
+  }
+  get gtag() {
+    return _Gtag.gtag;
+  }
+  static clearDataLayer() {
+    clearGlobalDataLayer();
+  }
+  static getInitialPage() {
+    return sessionStorage.getItem("initialPage") ?? "";
+  }
+  static getInitialQuery() {
+    return sessionStorage.getItem("initialQuery") ?? "";
+  }
+  static getInitialReferrer() {
+    return sessionStorage.getItem("initialReferrer") ?? "";
+  }
+  static init(ga4id, awid, domains) {
+    if (this.instance === void 0) {
+      return this.reinit(ga4id, awid, domains);
+    }
+    return this.instance;
+  }
+  static reinit(ga4id, awid, domains) {
+    this.instance = new _Gtag(ga4id, awid, domains);
+    return this.instance;
+  }
+  static updatePagePath(page_path) {
+    const instance = assertEx(this.instance, () => "Not initialized");
+    return instance.updatePagePath(page_path);
+  }
+  sendAdwords(event, data) {
+    return new Promise((resolve) => {
+      this.gtag("event", "conversion", {
+        ...data,
+        event_timeout: 2e3,
+        send_to: `${this.awid}/${event}`
+      });
+      resolve();
+    });
+  }
+  sendAnalytics(event, data) {
+    return new Promise((resolve) => {
+      this.gtag("event", event, {
+        ...data,
+        event_timeout: 2e3,
+        page_location: _Gtag.getInitialPage(),
+        page_referrer: _Gtag.getInitialReferrer(),
+        send_to: this.ga4id
+      });
+      resolve();
+    });
+  }
+  updatePagePath(page_path) {
+    const ga4id = assertEx(this.ga4id, () => "Missing GA4ID");
+    const pathOnly = page_path.split("?", 1)[0];
+    const search = _Gtag.getInitialQuery();
+    this.gtag("config", ga4id, { page_path: `${pathOnly}${search}` });
+  }
+};
+
+// src/lib/Tracking/Google/Gtm.ts
+var Gtm = class _Gtm {
+  static instance;
+  containerId;
+  constructor(containerId) {
+    this.containerId = containerId;
+    getDataLayer().push({ "event": "gtm.ts", "gtm.start": Date.now() });
+  }
+  static clearDataLayer() {
+    clearGlobalDataLayer();
+  }
+  static getInitialQuery() {
+    return sessionStorage.getItem("initialQuery") ?? "";
+  }
+  static init(containerId) {
+    this.instance ??= new _Gtm(containerId);
+    return this.instance;
+  }
+  send(event, data, eventTimeout = 500) {
+    return new Promise((resolve) => {
+      getDataLayer().push({
+        event,
+        ...data,
+        eventCallback: () => {
+          resolve();
+        },
+        eventTimeout
+      });
+    });
+  }
+};
+
+// src/lib/Tracking/Google/BaseEvent.ts
+var GoogleBaseEvent = class {
+  name;
+  adwordConversionId;
+  constructor(name, adwordConversionId) {
+    this.name = name;
+    this.adwordConversionId = adwordConversionId;
+  }
+  gtag() {
+    return assertEx2(Gtag.instance, () => "Missing/uninitialized gtag");
+  }
+  gtm() {
+    return assertEx2(Gtm.instance, () => "Missing/uninitialized gtm");
+  }
+  async send(data) {
+    return await this.sendGtag(data);
+  }
+  async sendGtag(data) {
+    const dataJson = toSafeJsonObject3(data, void 0, 10);
+    await this.gtag().sendAnalytics(this.name, dataJson);
+    if (this.adwordConversionId !== void 0 && this.adwordConversionId.length > 0) {
+      await this.gtag().sendAdwords(this.adwordConversionId, dataJson);
+    }
+  }
+  async sendGtm(data) {
+    await this.gtm().send(this.name, toSafeJsonObject3(data, void 0, 10));
+  }
+};
+
+// src/lib/Tracking/Google/CustomEvent.ts
+var GoogleCustomEvent = class extends GoogleBaseEvent {
+};
+
+// src/lib/Tracking/Google/StandardEvent.ts
+var GoogleStandardEvent = class extends GoogleBaseEvent {
+};
+
+// src/lib/Tracking/Google/StandardEvents.ts
+var GoogleStandardEvents = class {
+  addPaymentInfo() {
+    return new GoogleStandardEvent("add_paymennt_info");
+  }
+  addShippingInfo() {
+    return new GoogleStandardEvent("add_shipping_info");
+  }
+  addToCart() {
+    return new GoogleStandardEvent("add_to_cart");
+  }
+  addToWishList() {
+    return new GoogleStandardEvent("add_to_wishlist");
+  }
+  beginCheckout() {
+    return new GoogleStandardEvent("begin_checkout");
+  }
+  earnVirtualCurrency() {
+    return new GoogleStandardEvent("earn_virtual_currency");
+  }
+  generateLead() {
+    return new GoogleStandardEvent("generate_lead");
+  }
+  joinGroup() {
+    return new GoogleStandardEvent("join_group");
+  }
+  levelEnd() {
+    return new GoogleStandardEvent("level_end");
+  }
+  levelStart() {
+    return new GoogleStandardEvent("level_start");
+  }
+  levelUp() {
+    return new GoogleStandardEvent("level_up");
+  }
+  login() {
+    return new GoogleStandardEvent("login");
+  }
+  postScore() {
+    return new GoogleStandardEvent("post_score");
+  }
+  purchase() {
+    return new GoogleStandardEvent("purchase");
+  }
+  refund() {
+    return new GoogleStandardEvent("refund");
+  }
+  removeFromCart() {
+    return new GoogleStandardEvent("remove_from_cart");
+  }
+  search() {
+    return new GoogleStandardEvent("search");
+  }
+  selectContent() {
+    return new GoogleStandardEvent("select_content");
+  }
+  selectItem() {
+    return new GoogleStandardEvent("select_item");
+  }
+  selectPromotion() {
+    return new GoogleStandardEvent("select_promotion");
+  }
+  share() {
+    return new GoogleStandardEvent("share");
+  }
+  signUp() {
+    return new GoogleStandardEvent("sign_up");
+  }
+  spendVirtualCurrency() {
+    return new GoogleStandardEvent("spend_virtual_currency");
+  }
+  tutorialBegin() {
+    return new GoogleStandardEvent("tutorial_begin");
+  }
+  tutorialComplete() {
+    return new GoogleStandardEvent("tutorial_complete");
+  }
+  unlockAchievement() {
+    return new GoogleStandardEvent("unlock_achievement");
+  }
+  viewCart() {
+    return new GoogleStandardEvent("view_cart");
+  }
+  viewItem() {
+    return new GoogleStandardEvent("view_item");
+  }
+  viewItemList() {
+    return new GoogleStandardEvent("view_item_list");
+  }
+  viewPromotion() {
+    return new GoogleStandardEvent("view_promotion");
+  }
+};
+
+// src/lib/Tracking/Google/UserEventHandler.ts
+var GoogleUserEventHandler = class {
+  async funnelStarted(data) {
+    const event = new GoogleCustomEvent("FunnelStarted");
+    return await event.send(data);
+  }
+  async testStarted(data) {
+    const event = new GoogleCustomEvent("TestStarted");
+    return await event.send(data);
+  }
+  async userClick(data) {
+    const event = new GoogleCustomEvent("UserClick");
+    return await event.send(data);
+  }
+  async viewContent(data) {
+    const event = new GoogleCustomEvent("ViewContent");
+    return await event.send(data);
+  }
+};
+
+// src/lib/Tracking/Mixpanel/BaseEvent.ts
+import { toSafeJsonObject as toSafeJsonObject4 } from "@ariestools/sdk";
+var MixpanelBaseEvent = class {
+  mixpanel;
+  name;
+  constructor(name, mixpanel) {
+    this.name = name;
+    this.mixpanel = mixpanel;
+  }
+  send(fields) {
+    this.mixpanel.track(this.name, toSafeJsonObject4(fields, void 0, 10));
+  }
+};
+
+// src/lib/Tracking/Mixpanel/CustomEvent.ts
+var MixpanelCustomEvent = class extends MixpanelBaseEvent {
+};
+
+// src/lib/Tracking/Mixpanel/PageViewEvent.ts
+import { toSafeJsonObject as toSafeJsonObject5 } from "@ariestools/sdk";
+var MixpanelPageViewEvent = class {
+  mixpanel;
+  constructor(mixpanel) {
+    this.mixpanel = mixpanel;
+  }
+  send(fields) {
+    this.mixpanel.track_pageview(toSafeJsonObject5(fields, void 0, 10));
+  }
+};
+
+// src/lib/Tracking/Mixpanel/UserEventHandler.ts
+var MixpanelUserEventHandler = class {
+  mixpanel;
+  constructor(mixpanel) {
+    this.mixpanel = mixpanel;
+  }
+  async funnelStarted(data) {
+    const event = new MixpanelCustomEvent("FunnelStarted", this.mixpanel);
+    event.send(data);
+  }
+  async purchase(data) {
+    const event = new MixpanelCustomEvent("Purchase", this.mixpanel);
+    event.send(data);
+  }
+  async testStarted(data) {
+    const event = new MixpanelCustomEvent("TestStarted", this.mixpanel);
+    event.send(data);
+  }
+  async userClick(data) {
+    const event = new MixpanelCustomEvent("UserClick", this.mixpanel);
+    event.send(data);
+  }
+  async viewContent(data) {
+    const event = new MixpanelCustomEvent("ViewContent", this.mixpanel);
+    event.send(data);
+  }
+};
+
+// src/lib/Tracking/Reddit/BaseEvent.ts
+import { assertEx as assertEx3, delay as delay5 } from "@ariestools/sdk";
+
+// src/lib/Tracking/Reddit/Rdt.ts
+var Rdt = class _Rdt {
+  static instance;
+  static init(pixelId) {
+    try {
+      this.instance = new _Rdt();
+      this.instance.load(pixelId);
+      this.instance.track("PageVisit");
+    } catch (ex) {
+      console.error(ex);
+    }
+  }
+  static getRdt() {
+    if (globalThis.rdt) {
+      return globalThis.rdt;
+    }
+    console.warn("Missing rdt");
+  }
+  load(id) {
+    try {
+      _Rdt.getRdt()?.("init", id);
+    } catch (ex) {
+      console.error(ex);
+    }
+  }
+  track(event, data) {
+    try {
+      _Rdt.getRdt()?.("track", event, { ...data });
+    } catch (ex) {
+      console.error(ex);
+    }
+  }
+};
+
+// src/lib/Tracking/Reddit/BaseEvent.ts
+var RedditBaseEvent = class {
+  name;
+  rdt;
+  constructor(name) {
+    this.name = name;
+    this.rdt = assertEx3(Rdt.instance, () => "Missing Rdt");
+  }
+  async send(_data) {
+    await delay5(0);
+  }
+};
+
+// src/lib/Tracking/Reddit/CustomEvent.ts
+import { delay as delay6 } from "@ariestools/sdk";
+var RedditCustomEvent = class extends RedditBaseEvent {
+  async send(data) {
+    this.rdt.track(this.name, data);
+    await delay6(0);
+  }
+};
+
+// src/lib/Tracking/Reddit/StandardEvent.ts
+import { delay as delay7 } from "@ariestools/sdk";
+var RedditStandardEvent = class extends RedditBaseEvent {
+  async send(data) {
+    this.rdt.track(this.name, data);
+    await delay7(0);
+  }
+};
+
+// src/lib/Tracking/Reddit/StandardEvents.ts
+var RedditStandardEvents = class {
+  addToCart() {
+    return new RedditStandardEvent("AddToCart");
+  }
+  addToWishlist() {
+    return new RedditStandardEvent("AddToWishlist");
+  }
+  lead() {
+    return new RedditStandardEvent("Lead");
+  }
+  pageView() {
+    return new RedditStandardEvent("PageView");
+  }
+  purchase() {
+    return new RedditStandardEvent("Purchase");
+  }
+  search() {
+    return new RedditStandardEvent("Search");
+  }
+  signup() {
+    return new RedditStandardEvent("SignUp");
+  }
+  viewContent() {
+    return new RedditStandardEvent("ViewContent");
+  }
+};
+
+// src/lib/Tracking/Referrer.ts
+var Referrer = class _Referrer {
+  static storageId = "_coin_referrer";
+  local;
+  session;
+  constructor() {
+    this.session = this.getFromSession() ?? document.referrer;
+    sessionStorage.setItem(_Referrer.storageId, this.session);
+    this.local = this.getFromLocal() ?? document.referrer;
+    localStorage.setItem(_Referrer.storageId, this.local);
+  }
+  toJson() {
+    if (this.local && this.local.length > 0 || this.session && this.session.length > 0) {
+      return {
+        local: this.local,
+        session: this.session
+      };
+    }
+  }
+  getFromLocal() {
+    const value = localStorage.getItem(_Referrer.storageId);
+    if (value !== null && value.length > 0) {
+      return value;
+    }
+  }
+  getFromSession() {
+    const value = sessionStorage.getItem(_Referrer.storageId);
+    if (value !== null && value.length > 0) {
+      return value;
+    }
+  }
+};
+
+// src/lib/Tracking/Snapchat/BaseEvent.ts
+import { delay as delay8 } from "@ariestools/sdk";
+var SnapchatBaseEvent = class {
+  name;
+  constructor(name) {
+    this.name = name;
+  }
+  async send(_data) {
+    await delay8(0);
+  }
+};
+
+// src/lib/Tracking/Snapchat/Snaptr.ts
+import { delay as delay9 } from "@ariestools/sdk";
+var SnapTr = class {
+  static instance;
+  static getSnapTr() {
+    if (globalThis.snaptr) {
+      return globalThis.snaptr;
+    }
+    console.warn("Missing snaptr");
+  }
+  static async track(event, data) {
+    this.getSnapTr()?.("track", event, data);
+    await delay9(0);
+  }
+};
+
+// src/lib/Tracking/Snapchat/StandardEvent.ts
+var SnapchatStandardEvent = class extends SnapchatBaseEvent {
+  async send(data) {
+    await SnapTr.track(this.name, data);
+  }
+};
+
+// src/lib/Tracking/Snapchat/StandardEvents.ts
+var SnapchatStandardEvents = class {
+  achievementUnlocked() {
+    return new SnapchatStandardEvent("ACHIEVEMENT_UNLOCKED");
+  }
+  adClick() {
+    return new SnapchatStandardEvent("AD_CLICK");
+  }
+  adView() {
+    return new SnapchatStandardEvent("AD_VIEW");
+  }
+  addBilling() {
+    return new SnapchatStandardEvent("ADD_BILLING");
+  }
+  addCart() {
+    return new SnapchatStandardEvent("ADD_CART");
+  }
+  addToWishlist() {
+    return new SnapchatStandardEvent("ADD_TO_WISHLIST");
+  }
+  completeTutorial() {
+    return new SnapchatStandardEvent("COMPLETE_TUTORIAL");
+  }
+  custom1() {
+    return new SnapchatStandardEvent("CUSTOM_EVENT_1");
+  }
+  custom2() {
+    return new SnapchatStandardEvent("CUSTOM_EVENT_2");
+  }
+  custom3() {
+    return new SnapchatStandardEvent("CUSTOM_EVENT_3");
+  }
+  custom4() {
+    return new SnapchatStandardEvent("CUSTOM_EVENT_4");
+  }
+  custom5() {
+    return new SnapchatStandardEvent("CUSTOM_EVENT_5");
+  }
+  invite() {
+    return new SnapchatStandardEvent("INVITE");
+  }
+  listView() {
+    return new SnapchatStandardEvent("LIST_VIEW");
+  }
+  login() {
+    return new SnapchatStandardEvent("LOGIN");
+  }
+  openApp() {
+    return new SnapchatStandardEvent("OPEN_APP");
+  }
+  pageView() {
+    return new SnapchatStandardEvent("PAGE_VIEW");
+  }
+  purchase() {
+    return new SnapchatStandardEvent("PURCHASE");
+  }
+  rate() {
+    return new SnapchatStandardEvent("RATE");
+  }
+  reserve() {
+    return new SnapchatStandardEvent("RESERVE");
+  }
+  save() {
+    return new SnapchatStandardEvent("SAVE");
+  }
+  search() {
+    return new SnapchatStandardEvent("SEARCH");
+  }
+  share() {
+    return new SnapchatStandardEvent("SHARE");
+  }
+  signUp() {
+    return new SnapchatStandardEvent("SIGN_UP");
+  }
+  spentCredits() {
+    return new SnapchatStandardEvent("SPENT_CREDITS");
+  }
+  startCheckout() {
+    return new SnapchatStandardEvent("START_CHECKOUT");
+  }
+  startTrial() {
+    return new SnapchatStandardEvent("START_TRIAL");
+  }
+  subscribe() {
+    return new SnapchatStandardEvent("SUBSCRIBE");
+  }
+  viewContent() {
+    return new SnapchatStandardEvent("VIEW_CONTENT");
+  }
+};
+
+// src/lib/Tracking/Tapjoy/ef.ts
+var EF = class _EF {
+  static instance;
+  static getEF() {
+    if (globalThis.EF) {
+      return globalThis.EF;
+    }
+    console.warn("Missing EF");
+  }
+  static init() {
+    try {
+      _EF.instance = new _EF();
+    } catch (ex) {
+      console.error(`EF.init: ${String(ex)}`);
+    }
+  }
+  track(event, data) {
+    switch (event) {
+      case "Purchase": {
+        this.sendConversion(data);
+        break;
+      }
+      default: {
+        console.error(`EF.track: missing event ${event}`);
+      }
+    }
+  }
+  sendConversion(data) {
+    try {
+      const ef = _EF.getEF();
+      ef?.conversion({ ...data });
+    } catch (ex) {
+      console.error(`EF.conversion: ${String(ex)}`);
+    }
+  }
+};
+
+// src/lib/Tracking/Tapjoy/StandardEvent.ts
+import { delay as delay11 } from "@ariestools/sdk";
+
+// src/lib/Tracking/Tapjoy/BaseEvent.ts
+import { assertEx as assertEx4, delay as delay10 } from "@ariestools/sdk";
+var TapjoyBaseEvent = class {
+  ef;
+  name;
+  constructor(name) {
+    this.name = name;
+    this.ef = assertEx4(EF.instance, () => "Missing Tapjoy Eventflow");
+  }
+  async send(_data) {
+    await delay10(0);
+  }
+};
+
+// src/lib/Tracking/Tapjoy/StandardEvent.ts
+var TapjoyStandardEvent = class extends TapjoyBaseEvent {
+  async send(data) {
+    this.ef.track(this.name, data);
+    await delay11(0);
+  }
+};
+
+// src/lib/Tracking/Tapjoy/StandardEvents.ts
+var TapjoyStandardEvents = class {
+  accountCreated() {
+    return new TapjoyStandardEvent("Conversion");
+  }
+};
+
+// src/lib/Tracking/Tiktok/BaseEvent.ts
+import { assertEx as assertEx5, delay as delay12 } from "@ariestools/sdk";
+
+// src/lib/Tracking/Tiktok/Ttq.ts
+var Ttq = class _Ttq {
+  static instance;
+  static getTtq() {
+    if (globalThis.ttq) {
+      return globalThis.ttq;
+    }
+    console.warn("Missing ttq");
+  }
+  static init(pixelId) {
+    try {
+      this.instance = new _Ttq();
+      this.getTtq()?.load(pixelId);
+      this.page();
+    } catch (ex) {
+      console.error(`Ttq.init: ${String(ex)}`);
+    }
+  }
+  static page() {
+    try {
+      this.getTtq()?.page();
+    } catch (ex) {
+      console.error(`Ttq.page: ${String(ex)}`);
+    }
+  }
+  track(event, data) {
+    try {
+      _Ttq.getTtq()?.track(event, { ...data });
+    } catch (ex) {
+      console.error(`Ttq.track: ${String(ex)}`);
+    }
+  }
+};
+
+// src/lib/Tracking/Tiktok/BaseEvent.ts
+var TiktokBaseEvent = class {
+  name;
+  ttq;
+  constructor(name) {
+    this.name = name;
+    this.ttq = assertEx5(Ttq.instance, () => "Missing Ttq");
+  }
+  async send(_data) {
+    await delay12(0);
+  }
+};
+
+// src/lib/Tracking/Tiktok/CustomEvent.ts
+import { delay as delay13 } from "@ariestools/sdk";
+var TiktokCustomEvent = class extends TiktokBaseEvent {
+  async send(data) {
+    this.ttq.track(this.name, data);
+    await delay13(0);
+  }
+};
+
+// src/lib/Tracking/Tiktok/StandardEvent.ts
+import { delay as delay14 } from "@ariestools/sdk";
+var TiktokStandardEvent = class extends TiktokBaseEvent {
+  async send(data) {
+    this.ttq.track(this.name, data);
+    await delay14(0);
+  }
+};
+
+// src/lib/Tracking/Tiktok/StandardEvents.ts
+var TiktokStandardEvents = class {
+  addBilling() {
+    return new TiktokStandardEvent("AddBilling");
+  }
+  addToCart() {
+    return new TiktokStandardEvent("AddToCart");
+  }
+  checkout() {
+    return new TiktokStandardEvent("Checkout");
+  }
+  clickButton() {
+    return new TiktokStandardEvent("ClickButton");
+  }
+  clickForm() {
+    return new TiktokStandardEvent("ClickForm");
+  }
+  clickInDownloadPage() {
+    return new TiktokStandardEvent("ClickInDownloadPage");
+  }
+  clickToDownload() {
+    return new TiktokStandardEvent("ClickToDownload");
+  }
+  pageView() {
+    return new TiktokStandardEvent("Browse");
+  }
+  purchase() {
+    return new TiktokStandardEvent("Purchase");
+  }
+  registration() {
+    return new TiktokStandardEvent("Registration");
+  }
+  search() {
+    return new TiktokStandardEvent("Search");
+  }
+  startCheckout() {
+    return new TiktokStandardEvent("StartCheckout");
+  }
+  submitForm() {
+    return new TiktokStandardEvent("SubmitForm");
+  }
+  viewContent() {
+    return new TiktokStandardEvent("ViewContent");
+  }
+  viewDownloadPage() {
+    return new TiktokStandardEvent("ViewDownloadPage");
+  }
+  viewForm() {
+    return new TiktokStandardEvent("ViewForm");
+  }
+};
+
+// src/lib/Tracking/Xy/BaseEvent.ts
+import { toSafeJsonObject as toSafeJsonObject6 } from "@ariestools/sdk";
+import { XyPixel } from "@xylabs/pixel";
+var XyBaseEvent = class {
+  name;
+  constructor(name) {
+    this.name = name;
+  }
+  async send(fields, eventId) {
+    await XyPixel.instance.send(this.name, toSafeJsonObject6(fields, void 0, 10), eventId);
+  }
+};
+
+// src/lib/Tracking/Xy/CustomEvent.ts
+var XyCustomEvent = class extends XyBaseEvent {
+};
+
+// src/lib/Tracking/Xy/UserEventHandler.ts
+var XyUserEventHandler = class {
+  async funnelStarted(data) {
+    const event = new XyCustomEvent("FunnelStarted");
+    return await event.send(data);
+  }
+  async purchase(data) {
+    const event = new XyCustomEvent("TestStarted");
+    return await event.send(data);
+  }
+  async testStarted(data) {
+    const event = new XyCustomEvent("TestStarted");
+    return await event.send(data);
+  }
+  async userClick(data) {
+    const event = new XyCustomEvent("UserClick");
+    return await event.send(data);
+  }
+  async viewContent(data) {
+    const event = new XyCustomEvent("ViewContent");
+    return await event.send(data);
+  }
+};
+
+// src/lib/Tracking/XyoUserEventHandler.ts
+import { UserEventHandler } from "@xylabs/pixel";
+var XyoUserEventHandler = class _XyoUserEventHandler extends UserEventHandler {
+  static instance;
+  handlers;
+  constructor(handlers = []) {
+    super();
+    this.handlers = handlers ?? [new FacebookUserEventHandler(), new GoogleUserEventHandler()];
+  }
+  static get() {
+    this.instance = this.instance ?? new _XyoUserEventHandler();
+    return this.instance;
+  }
+  async funnelStarted(data) {
+    await Promise.allSettled(this.handlers.map((handler) => Promise.resolve(handler.funnelStarted(data))));
+  }
+  async testStarted(data) {
+    await Promise.allSettled(this.handlers.map((handler) => Promise.resolve(handler.testStarted(data))));
+  }
+  async userClick(data) {
+    await Promise.allSettled(this.handlers.map((handler) => Promise.resolve(handler.userClick(data))));
+  }
+  async viewContent(data) {
+    await Promise.allSettled(this.handlers.map((handler) => Promise.resolve(handler.viewContent(data))));
+  }
+};
+
+// src/contexts/UserEvents/Provider.tsx
+import { jsx } from "react/jsx-runtime";
+var UserEventsProvider = ({ userEvents, children }) => {
+  const value = useMemo(() => ({ userEvents: userEvents ?? XyoUserEventHandler.get() }), [userEvents]);
+  return /* @__PURE__ */ jsx(UserEventsContext, { value, children });
+};
+
+// src/hooks/useUserEvents.ts
+import { use } from "react";
+function useUserEvents(required = "warn") {
+  const { userEvents } = use(UserEventsContext);
+  if (!userEvents) {
+    if (required === "warn") {
+      console.warn("No UserEvents instance found in context");
+    } else if (required === true) {
+      throw new Error("No UserEvents instance found in context");
+    }
+  }
+  return userEvents;
+}
+export {
+  DebugUserEventsContext,
+  DripBaseEvent,
+  DripCustomEvent,
+  DripStandardEvents,
+  EF,
+  FacebookBaseEvent,
+  FacebookCustomEvent,
+  FacebookStandardEvent,
+  FacebookStandardEvents,
+  FacebookUserEventHandler,
+  Fbq,
+  GoogleBaseEvent,
+  GoogleCustomEvent,
+  GoogleStandardEvent,
+  GoogleStandardEvents,
+  GoogleUserEventHandler,
+  Gtag,
+  Gtm,
+  MixpanelBaseEvent,
+  MixpanelCustomEvent,
+  MixpanelPageViewEvent,
+  MixpanelUserEventHandler,
+  Rdt,
+  RedditBaseEvent,
+  RedditCustomEvent,
+  RedditStandardEvent,
+  RedditStandardEvents,
+  Referrer,
+  SnapTr,
+  SnapchatBaseEvent,
+  SnapchatStandardEvent,
+  SnapchatStandardEvents,
+  TapjoyStandardEvent,
+  TapjoyStandardEvents,
+  TiktokBaseEvent,
+  TiktokCustomEvent,
+  TiktokStandardEvent,
+  TiktokStandardEvents,
+  Ttq,
+  UserEventsContext,
+  UserEventsProvider,
+  XyBaseEvent,
+  XyCustomEvent,
+  XyUserEventHandler,
+  XyoUserEventHandler,
+  useUserEvents
+};