shopkit-analytics 1.0.0

package/dist/events/index.js

@@ -0,0 +1,2131 @@
+"use client";
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/events/publisher.ts
+function publishEvent(event) {
+  try {
+    eventPublisher.publish(event);
+  } catch (error) {
+    console.error("Error in publishEvent helper:", error);
+  }
+}
+var EventPublisher, eventPublisher;
+var init_publisher = __esm({
+  "src/events/publisher.ts"() {
+    "use strict";
+    EventPublisher = class _EventPublisher {
+      /**
+       * Private constructor to enforce singleton pattern
+       */
+      constructor() {
+        this.subscribers = [];
+      }
+      /**
+       * Get the singleton instance of EventPublisher
+       */
+      static getInstance() {
+        if (!_EventPublisher.instance) {
+          _EventPublisher.instance = new _EventPublisher();
+        }
+        return _EventPublisher.instance;
+      }
+      /**
+       * Subscribe to events
+       * @param callback Function to be called when an event is published
+       * @returns Unsubscribe function
+       */
+      subscribe(callback) {
+        this.subscribers.push(callback);
+        return () => {
+          this.subscribers = this.subscribers.filter(
+            (subscriber) => subscriber !== callback
+          );
+        };
+      }
+      /**
+       * Publish an event to all subscribers
+       * @param event The event to publish
+       */
+      publish(event) {
+        try {
+          console.log("EventPublisher: Received event", {
+            type: event.type,
+            data: event
+          });
+          const eventWithTimestamp = !event.timestamp ? { ...event, timestamp: Date.now() } : event;
+          console.log("EventPublisher: Number of subscribers:", this.subscribers.length);
+          for (const subscriber of this.subscribers) {
+            try {
+              console.log("EventPublisher: Notifying subscriber");
+              subscriber(eventWithTimestamp);
+              console.log("EventPublisher: Subscriber notified successfully");
+            } catch (error) {
+              console.error("EventPublisher: Error in subscriber:", error);
+            }
+          }
+          console.log("EventPublisher: Event processing completed");
+        } catch (error) {
+          console.error("Error publishing event:", error, event);
+        }
+      }
+    };
+    eventPublisher = EventPublisher.getInstance();
+  }
+});
+
+// src/events/subscriber.ts
+var subscriber_exports = {};
+__export(subscriber_exports, {
+  eventSubscriber: () => eventSubscriber
+});
+var EventSubscriber, eventSubscriber;
+var init_subscriber = __esm({
+  "src/events/subscriber.ts"() {
+    "use strict";
+    init_publisher();
+    EventSubscriber = class _EventSubscriber {
+      /**
+       * Private constructor to enforce singleton pattern
+       */
+      constructor() {
+        this.adapters = [];
+        this.initialized = false;
+        this.eventQueue = [];
+        this.unsubscribe = null;
+      }
+      /**
+       * Get the singleton instance of EventSubscriber
+       */
+      static getInstance() {
+        if (!_EventSubscriber.instance) {
+          _EventSubscriber.instance = new _EventSubscriber();
+        }
+        return _EventSubscriber.instance;
+      }
+      /**
+       * Register a tracking adapter
+       * @param adapter The tracking adapter to register
+       */
+      registerAdapter(adapter) {
+        const existingAdapter = this.adapters.find((a) => a.name === adapter.name);
+        if (existingAdapter) {
+          console.warn(
+            `Tracking adapter with name "${adapter.name}" is already registered. Skipping.`
+          );
+          return;
+        }
+        this.adapters.push(adapter);
+        if (this.initialized) {
+          this.initializeAdapter(adapter).catch((error) => {
+            console.error(`Failed to initialize adapter "${adapter.name}":`, error);
+          });
+        }
+      }
+      /**
+       * Unregister a tracking adapter by name
+       * @param adapterName The name of the adapter to unregister
+       */
+      unregisterAdapter(adapterName) {
+        this.adapters = this.adapters.filter(
+          (adapter) => adapter.name !== adapterName
+        );
+      }
+      /**
+       * Initialize all registered adapters
+       */
+      async initialize() {
+        console.log("Initializing EventSubscriber...");
+        if (this.initialized) {
+          console.log("EventSubscriber already initialized");
+          return;
+        }
+        this.unsubscribe = eventPublisher.subscribe(this.handleEvent.bind(this));
+        console.log("Subscribed to event publisher");
+        console.log(`Initializing ${this.adapters.length} adapters...`);
+        await Promise.all(
+          this.adapters.map((adapter) => this.initializeAdapter(adapter))
+        );
+        this.initialized = true;
+        console.log("EventSubscriber initialization complete");
+        this.processEventQueue();
+      }
+      /**
+       * Initialize a single adapter
+       * @param adapter The adapter to initialize
+       */
+      async initializeAdapter(adapter) {
+        try {
+          await adapter.initialize();
+          console.log(
+            `Tracking adapter "${adapter.name}" initialized successfully.`
+          );
+        } catch (error) {
+          console.error(`Failed to initialize adapter "${adapter.name}":`, error);
+        }
+      }
+      /**
+       * Handle an event by forwarding it to all enabled adapters
+       * @param event The event to handle
+       */
+      handleEvent(event) {
+        console.log("Handling event:", event.type);
+        if (!this.initialized) {
+          console.log("Subscriber not initialized, queueing event");
+          this.eventQueue.push(event);
+          return;
+        }
+        for (const adapter of this.adapters) {
+          if (adapter.isEnabled()) {
+            console.log(`Forwarding event to adapter: ${adapter.name}`);
+            adapter.trackEvent(event).catch((error) => {
+              console.error(
+                `Error tracking event in adapter "${adapter.name}":`,
+                error
+              );
+            });
+          } else {
+            console.log(`Adapter ${adapter.name} is disabled, skipping`);
+          }
+        }
+      }
+      /**
+       * Process any events that were queued before initialization
+       */
+      processEventQueue() {
+        if (this.eventQueue.length === 0) {
+          return;
+        }
+        console.log(`Processing ${this.eventQueue.length} queued events.`);
+        for (const event of this.eventQueue) {
+          this.handleEvent(event);
+        }
+        this.eventQueue = [];
+      }
+      /**
+       * Shutdown the subscriber and all adapters
+       */
+      shutdown() {
+        if (this.unsubscribe) {
+          this.unsubscribe();
+          this.unsubscribe = null;
+        }
+        this.initialized = false;
+        this.eventQueue = [];
+      }
+      /**
+       * Get all registered adapters
+       */
+      getAdapters() {
+        return [...this.adapters];
+      }
+    };
+    eventSubscriber = EventSubscriber.getInstance();
+  }
+});
+
+// src/events/index.ts
+var events_exports = {};
+__export(events_exports, {
+  DEFAULT_CURRENCY: () => DEFAULT_CURRENCY,
+  EventNames: () => EventNames,
+  EventType: () => EventType,
+  HARDCODED_HANDLE: () => HARDCODED_HANDLE,
+  eventPublisher: () => eventPublisher,
+  eventSubscriber: () => eventSubscriber,
+  initTracking: () => initTracking,
+  initializeEventTracking: () => initializeEventTracking,
+  publishEvent: () => publishEvent
+});
+module.exports = __toCommonJS(events_exports);
+
+// src/types.ts
+var EventType = /* @__PURE__ */ ((EventType2) => {
+  EventType2["PRODUCT_VIEW"] = "product_view";
+  EventType2["STARTED_ORDER"] = "started_order";
+  EventType2["PAGE_VIEW"] = "page_view";
+  EventType2["BUTTON_CLICK"] = "button_click";
+  EventType2["FORM_SUBMISSION"] = "form_submission";
+  EventType2["VIEW_ITEM"] = "view_item";
+  EventType2["VIEWED_PRODUCT"] = "viewed_product";
+  EventType2["CHECKOUT_PAYMENT"] = "checkout_payment";
+  EventType2["COLLECTION_VIEW"] = "collection_view";
+  EventType2["ADD_TO_CART"] = "add_to_cart";
+  EventType2["REMOVE_FROM_CART"] = "remove_from_cart";
+  EventType2["CHECKOUT_STARTED"] = "checkout_started";
+  EventType2["CHECKOUT_COMPLETED"] = "checkout_completed";
+  EventType2["SEARCH"] = "search";
+  EventType2["CART_PAGE_LAND"] = "cart_page_land";
+  EventType2["CLOSE_CART"] = "close_cart";
+  EventType2["QUANTITY_CHANGE"] = "quantity_change";
+  EventType2["FILTER_APPLIED"] = "filter_applied";
+  EventType2["NEWSLETTER_SUBSCRIPTION"] = "newsletter_subscription";
+  EventType2["USER_SIGNUP"] = "user_signup";
+  EventType2["USER_LOGIN"] = "user_login";
+  EventType2["CUSTOM"] = "custom";
+  EventType2["USER_ENGAGEMENT"] = "user_engagement";
+  EventType2["SESSION_START"] = "session_start";
+  EventType2["FIRST_VISIT"] = "first_visit";
+  EventType2["SCROLL"] = "scroll";
+  EventType2["FORM_START"] = "form_start";
+  EventType2["ADD_PAYMENT_INFO"] = "add_payment_info";
+  EventType2["CART_VIEWED"] = "cart_viewed";
+  EventType2["PAGES_SCREENS_PER_SESSION"] = "pages_screens_per_session";
+  EventType2["VIEW_CONTENT"] = "view_content";
+  EventType2["PURCHASE"] = "purchase";
+  EventType2["VIEW_SEARCH_RESULTS"] = "view_search_results";
+  EventType2["ORDER_PLACED"] = "order_placed";
+  EventType2["BEGIN_CHECKOUT"] = "begin_checkout";
+  EventType2["ITEM_PURCHASED"] = "item_purchased";
+  EventType2["UPDATE_CART"] = "update_cart";
+  EventType2["CUSTOMER_REGISTERED"] = "customer_registered";
+  EventType2["CUSTOMER_LOGGED_IN"] = "customer_logged_in";
+  EventType2["SHOPIFY_CHECKOUT_UPDATED"] = "shopify_checkout_updated";
+  EventType2["SHOPIFY_ABANDONED_CHECKOUT"] = "shopify_abandoned_checkout";
+  EventType2["SHOPIFY_ORDER_FULFILLED"] = "shopify_order_fulfilled";
+  EventType2["SHOPIFY_CHECKOUT_STARTED"] = "shopify_checkout_started";
+  EventType2["SHOPIFY_ADD_TO_CART"] = "shopify_add_to_cart";
+  EventType2["SHOPIFY_REMOVED_FROM_CART"] = "shopify_removed_from_cart";
+  EventType2["SHOPIFY_UPDATE_CART"] = "shopify_update_cart";
+  EventType2["SPINFORM_RESULT"] = "spinform_result";
+  EventType2["COUPON_COPIED"] = "coupon_copied";
+  EventType2["STARTED_CHECKOUT_GK"] = "started_checkout_gk";
+  EventType2["MOBILE_ADDED_GK"] = "mobile_added_gk";
+  EventType2["ADDRESS_SELECTED_GK"] = "address_selected_gk";
+  EventType2["ADDRESS_COMPLETED_GK"] = "address_completed_gk";
+  EventType2["PAYMENT_METHOD_SELECTED_GK"] = "payment_method_selected_gk";
+  EventType2["PAYMENT_COMPLETED_GK"] = "payment_completed_gk";
+  EventType2["ORDER_SUCCESS"] = "order_success";
+  EventType2["ORDER_COMPLETED"] = "order_completed";
+  EventType2["PIN_CODE_ADDED_GK"] = "pin_code_added_gk";
+  EventType2["ADDRESS_ADDED_GK"] = "address_added_gk";
+  EventType2["KP_MP_PHONE_NUMBER_LOGGED_IN"] = "kp_mp_phone_number_logged_in";
+  EventType2["KP_PHONE_NUMBER_LOGGED_IN"] = "kp_phone_number_logged_in";
+  EventType2["KP_MP_SHOPIFY_LOGGED_IN"] = "kp_mp_shopify_logged_in";
+  EventType2["KP_MP_SUCCESSFULLY_LOGGED_OUT"] = "kp_mp_successfully_logged_out";
+  EventType2["KP_WHATSAPP_LOGGED_IN"] = "kp_whatsapp_logged_in";
+  EventType2["KP_MP_TRUECALLER_LOGGED_IN"] = "kp_mp_truecaller_logged_in";
+  EventType2["KP_MP_WHATSAPP_LOGGED_IN"] = "kp_mp_whatsapp_logged_in";
+  EventType2["KP_TRUECALLER_LOGGED_IN"] = "kp_truecaller_logged_in";
+  EventType2["KP_SHOPIFY_LOGGED_IN"] = "kp_shopify_logged_in";
+  EventType2["KP_SUCCESSFULLY_LOGGED_OUT"] = "kp_successfully_logged_out";
+  return EventType2;
+})(EventType || {});
+
+// src/events/index.ts
+init_publisher();
+init_subscriber();
+
+// src/logger/index.ts
+var import_pino = __toESM(require("pino"));
+var NoOpLogger = class _NoOpLogger {
+  trace() {
+  }
+  debug() {
+  }
+  info() {
+  }
+  warn() {
+  }
+  error() {
+  }
+  fatal() {
+  }
+  child() {
+    return new _NoOpLogger();
+  }
+};
+var PinoLogger = class _PinoLogger {
+  constructor(logger2) {
+    this.logger = logger2;
+  }
+  trace(message, ...args) {
+    this.logger.trace({ args }, message);
+  }
+  debug(message, ...args) {
+    this.logger.debug({ args }, message);
+  }
+  info(message, ...args) {
+    this.logger.info({ args }, message);
+  }
+  warn(message, ...args) {
+    this.logger.warn({ args }, message);
+  }
+  error(message, error, ...args) {
+    this.logger.error({ error, args }, message);
+  }
+  fatal(message, error, ...args) {
+    this.logger.fatal({ error, args }, message);
+  }
+  child(bindings) {
+    return new _PinoLogger(this.logger.child(bindings));
+  }
+};
+function createLogger(config = {}) {
+  const {
+    level = "info",
+    enabled = true,
+    name = "@shopkit/analytics",
+    prettyPrint = false,
+    redact = []
+  } = config;
+  if (!enabled) {
+    return new NoOpLogger();
+  }
+  const pinoConfig = {
+    name,
+    level,
+    redact,
+    browser: {
+      asObject: true,
+      serialize: true,
+      write: {
+        trace: (o) => console.trace(formatBrowserLog(o)),
+        debug: (o) => console.debug(formatBrowserLog(o)),
+        info: (o) => console.info(formatBrowserLog(o)),
+        warn: (o) => console.warn(formatBrowserLog(o)),
+        error: (o) => console.error(formatBrowserLog(o)),
+        fatal: (o) => console.error(formatBrowserLog(o))
+      }
+    }
+  };
+  if (prettyPrint && typeof window === "undefined") {
+    pinoConfig.transport = {
+      target: "pino-pretty",
+      options: {
+        colorize: true,
+        translateTime: "HH:MM:ss Z",
+        ignore: "pid,hostname"
+      }
+    };
+  }
+  const pinoLogger = (0, import_pino.default)(pinoConfig);
+  return new PinoLogger(pinoLogger);
+}
+function formatBrowserLog(logObj) {
+  const { level, time, msg, name, args, error, ...rest } = logObj;
+  let message = `[${name}] ${msg}`;
+  if (args && args.length > 0) {
+    message += ` ${args.map(
+      (arg) => typeof arg === "object" ? JSON.stringify(arg) : String(arg)
+    ).join(" ")}`;
+  }
+  if (error) {
+    message += ` Error: ${error.message}`;
+    if (error.stack) {
+      message += `
+${error.stack}`;
+    }
+  }
+  if (Object.keys(rest).length > 0) {
+    message += ` ${JSON.stringify(rest)}`;
+  }
+  return message;
+}
+var logger = createLogger({
+  enabled: true,
+  level: "info",
+  prettyPrint: false
+});
+function createAdapterLogger(adapterName, config = {}) {
+  const baseLogger = createLogger(config);
+  return baseLogger.child({ adapter: adapterName });
+}
+
+// src/adapters/base-adapter.ts
+var BaseAdapter = class {
+  /**
+   * Constructor
+   * @param config Configuration for the adapter
+   */
+  constructor(config = {}) {
+    /**
+     * Whether the adapter has been initialized
+     */
+    this.initialized = false;
+    this.config = config;
+    const loggerConfig = {
+      enabled: config.enableDebugLogs ?? true,
+      level: config.logLevel ?? "info",
+      name: "@shopkit/analytics"
+    };
+    this.logger = createAdapterLogger("BaseAdapter", loggerConfig);
+  }
+  /**
+   * Initialize logger with proper adapter name
+   * Should be called by subclasses after name is available
+   */
+  initializeLogger() {
+    const loggerConfig = {
+      enabled: this.config.enableDebugLogs ?? true,
+      level: this.config.logLevel ?? "info",
+      name: "@shopkit/analytics"
+    };
+    this.logger = createAdapterLogger(this.name, loggerConfig);
+  }
+  /**
+   * Check if the adapter is enabled
+   */
+  isEnabled() {
+    return this.initialized;
+  }
+  /**
+   * Get a configuration value
+   * @param key The configuration key
+   * @param defaultValue The default value if the key is not found
+   */
+  getConfig(key, defaultValue) {
+    return key in this.config ? this.config[key] : defaultValue;
+  }
+  /**
+   * Get affiliate parameters from session storage or custom implementation
+   * Override this method to provide your own affiliate tracking implementation
+   * @returns Affiliate parameters or null if not available
+   */
+  getAffiliateParams() {
+    return null;
+  }
+  /**
+   * Enhance event parameters with affiliate data
+   * @param params The original parameters
+   * @returns Parameters enhanced with affiliate data
+   */
+  enhanceWithAffiliateParams(params) {
+    const affiliateParams = this.getAffiliateParams();
+    if (!affiliateParams) return params;
+    return {
+      ...params,
+      // Add affiliate parameters
+      ...affiliateParams
+    };
+  }
+};
+
+// src/adapters/pixel-adapter.ts
+var PixelAdapter = class extends BaseAdapter {
+  constructor(config) {
+    super(config);
+    this.name = "FacebookPixel";
+    this.initializeLogger();
+  }
+  /**
+   * Initialize the Facebook Pixel
+   */
+  async initialize() {
+    if (this.initialized) {
+      this.logger.debug("Already initialized");
+      return;
+    }
+    if (typeof window === "undefined") {
+      this.logger.debug("Skipping initialization on server");
+      return;
+    }
+    if (!window.fbq) {
+      this.logger.warn(
+        "Facebook Pixel fbq not found. Make sure the script is loaded."
+      );
+      return;
+    }
+    const pixelId = this.getConfig("pixelId");
+    this.logger.info("Successfully initialized", { pixelId: "***" });
+    this.initialized = true;
+  }
+  /**
+   * Track an event with Facebook Pixel
+   * @param event The event to track
+   */
+  async trackEvent(event) {
+    if (!this.initialized || typeof window === "undefined" || !window.fbq) {
+      this.logger.warn(
+        "Cannot track event, adapter not initialized or fbq not available",
+        {
+          eventType: event.type,
+          initialized: this.initialized,
+          hasWindow: typeof window !== "undefined",
+          hasFbq: !!window?.fbq
+        }
+      );
+      return;
+    }
+    this.logger.debug("Tracking event", { eventType: event.type });
+    switch (event.type) {
+      case "page_view" /* PAGE_VIEW */:
+        this.trackPageView(event);
+        break;
+      case "view_content" /* VIEW_CONTENT */:
+        this.trackViewContent(event);
+        break;
+      case "product_view" /* PRODUCT_VIEW */:
+        this.trackProductView(event);
+        break;
+      case "add_to_cart" /* ADD_TO_CART */:
+        this.trackAddToCart(event);
+        break;
+      case "checkout_started" /* CHECKOUT_STARTED */:
+        this.trackCheckoutStarted(event);
+        break;
+      case "checkout_completed" /* CHECKOUT_COMPLETED */:
+        this.trackCheckoutCompleted(event);
+        break;
+      case "purchase" /* PURCHASE */:
+        this.trackPurchase(event);
+        break;
+      case "add_payment_info" /* ADD_PAYMENT_INFO */:
+        this.trackAddPaymentInfo(event);
+        break;
+      case "search" /* SEARCH */:
+        this.trackSearch(event);
+        break;
+      default:
+        this.logger.debug("Unhandled event type", { eventType: event.type });
+        break;
+    }
+  }
+  /**
+   * Track a page view event
+   * @param event The page view event
+   */
+  trackPageView(event) {
+    const params = this.enhanceWithAffiliateParams({});
+    window.fbq?.("track", "PageView", params);
+    this.logger.debug("PageView event tracked", { params });
+  }
+  /**
+   * Track a product view event
+   * @param event The product view event
+   */
+  trackProductView(event) {
+    const params = {
+      content_type: "product_group",
+      content_ids: [event.productId],
+      content_name: event.productName,
+      content_category: event.category,
+      value: event.price,
+      currency: event.currency || "INR"
+    };
+    window.fbq?.(
+      "track",
+      "ViewContent",
+      this.enhanceWithAffiliateParams(params)
+    );
+  }
+  /**
+   * Track an add to cart event
+   * @param event The add to cart event
+   */
+  trackAddToCart(event) {
+    const params = {
+      content_type: "product_group",
+      content_ids: [event.productId],
+      content_name: event.productName,
+      value: event.price,
+      currency: event.currency || "INR"
+    };
+    const enhancedParams = this.enhanceWithAffiliateParams(params);
+    window.fbq?.("track", "AddToCart", enhancedParams);
+    this.logger.debug("AddToCart event tracked", { params: enhancedParams });
+  }
+  /**
+   * Track a checkout started event
+   * @param event The checkout started event
+   */
+  trackCheckoutStarted(event) {
+    const params = {
+      content_ids: event.items.map((item) => item.productId),
+      content_type: "product_group",
+      value: event.cartValue,
+      currency: event.currency || "INR",
+      num_items: event.itemCount,
+      contents: event.items.map((item) => ({
+        id: item.productId,
+        quantity: item.quantity,
+        item_price: item.price
+      }))
+    };
+    window.fbq?.(
+      "track",
+      "InitiateCheckout",
+      this.enhanceWithAffiliateParams(params)
+    );
+  }
+  /**
+   * Track a checkout completed event
+   * @param event The checkout completed event
+   */
+  trackCheckoutCompleted(event) {
+    const params = {
+      value: event.cartValue,
+      currency: event.currency || "INR",
+      content_type: "product_group",
+      content_ids: event.items.map((item) => item.productId),
+      num_items: event.itemCount,
+      contents: event.items.map((item) => ({
+        id: item.productId,
+        quantity: item.quantity,
+        item_price: item.price
+      }))
+    };
+    window.fbq?.("track", "Purchase", this.enhanceWithAffiliateParams(params));
+  }
+  /**
+   * Track a search event
+   * @param event The search event
+   */
+  trackSearch(event) {
+    const params = {
+      search_string: event.searchTerm,
+      content_category: "product",
+      content_ids: event.content_ids || []
+    };
+    window.fbq?.("track", "Search", this.enhanceWithAffiliateParams(params));
+  }
+  /**
+   * Track an add payment info event
+   * @param event The add payment info event
+   */
+  trackAddPaymentInfo(event) {
+    const params = {
+      value: event.cartValue,
+      currency: event.currency || "INR",
+      content_type: "product_group",
+      content_ids: event.items.map((item) => item.productId),
+      contents: event.items.map((item) => ({
+        id: item.productId,
+        quantity: item.quantity,
+        item_price: item.price
+      })),
+      payment_type: event.paymentType || ""
+    };
+    window.fbq?.(
+      "track",
+      "AddPaymentInfo",
+      this.enhanceWithAffiliateParams(params)
+    );
+  }
+  /**
+   * Track a view content event
+   * @param event The view content event
+   */
+  trackViewContent(event) {
+    const params = {
+      content_type: event.content_type || "product",
+      content_ids: event.content_ids || [],
+      content_name: event.content_name || "",
+      content_category: event.content_category || "",
+      value: event.value || 0,
+      currency: event.currency || "INR"
+    };
+    window.fbq?.(
+      "track",
+      "ViewContent",
+      this.enhanceWithAffiliateParams(params)
+    );
+  }
+  /**
+   * Track a purchase event
+   * @param event The purchase event
+   */
+  trackPurchase(event) {
+    const params = {
+      value: event.value,
+      currency: event.currency || "INR",
+      content_type: event.content_type || "product_group",
+      content_ids: event.content_ids || [],
+      num_items: event.num_items || 1,
+      contents: event.contents || []
+    };
+    window.fbq?.("track", "Purchase", this.enhanceWithAffiliateParams(params));
+  }
+  /**
+   * Convert an event to Facebook Pixel parameters
+   * @param event The event to convert
+   */
+  eventToParams(event) {
+    const { type, timestamp, ...params } = event;
+    return this.enhanceWithAffiliateParams(params);
+  }
+};
+
+// src/adapters/google-adapter.ts
+var GoogleAdapter = class extends BaseAdapter {
+  constructor(config) {
+    super(config);
+    this.name = "GoogleAnalytics";
+    this.initializeLogger();
+  }
+  /**
+   * Initialize Google Analytics adapter
+   * This just checks if gtag is available
+   */
+  isEnabled() {
+    const enabled = this.initialized && typeof window !== "undefined" && !!window.gtag;
+    this.logger.debug("Checking if enabled", {
+      initialized: this.initialized,
+      hasWindow: typeof window !== "undefined",
+      hasGtag: !!window?.gtag,
+      enabled
+    });
+    return enabled;
+  }
+  async initialize() {
+    this.logger.info("Starting initialization");
+    if (this.initialized) {
+      this.logger.debug("Already initialized");
+      return;
+    }
+    if (typeof window === "undefined") {
+      this.logger.debug("Skipping initialization on server");
+      return;
+    }
+    const measurementId = this.getConfig("measurementId");
+    this.logger.info("Using measurement ID", { measurementId });
+    if (!window.gtag) {
+      this.logger.warn(
+        "Google Analytics gtag not found. Make sure the script is loaded."
+      );
+      return;
+    }
+    this.initialized = true;
+    this.logger.info("Successfully initialized", { measurementId });
+  }
+  /**
+   * Track an event with Google Analytics
+   * @param event The event to track
+   */
+  async trackEvent(event) {
+    this.logger.debug("Attempting to track event", {
+      initialized: this.initialized,
+      hasWindow: typeof window !== "undefined",
+      hasGtag: !!window?.gtag,
+      eventType: event.type
+    });
+    if (!this.initialized || typeof window === "undefined" || !window.gtag) {
+      this.logger.warn(
+        "Cannot track event, adapter not initialized or gtag not available",
+        {
+          eventType: event.type,
+          initialized: this.initialized,
+          hasWindow: typeof window !== "undefined",
+          hasGtag: !!window?.gtag
+        }
+      );
+      return;
+    }
+    const measurementId = this.getConfig("measurementId");
+    this.logger.info("Tracking event", {
+      eventType: event.type,
+      measurementId
+    });
+    switch (event.type) {
+      case "page_view" /* PAGE_VIEW */:
+        this.trackPageView(event, measurementId);
+        break;
+      case "user_engagement" /* USER_ENGAGEMENT */:
+        this.trackUserEngagement();
+        break;
+      case "session_start" /* SESSION_START */:
+        this.trackSessionStart();
+        break;
+      case "first_visit" /* FIRST_VISIT */:
+        this.trackFirstVisit();
+        break;
+      case "view_item" /* VIEW_ITEM */:
+        this.trackViewItem(event);
+        break;
+      case "viewed_product" /* VIEWED_PRODUCT */:
+        this.trackViewedProduct(event);
+        break;
+      case "checkout_payment" /* CHECKOUT_PAYMENT */:
+        this.trackCheckoutPayment(event);
+        break;
+      case "scroll" /* SCROLL */:
+        this.trackScroll();
+        break;
+      case "add_to_cart" /* ADD_TO_CART */:
+      case "shopify_add_to_cart" /* SHOPIFY_ADD_TO_CART */:
+        this.trackAddToCart(event);
+        break;
+      case "form_start" /* FORM_START */:
+        this.trackFormStart();
+        break;
+      case "checkout_started" /* CHECKOUT_STARTED */:
+        this.trackCheckoutStarted(event);
+        break;
+      case "form_submission" /* FORM_SUBMISSION */:
+        this.trackFormSubmission(event);
+        break;
+      case "search" /* SEARCH */:
+        this.trackSearch(event);
+        break;
+      case "checkout_completed" /* CHECKOUT_COMPLETED */:
+        this.trackCheckoutCompleted(event);
+        break;
+      case "add_payment_info" /* ADD_PAYMENT_INFO */:
+        this.trackAddPaymentInfo(event);
+        break;
+      case "view_content" /* VIEW_CONTENT */:
+        this.trackViewContent(event);
+        break;
+      case "purchase" /* PURCHASE */:
+        this.trackPurchase(event);
+        break;
+      case "view_search_results" /* VIEW_SEARCH_RESULTS */:
+        this.trackViewSearchResults(event);
+        break;
+      case "order_placed" /* ORDER_PLACED */:
+        this.trackOrderPlaced(event);
+        break;
+      case "begin_checkout" /* BEGIN_CHECKOUT */:
+        this.trackBeginCheckout(event);
+        break;
+      case "custom" /* CUSTOM */:
+        this.trackCustomEvent(event);
+        break;
+      default: {
+        const params = this.eventToParams(event);
+        window.gtag(
+          "event",
+          event.type,
+          this.enhanceWithAffiliateParams(params)
+        );
+        break;
+      }
+    }
+  }
+  /**
+   * Track a page view event
+   * @param event The page view event
+   * @param measurementId The Google Analytics measurement ID
+   */
+  trackPageView(event, measurementId) {
+    const params = {
+      page_path: event.path,
+      page_title: event.title || document.title,
+      page_location: event.page_location || window.location.href,
+      page_referrer: event.page_referrer || document.referrer || void 0,
+      ga_session_id: event.ga_session_id || "",
+      ga_session_number: event.ga_session_number || "",
+      gclid: event.gclid || "",
+      engagement_time_msec: event.engagement_time_msec,
+      campaign: event.campaign || "",
+      campaign_id: event.campaign_id || "",
+      content: event.content || "",
+      debug_mode: event.debug_mode,
+      medium: event.medium || "",
+      source: event.page_source || "",
+      page_term: event.page_term || "",
+      ignore_referrer: event.ignore_referrer,
+      batch_ordering_id: event.batch_ordering_id || "",
+      batch_page_id: event.batch_page_id || "",
+      user_id: event.user_id,
+      user_properties: event.user_properties,
+      session_engaged: event.session_engaged
+    };
+    window.gtag?.(
+      "event",
+      "page_view",
+      this.enhanceWithAffiliateParams(params)
+    );
+  }
+  trackUserEngagement() {
+    const params = {
+      batch_ordering_id: "",
+      batch_page_id: "",
+      campaign: "",
+      ga_session_id: "",
+      ga_session_number: "",
+      gclid: "",
+      ignore_referrer: "",
+      medium: "",
+      page_location: window.location.href,
+      page_path: window.location.pathname,
+      page_referrer: document.referrer,
+      page_title: document.title,
+      source: "",
+      srsltid: "",
+      term: ""
+    };
+    window.gtag?.(
+      "event",
+      "user_engagement",
+      this.enhanceWithAffiliateParams(params)
+    );
+  }
+  trackSessionStart() {
+    const params = {
+      batch_ordering_id: "",
+      batch_page_id: "",
+      campaign: "",
+      campaign_id: "",
+      content: "",
+      ga_session_id: "",
+      ga_session_number: "",
+      gclid: "",
+      ignore_referrer: "",
+      medium: "",
+      page_location: window.location.href,
+      page_path: window.location.pathname,
+      page_referrer: document.referrer,
+      page_title: document.title,
+      source: "",
+      srsltid: "",
+      term: ""
+    };
+    window.gtag?.(
+      "event",
+      "session_start",
+      this.enhanceWithAffiliateParams(params)
+    );
+  }
+  trackFirstVisit() {
+    const params = {
+      batch_ordering_id: "",
+      batch_page_id: "",
+      campaign: "",
+      campaign_id: "",
+      content: "",
+      debug_mode: "",
+      engagement_time_msec: 0,
+      entrances: 1,
+      ga_session_id: "",
+      ga_session_number: "",
+      gclid: "",
+      ignore_referrer: "",
+      medium: "",
+      page_location: window.location.href,
+      page_path: window.location.pathname,
+      page_referrer: document.referrer,
+      page_title: document.title,
+      page_source: "",
+      page_term: ""
+    };
+    window.gtag?.(
+      "event",
+      "first_visit",
+      this.enhanceWithAffiliateParams(params)
+    );
+  }
+  trackViewItem(event) {
+    window.gtag?.(
+      "event",
+      "view_item",
+      this.enhanceWithAffiliateParams({
+        currency: event.currency,
+        value: event.value,
+        items: event.items
+      })
+    );
+  }
+  trackScroll() {
+    const params = {
+      batch_ordering_id: "",
+      batch_page_id: "",
+      engagement_time_msec: void 0,
+      ga_session_id: "",
+      ga_session_number: "",
+      ignore_referrer: void 0,
+      page_location: window.location.href,
+      page_path: window.location.pathname,
+      page_referrer: document.referrer,
+      page_title: document.title,
+      percent_scrolled: 90
+      // or dynamically captured
+    };
+    window.gtag?.("event", "scroll", this.enhanceWithAffiliateParams(params));
+  }
+  trackCheckoutPayment(event) {
+    window.gtag?.(
+      "event",
+      "checkout_payment",
+      this.enhanceWithAffiliateParams({
+        currency: event.currency,
+        value: event.cartValue,
+        items: event.items.map((item) => ({
+          item_id: item.productId,
+          item_name: item.productName,
+          price: item.price,
+          quantity: item.quantity
+        }))
+      })
+    );
+  }
+  trackViewedProduct(event) {
+    window.gtag?.(
+      "event",
+      "viewed_product",
+      this.enhanceWithAffiliateParams({
+        currency: event.currency,
+        value: event.price,
+        items: [
+          {
+            item_id: event.productId,
+            item_name: event.productName,
+            price: event.price,
+            currency: event.currency
+          }
+        ],
+        view_duration: event.viewDuration
+      })
+    );
+  }
+  trackAddToCart(event) {
+    this.logger.debug("Processing add_to_cart event", { event });
+    const params = {
+      currency: event.currency || "INR",
+      value: event.price * (event.quantity || 1),
+      // Calculate total value
+      items: [
+        {
+          item_id: event.productId,
+          item_name: event.productName,
+          price: event.price,
+          quantity: event.quantity || 1,
+          item_variant: event.variant
+        }
+      ],
+      // GA4-specific parameters
+      batch_ordering_id: event.batch_ordering_id || "",
+      batch_page_id: event.batch_page_id || "",
+      campaign: event.campaign || "",
+      ga_session_id: event.ga_session_id || "",
+      engagement_time_msec: event.engagement_time_msec,
+      session_engaged: event.session_engaged,
+      page_title: event.page_title || document.title,
+      page_location: event.page_location || window.location.href,
+      page_referrer: event.page_referrer || document.referrer,
+      user_id: event.user_id,
+      user_properties: event.user_properties
+    };
+    const enhancedParams = this.enhanceWithAffiliateParams(params);
+    this.logger.debug("Sending add_to_cart event to gtag", {
+      params: enhancedParams
+    });
+    window.gtag?.("event", "add_to_cart", enhancedParams);
+  }
+  trackFormStart() {
+    const params = {
+      batch_ordering_id: "",
+      batch_page_id: "",
+      engagement_time_msec: void 0,
+      first_field_id: "",
+      first_field_name: "",
+      first_field_position: "",
+      first_field_type: "",
+      form_destination: "",
+      form_length: "",
+      form_id: "",
+      ga_session_id: "",
+      ga_session_number: "",
+      ignore_referrer: void 0,
+      page_location: window.location.href,
+      page_referrer: document.referrer,
+      page_title: document.title
+    };
+    window.gtag?.(
+      "event",
+      "form_start",
+      this.enhanceWithAffiliateParams(params)
+    );
+  }
+  trackCheckoutStarted(event) {
+    const params = {
+      batch_ordering_id: "",
+      batch_page_id: "",
+      currency: event.currency || "INR",
+      ecomm_pagetype: "",
+      ecomm_prodid: "",
+      ecomm_totalvalue: event.cartValue,
+      value: event.cartValue,
+      engagement_time_msec: void 0,
+      ga_session_id: "",
+      ga_session_number: "",
+      ignore_referrer: void 0,
+      page_location: window.location.href,
+      page_referrer: document.referrer,
+      page_title: document.title,
+      items: event.items.map((item) => ({
+        item_id: item.productId,
+        item_name: item.productName,
+        price: item.price,
+        quantity: item.quantity,
+        item_variant: item.variant
+      }))
+    };
+    window.gtag?.(
+      "event",
+      "begin_checkout",
+      this.enhanceWithAffiliateParams(params)
+    );
+  }
+  trackFormSubmission(event) {
+    const params = {
+      batch_ordering_id: "",
+      batch_page_id: "",
+      engagement_time_msec: void 0,
+      form_destination: "",
+      form_length: "",
+      form_id: event.formId,
+      ga_session_id: "",
+      ga_session_number: "",
+      ignore_referrer: void 0,
+      page_location: window.location.href,
+      page_referrer: document.referrer,
+      page_title: document.title
+    };
+    window.gtag?.(
+      "event",
+      "form_submit",
+      this.enhanceWithAffiliateParams(params)
+    );
+  }
+  trackSearch(event) {
+    const params = {
+      batch_ordering_id: "",
+      batch_page_id: "",
+      engagement_time_msec: void 0,
+      ga_session_id: "",
+      ga_session_number: "",
+      ignore_referrer: void 0,
+      page_location: window.location.href,
+      page_referrer: document.referrer,
+      page_title: document.title,
+      search_term: event.searchTerm
+    };
+    window.gtag?.("event", "search", this.enhanceWithAffiliateParams(params));
+  }
+  /**
+   * Track a checkout completed event
+   * @param event The checkout completed event
+   */
+  trackCheckoutCompleted(event) {
+    const params = {
+      transaction_id: event.orderId,
+      currency: event.currency || "INR",
+      value: event.cartValue,
+      items: event.items.map((item) => ({
+        item_id: item.productId,
+        item_name: item.productName,
+        price: item.price,
+        quantity: item.quantity,
+        item_variant: item.variant
+      }))
+    };
+    window.gtag?.("event", "purchase", this.enhanceWithAffiliateParams(params));
+  }
+  /**
+   * Track a custom event
+   * @param event The custom event
+   */
+  trackCustomEvent(event) {
+    const params = event.properties || {};
+    window.gtag?.("event", event.name, this.enhanceWithAffiliateParams(params));
+  }
+  /**
+   * Track an add payment info event
+   * @param event The add payment info event
+   */
+  trackAddPaymentInfo(event) {
+    const params = {
+      currency: event.currency || "INR",
+      value: event.cartValue,
+      payment_type: event.paymentType || "",
+      items: event.items.map((item) => ({
+        item_id: item.productId,
+        item_name: item.productName,
+        price: item.price,
+        quantity: item.quantity,
+        item_variant: item.variant
+      }))
+    };
+    window.gtag?.(
+      "event",
+      "add_payment_info",
+      this.enhanceWithAffiliateParams(params)
+    );
+  }
+  /**
+   * Track a view content event
+   * @param event The view content event
+   */
+  trackViewContent(event) {
+    const params = {
+      currency: event.currency || "USD",
+      value: event.value || 0,
+      items: event.items?.map((item) => ({
+        item_id: item.item_id,
+        item_name: item.item_name,
+        item_category: item.item_category,
+        item_category2: item.item_category2,
+        item_category3: item.item_category3,
+        item_category4: item.item_category4,
+        item_category5: item.item_category5,
+        item_brand: item.item_brand,
+        item_variant: item.item_variant,
+        price: item.price,
+        quantity: item.quantity
+      })) || [],
+      // GA4-specific parameters
+      batch_ordering_id: event.batch_ordering_id || "",
+      batch_page_id: event.batch_page_id || "",
+      campaign: event.campaign || "",
+      ga_session_id: event.ga_session_id || "",
+      engagement_time_msec: event.engagement_time_msec,
+      session_engaged: event.session_engaged,
+      page_title: event.page_title || document.title,
+      page_location: event.page_location || window.location.href,
+      page_referrer: event.page_referrer || document.referrer,
+      user_id: event.user_id,
+      user_properties: event.user_properties
+    };
+    window.gtag?.(
+      "event",
+      "view_item",
+      this.enhanceWithAffiliateParams(params)
+    );
+  }
+  /**
+   * Track a purchase event
+   * @param event The purchase event
+   */
+  trackPurchase(event) {
+    const params = {
+      transaction_id: event.transaction_id,
+      value: event.value,
+      currency: event.currency || "USD",
+      coupon: event.coupon,
+      shipping: event.shipping,
+      tax: event.tax,
+      items: event.items?.map((item) => ({
+        item_id: item.item_id,
+        item_name: item.item_name,
+        item_category: item.item_category,
+        item_category2: item.item_category2,
+        item_category3: item.item_category3,
+        item_category4: item.item_category4,
+        item_category5: item.item_category5,
+        item_brand: item.item_brand,
+        item_variant: item.item_variant,
+        price: item.price,
+        quantity: item.quantity
+      })) || [],
+      // GA4-specific parameters
+      batch_ordering_id: event.batch_ordering_id || "",
+      batch_page_id: event.batch_page_id || "",
+      campaign: event.campaign || "",
+      ga_session_id: event.ga_session_id || "",
+      engagement_time_msec: event.engagement_time_msec,
+      session_engaged: event.session_engaged,
+      page_title: event.page_title || document.title,
+      page_location: event.page_location || window.location.href,
+      page_referrer: event.page_referrer || document.referrer,
+      user_id: event.user_id,
+      user_properties: event.user_properties
+    };
+    window.gtag?.("event", "purchase", this.enhanceWithAffiliateParams(params));
+  }
+  /**
+   * Track a view search results event
+   * @param event The view search results event
+   */
+  trackViewSearchResults(event) {
+    const params = {
+      search_term: event.search_term,
+      // GA4-specific parameters
+      batch_ordering_id: event.batch_ordering_id || "",
+      batch_page_id: event.batch_page_id || "",
+      campaign: event.campaign || "",
+      ga_session_id: event.ga_session_id || "",
+      engagement_time_msec: event.engagement_time_msec,
+      session_engaged: event.session_engaged,
+      page_title: event.page_title || document.title,
+      page_location: event.page_location || window.location.href,
+      page_referrer: event.page_referrer || document.referrer,
+      user_id: event.user_id,
+      user_properties: event.user_properties
+    };
+    window.gtag?.(
+      "event",
+      "view_search_results",
+      this.enhanceWithAffiliateParams(params)
+    );
+  }
+  /**
+   * Track an order placed event
+   * @param event The order placed event
+   */
+  trackOrderPlaced(event) {
+    const params = {
+      transaction_id: event.order_id,
+      value: event.total_amount,
+      currency: event.currency || "USD",
+      items: event.items?.map((item) => ({
+        item_id: item.product_id,
+        item_name: item.product_name,
+        item_category: item.category,
+        item_brand: item.brand,
+        item_variant: item.variant,
+        price: item.price,
+        quantity: item.quantity
+      })) || [],
+      // GA4-specific parameters
+      batch_ordering_id: event.batch_ordering_id || "",
+      batch_page_id: event.batch_page_id || "",
+      campaign: event.campaign || "",
+      ga_session_id: event.ga_session_id || "",
+      engagement_time_msec: event.engagement_time_msec,
+      session_engaged: event.session_engaged,
+      page_title: event.page_title || document.title,
+      page_location: event.page_location || window.location.href,
+      page_referrer: event.page_referrer || document.referrer,
+      user_id: event.user_id,
+      user_properties: event.user_properties
+    };
+    window.gtag?.("event", "purchase", this.enhanceWithAffiliateParams(params));
+  }
+  /**
+   * Track a begin checkout event
+   * @param event The begin checkout event
+   */
+  trackBeginCheckout(event) {
+    const params = {
+      currency: event.currency || "USD",
+      value: event.value || 0,
+      coupon: event.coupon,
+      items: event.items?.map((item) => ({
+        item_id: item.item_id,
+        item_name: item.item_name,
+        item_category: item.item_category,
+        item_category2: item.item_category2,
+        item_category3: item.item_category3,
+        item_category4: item.item_category4,
+        item_category5: item.item_category5,
+        item_brand: item.item_brand,
+        item_variant: item.item_variant,
+        price: item.price,
+        quantity: item.quantity
+      })) || [],
+      // GA4-specific parameters
+      batch_ordering_id: event.batch_ordering_id || "",
+      batch_page_id: event.batch_page_id || "",
+      campaign: event.campaign || "",
+      ga_session_id: event.ga_session_id || "",
+      engagement_time_msec: event.engagement_time_msec,
+      session_engaged: event.session_engaged,
+      page_title: event.page_title || document.title,
+      page_location: event.page_location || window.location.href,
+      page_referrer: event.page_referrer || document.referrer,
+      user_id: event.user_id,
+      user_properties: event.user_properties
+    };
+    window.gtag?.(
+      "event",
+      "begin_checkout",
+      this.enhanceWithAffiliateParams(params)
+    );
+  }
+  /**
+   * Convert an event to Google Analytics parameters
+   * @param event The event to convert
+   */
+  eventToParams(event) {
+    const { type, timestamp, ...params } = event;
+    return this.enhanceWithAffiliateParams(params);
+  }
+};
+
+// src/constants.ts
+var EventNames = {
+  // Page events
+  PAGE_VIEWED: "Page Viewed",
+  // Interaction events
+  BUTTON_CLICKED: "Button Clicked",
+  FORM_SUBMITTED: "Form Submitted",
+  // Product events
+  PRODUCT_VIEWED: "Product Viewed",
+  ADDED_TO_CART: "Added To Cart",
+  REMOVED_FROM_CART: "Removed From Cart",
+  // Checkout events
+  CHECKOUT_STARTED: "Checkout Started",
+  PURCHASE_COMPLETED: "Purchase Completed",
+  // Search events
+  SEARCH: "Search",
+  // User events
+  USER_SIGNED_UP: "User Signed Up",
+  USER_LOGGED_IN: "User Logged In",
+  // MoEngage events
+  ITEM_PURCHASED: "Item Purchased",
+  UPDATE_CART: "Update Cart",
+  CUSTOMER_REGISTERED: "Customer Registered",
+  CUSTOMER_LOGGED_IN: "Customer Logged In",
+  SHOPIFY_CHECKOUT_UPDATED: "Shopify - Checkout Updated",
+  SHOPIFY_ABANDONED_CHECKOUT: "Shopify - Abandoned Checkout",
+  SHOPIFY_ORDER_FULFILLED: "Shopify - Order Fulfilled",
+  SHOPIFY_CHECKOUT_STARTED: "Shopify - Checkout Started",
+  SHOPIFY_ADD_TO_CART: "Shopify - Add To Cart",
+  SHOPIFY_REMOVED_FROM_CART: "Shopify - Removed From Cart",
+  SHOPIFY_UPDATE_CART: "Shopify - Update Cart",
+  SPINFORM_RESULT: "Spinform Result",
+  COUPON_COPIED: "Coupon Copied",
+  STARTED_CHECKOUT_GK: "Started Checkout GK",
+  MOBILE_ADDED_GK: "Mobile Added GK",
+  ADDRESS_SELECTED_GK: "Address Selected GK",
+  ADDRESS_COMPLETED_GK: "Address Completed GK",
+  PAYMENT_METHOD_SELECTED_GK: "Payment Method Selected GK",
+  PAYMENT_COMPLETED_GK: "Payment Completed GK",
+  ORDER_SUCCESS: "Order Success",
+  ORDER_COMPLETED: "Order Completed",
+  PIN_CODE_ADDED_GK: "PIN Code Added GK",
+  ADDRESS_ADDED_GK: "Address Added GK",
+  KP_MP_PHONE_NUMBER_LOGGED_IN: "KP MP Phone Number Logged In",
+  KP_PHONE_NUMBER_LOGGED_IN: "KP Phone Number Logged In",
+  KP_MP_SHOPIFY_LOGGED_IN: "KP MP Shopify Logged In",
+  KP_MP_SUCCESSFULLY_LOGGED_OUT: "KP MP Successfully Logged Out",
+  KP_WHATSAPP_LOGGED_IN: "KP Whatsapp Logged In",
+  KP_MP_TRUECALLER_LOGGED_IN: "KP MP Truecaller Logged In",
+  KP_MP_WHATSAPP_LOGGED_IN: "KP MP Whatsapp Logged In",
+  KP_TRUECALLER_LOGGED_IN: "KP Truecaller Logged In",
+  KP_SHOPIFY_LOGGED_IN: "KP Shopify Logged In",
+  KP_SUCCESSFULLY_LOGGED_OUT: "KP Successfully Logged Out"
+};
+var DEFAULT_CURRENCY = "INR";
+var HARDCODED_HANDLE = "ryze-gums";
+
+// src/adapters/moengage-adapter.ts
+var import_web_sdk = __toESM(require("@moengage/web-sdk"));
+var MoengageAdapter = class extends BaseAdapter {
+  constructor(config) {
+    super(config);
+    this.name = "MoEngage";
+    this.sdk = null;
+    this.initializeLogger();
+  }
+  /**
+   * Initialize the MoenGage adapter using the Web SDK
+   */
+  async initialize() {
+    if (this.initialized) {
+      this.logger.debug("Already initialized");
+      return;
+    }
+    if (typeof window === "undefined") {
+      this.logger.debug("Skipping initialization on server");
+      return;
+    }
+    try {
+      const appId = this.getConfig("appId");
+      if (!appId) {
+        this.logger.warn("App ID is required for initialization");
+        return;
+      }
+      const region = this.getConfig("region", "dc_01");
+      const config = {
+        app_id: appId,
+        debug_logs: this.getConfig("debug", false) ? 1 : 0,
+        cluster: region
+      };
+      this.logger.info("Initializing with config", {
+        region,
+        debug: this.getConfig("debug", false),
+        appId: "***"
+        // Hide sensitive data
+      });
+      import_web_sdk.default.initialize(config);
+      this.sdk = window.Moengage;
+      this.logger.info("Successfully initialized with SDK");
+      this.initialized = true;
+    } catch (error) {
+      this.logger.error("Failed to initialize", error);
+    }
+  }
+  /**
+   * Track an event with MoenGage SDK
+   * @param event The event to track
+   */
+  async trackEvent(event) {
+    if (!this.initialized || typeof window === "undefined" || !this.sdk) {
+      this.logger.warn(
+        "Cannot track event, adapter not initialized or SDK not available",
+        {
+          eventType: event.type,
+          initialized: this.initialized,
+          hasWindow: typeof window !== "undefined",
+          hasSdk: !!this.sdk
+        }
+      );
+      return;
+    }
+    this.logger.debug("Tracking event", { eventType: event.type });
+    switch (event.type) {
+      case "page_view" /* PAGE_VIEW */:
+        this.trackPageView(event);
+        break;
+      case "button_click" /* BUTTON_CLICK */:
+        this.trackButtonClick(event);
+        break;
+      case "form_submission" /* FORM_SUBMISSION */:
+        this.trackFormSubmission(event);
+        break;
+      case "product_view" /* PRODUCT_VIEW */:
+        this.trackProductView(event);
+        break;
+      case "add_to_cart" /* ADD_TO_CART */:
+        this.trackAddToCart(event);
+        break;
+      case "remove_from_cart" /* REMOVE_FROM_CART */:
+        this.trackRemoveFromCart(event);
+        break;
+      case "checkout_started" /* CHECKOUT_STARTED */:
+        this.trackCheckoutStarted(event);
+        break;
+      case "checkout_completed" /* CHECKOUT_COMPLETED */:
+        this.trackCheckoutCompleted(event);
+        break;
+      case "search" /* SEARCH */:
+        this.trackSearch(event);
+        break;
+      case "user_signup" /* USER_SIGNUP */:
+        this.trackUserSignup(event);
+        break;
+      case "user_login" /* USER_LOGIN */:
+        this.trackUserLogin(event);
+        break;
+      case "custom" /* CUSTOM */:
+        this.trackCustomEvent(event);
+        break;
+      default:
+        this.sdk.track_event(event.type, this.eventToParams(event));
+        break;
+    }
+  }
+  /**
+   * Track a page view event
+   * @param event The page view event
+   */
+  trackPageView(event) {
+    if (!this.sdk?.track_event) {
+      this.logger.warn("track_event not available for PageView event");
+      return;
+    }
+    const eventData = {
+      page_path: event.path,
+      page_title: event.title,
+      page_url: window.location.href,
+      referrer: event.referrer || document.referrer
+    };
+    this.sdk.track_event(EventNames.PAGE_VIEWED, eventData);
+    this.logger.debug("PageView event tracked", { eventData });
+  }
+  /**
+   * Track a button click event
+   * @param event The button click event
+   */
+  trackButtonClick(event) {
+    this.sdk?.track_event(EventNames.BUTTON_CLICKED, {
+      button_id: event.buttonId,
+      button_text: event.buttonText,
+      location: event.location
+    });
+  }
+  /**
+   * Track a form submission event
+   * @param event The form submission event
+   */
+  trackFormSubmission(event) {
+    this.sdk?.track_event(EventNames.FORM_SUBMITTED, {
+      form_id: event.formId,
+      form_name: event.formName,
+      success: event.success
+    });
+  }
+  /**
+   * Track a product view event
+   * @param event The product view event
+   */
+  trackProductView(event) {
+    this.sdk?.track_event(EventNames.PRODUCT_VIEWED, {
+      product_id: event.productId,
+      product_name: event.productName,
+      price: event.price,
+      currency: event.currency || DEFAULT_CURRENCY,
+      category: event.category
+    });
+  }
+  /**
+   * Track an add to cart event
+   * @param event The add to cart event
+   */
+  trackAddToCart(event) {
+    const quantity = event.quantity ?? 1;
+    this.sdk?.track_event(EventNames.ADDED_TO_CART, {
+      product_id: event.productId,
+      product_name: event.productName,
+      price: event.price,
+      currency: event.currency || DEFAULT_CURRENCY,
+      quantity,
+      variant: event.variant,
+      total_value: event.price * quantity
+    });
+  }
+  /**
+   * Track a remove from cart event
+   * @param event The remove from cart event
+   */
+  trackRemoveFromCart(event) {
+    this.sdk?.track_event(EventNames.REMOVED_FROM_CART, {
+      product_id: event.productId,
+      product_name: event.productName,
+      price: event.price,
+      currency: event.currency || DEFAULT_CURRENCY,
+      quantity: event.quantity,
+      variant: event.variant,
+      total_value: event.price * event.quantity
+    });
+  }
+  /**
+   * Track a checkout started event
+   * @param event The checkout started event
+   */
+  trackCheckoutStarted(event) {
+    this.sdk?.track_event(EventNames.CHECKOUT_STARTED, {
+      cart_value: event.cartValue,
+      currency: event.currency || DEFAULT_CURRENCY,
+      item_count: event.itemCount,
+      items: event.items.map((item) => ({
+        product_id: item.productId,
+        product_name: item.productName,
+        price: item.price,
+        quantity: item.quantity,
+        variant: item.variant
+      }))
+    });
+  }
+  /**
+   * Track a checkout completed event
+   * @param event The checkout completed event
+   */
+  trackCheckoutCompleted(event) {
+    this.sdk?.track_event(EventNames.PURCHASE_COMPLETED, {
+      order_id: event.orderId,
+      cart_value: event.cartValue,
+      currency: event.currency || DEFAULT_CURRENCY,
+      item_count: event.itemCount,
+      items: event.items.map((item) => ({
+        product_id: item.productId,
+        product_name: item.productName,
+        price: item.price,
+        quantity: item.quantity,
+        variant: item.variant
+      }))
+    });
+  }
+  /**
+   * Track a search event
+   * @param event The search event
+   */
+  trackSearch(event) {
+    this.sdk?.track_event(EventNames.SEARCH, {
+      search_term: event.searchTerm,
+      results_count: event.resultsCount
+    });
+  }
+  /**
+   * Track a user signup event
+   * @param event The user signup event
+   */
+  trackUserSignup(event) {
+    this.sdk?.track_event(EventNames.USER_SIGNED_UP, {
+      user_id: event.userId,
+      method: event.method,
+      success: event.success
+    });
+    if (event.userId && this.getConfig("enableUserIdentification", true)) {
+      this.sdk?.add_unique_user_id(event.userId);
+    }
+  }
+  /**
+   * Track a user login event
+   * @param event The user login event
+   */
+  trackUserLogin(event) {
+    this.sdk?.track_event(EventNames.USER_LOGGED_IN, {
+      user_id: event.userId,
+      method: event.method,
+      success: event.success
+    });
+    if (event.userId && this.getConfig("enableUserIdentification", true)) {
+      this.sdk?.add_unique_user_id(event.userId);
+    }
+  }
+  /**
+   * Track a custom event
+   * @param event The custom event
+   */
+  trackCustomEvent(event) {
+    this.sdk?.track_event(event.name, event.properties);
+  }
+  /**
+   * Convert an event to MoenGage parameters
+   * @param event The event to convert
+   */
+  eventToParams(event) {
+    const { type, timestamp, ...params } = event;
+    return params;
+  }
+  /**
+   * Set user attributes in MoenGage
+   * @param attributes User attributes to set
+   */
+  setUserAttributes(attributes) {
+    if (!this.initialized || typeof window === "undefined" || !this.sdk) {
+      this.logger.warn("Cannot set user attributes, adapter not initialized");
+      return;
+    }
+    this.logger.debug("Setting user attributes", {
+      attributeKeys: Object.keys(attributes)
+    });
+    for (const [key, value] of Object.entries(attributes)) {
+      switch (key) {
+        case "firstName":
+          this.sdk?.add_first_name(value);
+          break;
+        case "lastName":
+          this.sdk?.add_last_name(value);
+          break;
+        case "email":
+          this.sdk?.add_email(value);
+          break;
+        case "mobile":
+          this.sdk?.add_mobile(value);
+          break;
+        case "username":
+          this.sdk?.add_user_name(value);
+          break;
+        case "gender":
+          this.sdk?.add_gender(value);
+          break;
+        case "birthday":
+          this.sdk?.add_birthday(value);
+          break;
+        case "userId":
+          this.sdk?.add_unique_user_id(value);
+          break;
+        default:
+          this.sdk?.add_user_attribute(key, value);
+          break;
+      }
+    }
+  }
+};
+
+// src/adapters/posthog-adapter.ts
+var PostHogAdapter = class extends BaseAdapter {
+  constructor(config = {}) {
+    super(config);
+    this.name = "PostHog";
+    this.initializeLogger();
+  }
+  /**
+   * Initialize PostHog
+   */
+  async initialize() {
+    if (this.initialized) {
+      this.logger.debug("Already initialized");
+      return;
+    }
+    if (typeof window === "undefined") {
+      this.logger.debug("Skipping initialization on server");
+      return;
+    }
+    if (!window.posthog) {
+      this.logger.warn(
+        "PostHog object not found. Make sure the script is loaded."
+      );
+      return;
+    }
+    this.logger.info("Successfully initialized");
+    this.initialized = true;
+  }
+  /**
+   * Track an event with PostHog
+   * @param event The event to track
+   */
+  async trackEvent(event) {
+    if (!this.initialized || typeof window === "undefined" || !window.posthog) {
+      this.logger.warn(
+        "Cannot track event, adapter not initialized or posthog not available",
+        {
+          eventType: event.type,
+          initialized: this.initialized,
+          hasWindow: typeof window !== "undefined",
+          hasPosthog: !!window?.posthog
+        }
+      );
+      return;
+    }
+    this.logger.debug("Tracking event", { eventType: event.type });
+    switch (event.type) {
+      case "page_view" /* PAGE_VIEW */:
+        this.trackPageView(event);
+        break;
+      case "product_view" /* PRODUCT_VIEW */:
+        this.trackProductView(event);
+        break;
+      case "add_to_cart" /* ADD_TO_CART */:
+        this.trackAddToCart(event);
+        break;
+      case "checkout_started" /* CHECKOUT_STARTED */:
+        this.trackCheckoutStarted(event);
+        break;
+      case "checkout_completed" /* CHECKOUT_COMPLETED */:
+        this.trackCheckoutCompleted(event);
+        break;
+      case "add_payment_info" /* ADD_PAYMENT_INFO */:
+        this.trackAddPaymentInfo(event);
+        break;
+      case "search" /* SEARCH */:
+        this.trackSearch(event);
+        break;
+      default:
+        const params = this.eventToParams(event);
+        window.posthog?.capture(
+          event.type,
+          this.enhanceWithAffiliateParams(params)
+        );
+        break;
+    }
+  }
+  /**
+   * Track a page view event
+   * @param event The page view event
+   */
+  trackPageView(event) {
+    const params = {
+      path: event.path,
+      title: event.title,
+      referrer: event.referrer
+    };
+    window.posthog?.capture(
+      "$pageview",
+      this.enhanceWithAffiliateParams(params)
+    );
+  }
+  /**
+   * Track a product view event
+   * @param event The product view event
+   */
+  trackProductView(event) {
+    const params = {
+      product_id: event.productId,
+      product_name: event.productName,
+      category: event.category,
+      price: event.price,
+      currency: event.currency || "INR"
+    };
+    window.posthog?.capture(
+      "product_viewed",
+      this.enhanceWithAffiliateParams(params)
+    );
+  }
+  /**
+   * Track an add to cart event
+   * @param event The add to cart event
+   */
+  trackAddToCart(event) {
+    this.logger.debug("Handling ADD_TO_CART event", { event });
+    const params = {
+      product_id: event.productId,
+      product_name: event.productName,
+      price: event.price,
+      currency: event.currency || "INR",
+      quantity: event.quantity,
+      variant: event.variant
+    };
+    this.logger.debug("Sending to PostHog with params", { params });
+    if (!window.posthog) {
+      this.logger.error("window.posthog is not available");
+      return;
+    }
+    window.posthog.capture(
+      "add_to_cart",
+      this.enhanceWithAffiliateParams(params)
+    );
+    this.logger.debug("Event sent to PostHog successfully");
+  }
+  /**
+   * Track a checkout started event
+   * @param event The checkout started event
+   */
+  trackCheckoutStarted(event) {
+    const params = {
+      cart_value: event.cartValue,
+      currency: event.currency || "INR",
+      item_count: event.itemCount,
+      items: event.items.map((item) => ({
+        product_id: item.productId,
+        product_name: item.productName,
+        price: item.price,
+        quantity: item.quantity,
+        variant: item.variant
+      }))
+    };
+    window.posthog?.capture(
+      "checkout_started",
+      this.enhanceWithAffiliateParams(params)
+    );
+  }
+  /**
+   * Track a checkout completed event
+   * @param event The checkout completed event
+   */
+  trackCheckoutCompleted(event) {
+    const params = {
+      order_id: event.orderId,
+      cart_value: event.cartValue,
+      currency: event.currency || "INR",
+      item_count: event.itemCount,
+      items: event.items.map((item) => ({
+        product_id: item.productId,
+        product_name: item.productName,
+        price: item.price,
+        quantity: item.quantity,
+        variant: item.variant
+      }))
+    };
+    window.posthog?.capture(
+      "purchase",
+      this.enhanceWithAffiliateParams(params)
+    );
+  }
+  /**
+   * Track a search event
+   * @param event The search event
+   */
+  trackSearch(event) {
+    const params = {
+      search_term: event.searchTerm,
+      results_count: event.resultsCount,
+      content_ids: event.content_ids
+    };
+    window.posthog?.capture("search", this.enhanceWithAffiliateParams(params));
+  }
+  /**
+   * Track an add payment info event
+   * @param event The add payment info event
+   */
+  trackAddPaymentInfo(event) {
+    const params = {
+      cart_value: event.cartValue,
+      currency: event.currency || "INR",
+      payment_type: event.paymentType,
+      item_count: event.itemCount,
+      items: event.items.map((item) => ({
+        product_id: item.productId,
+        product_name: item.productName,
+        price: item.price,
+        quantity: item.quantity,
+        variant: item.variant
+      }))
+    };
+    window.posthog?.capture(
+      "add_payment_info",
+      this.enhanceWithAffiliateParams(params)
+    );
+  }
+  /**
+   * Convert an event to PostHog parameters
+   * @param event The event to convert
+   */
+  eventToParams(event) {
+    const { type, timestamp, ...params } = event;
+    return params;
+  }
+};
+
+// src/adapters/shopify-adapter.ts
+var import_hydrogen_react = require("@shopify/hydrogen-react");
+
+// src/events/init.ts
+async function initializeEventTracking(adapters) {
+  const { eventSubscriber: eventSubscriber2 } = await Promise.resolve().then(() => (init_subscriber(), subscriber_exports));
+  for (const adapter of adapters) {
+    eventSubscriber2.registerAdapter(adapter);
+  }
+  await eventSubscriber2.initialize();
+}
+async function initTracking(config) {
+  console.log("Initializing event tracking system...");
+  const adapters = [];
+  if (config.pixelId) {
+    const pixelAdapter = new PixelAdapter({
+      pixelId: config.pixelId
+    });
+    adapters.push(pixelAdapter);
+  }
+  if (config.gaId) {
+    const gaAdapter = new GoogleAdapter({
+      measurementId: config.gaId
+    });
+    adapters.push(gaAdapter);
+  }
+  if (config.moengageAppId) {
+    const moengageAdapter = new MoengageAdapter({
+      appId: config.moengageAppId,
+      enableUserIdentification: true,
+      region: config.moengageRegion || "dc_01",
+      debug: config.enableDebugLogs || false
+    });
+    adapters.push(moengageAdapter);
+  }
+  const posthogAdapter = new PostHogAdapter({
+    enableDebugLogs: config.enableDebugLogs || false
+  });
+  adapters.push(posthogAdapter);
+  console.log(
+    "Configured adapters:",
+    adapters.map((a) => a.name)
+  );
+  await initializeEventTracking(adapters);
+  console.log("Event tracking system initialized successfully");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_CURRENCY,
+  EventNames,
+  EventType,
+  HARDCODED_HANDLE,
+  eventPublisher,
+  eventSubscriber,
+  initTracking,
+  initializeEventTracking,
+  publishEvent
+});
+//# sourceMappingURL=index.js.map