shopkit-analytics 1.0.0

package/dist/adapters/index.js

@@ -0,0 +1,2405 @@
+"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 __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/adapters/index.ts
+var adapters_exports = {};
+__export(adapters_exports, {
+  BaseAdapter: () => BaseAdapter,
+  GoogleAdapter: () => GoogleAdapter,
+  KwikCheckoutAdapter: () => KwikCheckoutAdapter,
+  KwikPassAdapter: () => KwikPassAdapter,
+  MoengageAdapter: () => MoengageAdapter,
+  PixelAdapter: () => PixelAdapter,
+  PostHogAdapter: () => PostHogAdapter,
+  ShopifyAdapter: () => ShopifyAdapter
+});
+module.exports = __toCommonJS(adapters_exports);
+
+// 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";
+
+// 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");
+var DEFAULT_CURRENCY2 = "INR";
+var DEFAULT_LANGUAGE = "en";
+var ShopifyAdapter = class extends BaseAdapter {
+  constructor(config) {
+    super(config);
+    this.name = "ShopifyAnalytics";
+    /**
+     * Send page view event using the enhanced functionality
+     */
+    this.sendPageView = (eventName, payload) => {
+      const enhancedPayload = {
+        ...this.createBasePayload(),
+        ...payload
+      };
+      return (0, import_hydrogen_react.sendShopifyAnalytics)({
+        eventName,
+        payload: enhancedPayload
+      });
+    };
+    /**
+     * Send add to cart event using the enhanced functionality
+     */
+    this.sendAddToCart = ({
+      cartId,
+      totalValue,
+      products
+    }) => {
+      return this.sendPageView(import_hydrogen_react.AnalyticsEventName.ADD_TO_CART, {
+        cartId,
+        totalValue,
+        products
+      });
+    };
+    this.shopId = config.shopId;
+    this.domain = config.domain;
+    this.currency = config.currency || DEFAULT_CURRENCY2;
+  }
+  /**
+   * Initialize the Shopify Analytics adapter
+   */
+  async initialize() {
+    this.initializeLogger();
+    try {
+      if (typeof window !== "undefined") {
+        this.logger.info("Shopify Analytics adapter initialized successfully", {
+          shopId: this.shopId,
+          domain: this.domain,
+          currency: this.currency
+        });
+      }
+      this.initialized = true;
+    } catch (error) {
+      this.logger.error(
+        "Failed to initialize Shopify Analytics",
+        error instanceof Error ? error : new Error(String(error))
+      );
+      throw error;
+    }
+  }
+  /**
+   * Convert product ID to Shopify GID format if it's not already
+   */
+  formatProductGid(productId) {
+    return productId.startsWith("gid://shopify/Product/") ? productId : `gid://shopify/Product/${productId}`;
+  }
+  /**
+   * Get user consent status from your consent management system
+   */
+  getUserConsent() {
+    const hasConsent = this.checkUserConsent();
+    return {
+      hasUserConsent: hasConsent,
+      analyticsAllowed: hasConsent && this.checkAnalyticsConsent(),
+      marketingAllowed: hasConsent && this.checkMarketingConsent(),
+      saleOfDataAllowed: hasConsent && this.checkSaleOfDataConsent()
+    };
+  }
+  /**
+   * Check user consent (implement based on your consent management)
+   */
+  checkUserConsent() {
+    return true;
+  }
+  checkAnalyticsConsent() {
+    return true;
+  }
+  checkMarketingConsent() {
+    return true;
+  }
+  checkSaleOfDataConsent() {
+    return true;
+  }
+  /**
+   * Create base payload for all events
+   */
+  createBasePayload() {
+    const consent = this.getUserConsent();
+    return {
+      ...(0, import_hydrogen_react.getClientBrowserParameters)(),
+      ...consent,
+      storefrontId: this.domain,
+      shopifySalesChannel: import_hydrogen_react.ShopifySalesChannel.headless,
+      shopId: `gid://shopify/Shop/${this.shopId}`,
+      currency: this.currency,
+      acceptedLanguage: DEFAULT_LANGUAGE,
+      ...this.enhanceWithAffiliateParams({})
+    };
+  }
+  /**
+   * Track an event using Shopify Analytics
+   */
+  async trackEvent(event) {
+    if (!this.initialized || typeof window === "undefined") {
+      this.logger.warn(
+        "Shopify Analytics not initialized or not in browser environment"
+      );
+      return;
+    }
+    this.logger.debug("Processing Shopify Analytics event", {
+      eventType: event.type,
+      eventData: event
+    });
+    try {
+      switch (event.type) {
+        case "page_view" /* PAGE_VIEW */:
+          this.sendPageView(import_hydrogen_react.AnalyticsEventName.PAGE_VIEW);
+          this.logger.debug("Sent PAGE_VIEW event to Shopify Analytics");
+          break;
+        case "view_content" /* VIEW_CONTENT */:
+          this.sendPageView(import_hydrogen_react.AnalyticsEventName.PRODUCT_VIEW);
+          this.logger.debug("Sent PRODUCT_VIEW event to Shopify Analytics");
+          break;
+        case "add_to_cart" /* ADD_TO_CART */:
+          this.trackAddToCart(event);
+          break;
+        case "checkout_started" /* CHECKOUT_STARTED */:
+        case "begin_checkout" /* BEGIN_CHECKOUT */:
+          this.sendPageView(import_hydrogen_react.AnalyticsEventName.PAGE_VIEW, {
+            pageType: "checkout"
+          });
+          this.logger.debug(
+            "Sent checkout PAGE_VIEW event to Shopify Analytics"
+          );
+          break;
+        default:
+          this.logger.debug("Event not supported by Shopify Analytics", {
+            eventType: event.type
+          });
+          break;
+      }
+    } catch (error) {
+      this.logger.error(
+        "Error tracking Shopify Analytics event",
+        error instanceof Error ? error : new Error(String(error)),
+        { eventType: event.type }
+      );
+    }
+  }
+  /**
+   * Check if Shopify session is properly established
+   */
+  isSessionValid() {
+    if (typeof window === "undefined") return false;
+    const shopifyY = document.cookie.includes("_shopify_y=");
+    const shopifyS = document.cookie.includes("_shopify_s=");
+    return shopifyY && shopifyS;
+  }
+  /**
+   * Get session debug information
+   */
+  getSessionDebugInfo() {
+    if (typeof window === "undefined")
+      return { error: "Not in browser environment" };
+    return {
+      sessionValid: this.isSessionValid(),
+      cookies: {
+        shopify_y: document.cookie.includes("_shopify_y="),
+        shopify_s: document.cookie.includes("_shopify_s="),
+        all: document.cookie
+      },
+      shopId: this.shopId,
+      initialized: this.initialized
+    };
+  }
+  /**
+   * Track add to cart event with enhanced error handling
+   */
+  trackAddToCart(event) {
+    if (!event.productId) {
+      this.logger.warn("ADD_TO_CART event missing productId");
+      return;
+    }
+    try {
+      const productGid = this.formatProductGid(event.productId);
+      const cartKey = `merchant_${process.env.NEXT_PUBLIC_MERCHANT_NAME}_cartId`;
+      const cartId = localStorage.getItem(cartKey) || "";
+      if (!cartId) {
+        this.logger.warn("No cart ID found, creating anonymous session");
+      }
+      if (!event.price || event.price <= 0) {
+        this.logger.warn("Invalid or missing price for ADD_TO_CART", {
+          price: event.price
+        });
+      }
+      const productPrice = Math.max(0, event.price || 0);
+      const productQuantity = Math.max(1, event.quantity || 1);
+      const products = [
+        {
+          productGid,
+          variantGid: event.variantId || productGid.replace("Product", "ProductVariant"),
+          quantity: productQuantity,
+          price: productPrice.toString(),
+          // Convert to string as required by ShopifyAnalyticsProduct
+          name: event.productName || "Unknown Product",
+          brand: event.brand || "Unknown Brand"
+        }
+      ];
+      const totalValue = productPrice * productQuantity;
+      this.logger.debug("ADD_TO_CART event tracked successfully", {
+        productGid,
+        quantity: productQuantity,
+        price: productPrice,
+        totalValue
+      });
+      this.sendAddToCart({
+        cartId,
+        products,
+        totalValue
+      });
+    } catch (error) {
+      this.logger.error(
+        "Error in trackAddToCart",
+        error instanceof Error ? error : new Error(String(error))
+      );
+    }
+  }
+};
+
+// src/adapters/kwikpass-adapter.ts
+var KwikPassAdapter = class extends BaseAdapter {
+  constructor(config = {}) {
+    super(config);
+    this.name = "KwikPass";
+    this.enableKwikPassEvents = config.enableKwikPassEvents ?? true;
+    this.initializeLogger();
+  }
+  /**
+   * Initialize the KwikPass adapter
+   */
+  async initialize() {
+    try {
+      if (typeof window !== "undefined") {
+        this.logger.info("KwikPass adapter initialized successfully", {
+          eventsEnabled: this.enableKwikPassEvents
+        });
+      }
+      this.initialized = true;
+    } catch (error) {
+      this.logger.error(
+        "Failed to initialize KwikPass adapter",
+        error
+      );
+      throw error;
+    }
+  }
+  /**
+   * Track an event using KwikPass
+   */
+  async trackEvent(event) {
+    if (!this.initialized || typeof window === "undefined") {
+      this.logger.warn(
+        "KwikPass adapter not initialized or not in browser environment"
+      );
+      return;
+    }
+    if (!this.enableKwikPassEvents) {
+      this.logger.debug("KwikPass events disabled, skipping event", {
+        eventType: event.type
+      });
+      return;
+    }
+    try {
+      this.logger.debug("Processing event", { eventType: event.type });
+      const enhancedEvent = this.enhanceWithAffiliateParams(event);
+      switch (event.type) {
+        case "product_view" /* PRODUCT_VIEW */:
+          this.trackProductView(enhancedEvent);
+          break;
+        case "collection_view" /* COLLECTION_VIEW */:
+          this.trackCollectionView(enhancedEvent);
+          break;
+        case "page_view" /* PAGE_VIEW */:
+          this.trackPageView(enhancedEvent);
+          break;
+        default:
+          this.logger.debug("Event not supported", { eventType: event.type });
+          break;
+      }
+    } catch (error) {
+      this.logger.error("Error tracking KwikPass event", error, {
+        eventType: event.type
+      });
+    }
+  }
+  /**
+   * Send event to KwikPass platform
+   */
+  sendKwikPassEvent(type, eventData) {
+    this.logger.debug(`Sending ${type}`, { eventData });
+    if (typeof window !== "undefined") {
+      const customEvent = new CustomEvent(`page_view_kp`, {
+        detail: {
+          type,
+          detail: eventData
+        }
+      });
+      window.dispatchEvent(customEvent);
+      this.logger.debug(`${type} sent successfully`);
+    }
+  }
+  /**
+   * Track product view event
+   */
+  trackCollectionView(event) {
+    this.sendKwikPassEvent("collection", {
+      product_id: event.productId,
+      product_name: event.productName,
+      price: event.price,
+      currency: event.currency,
+      category: event.category,
+      timestamp: event.timestamp || Date.now()
+    });
+  }
+  /**
+   * Track collection view event
+   */
+  trackProductView(event) {
+    this.sendKwikPassEvent("product", {
+      product_id: event.productId,
+      product_name: event.productName,
+      price: event.price,
+      currency: event.currency,
+      category: event.category,
+      timestamp: event.timestamp || Date.now()
+    });
+  }
+  /**
+   * Track page view event
+   */
+  trackPageView(event) {
+    this.sendKwikPassEvent("other", {
+      path: event.path,
+      title: event.title,
+      referrer: event.referrer,
+      timestamp: event.timestamp || Date.now()
+    });
+  }
+};
+
+// src/adapters/kwik-checkout-adapter.ts
+var KwikCheckoutAdapter = class extends BaseAdapter {
+  constructor(config) {
+    super(config);
+    this.name = "KwikCheckout";
+    this.mid = config.mid || "";
+    this.environment = config.environment || "production";
+    this.storeId = config.storeId || "";
+    this.initializeLogger();
+  }
+  /**
+   * Initialize the GoKwik adapter
+   */
+  async initialize() {
+    try {
+      if (typeof window !== "undefined") {
+        this.logger.info("GoKwik adapter initialized successfully", {
+          mid: this.mid,
+          environment: this.environment,
+          storeId: this.storeId
+        });
+      }
+      this.initialized = true;
+    } catch (error) {
+      this.logger.error("Failed to initialize GoKwik adapter", error);
+      throw error;
+    }
+  }
+  /**
+   * Track an event using GoKwik
+   */
+  async trackEvent(event) {
+    if (!this.initialized || typeof window === "undefined") {
+      this.logger.warn(
+        "GoKwik adapter not initialized or not in browser environment"
+      );
+      return;
+    }
+    try {
+      this.logger.debug("Processing event", { eventType: event.type });
+      const enhancedEvent = this.enhanceWithAffiliateParams(event);
+      switch (event.type) {
+        case "started_checkout_gk" /* STARTED_CHECKOUT_GK */:
+          this.trackStartedCheckoutGK(enhancedEvent);
+          break;
+        case "mobile_added_gk" /* MOBILE_ADDED_GK */:
+          this.trackMobileAddedGK(enhancedEvent);
+          break;
+        case "address_selected_gk" /* ADDRESS_SELECTED_GK */:
+          this.trackAddressSelectedGK(enhancedEvent);
+          break;
+        case "address_completed_gk" /* ADDRESS_COMPLETED_GK */:
+          this.trackAddressCompletedGK(enhancedEvent);
+          break;
+        case "address_added_gk" /* ADDRESS_ADDED_GK */:
+          this.trackAddressAddedGK(enhancedEvent);
+          break;
+        case "pin_code_added_gk" /* PIN_CODE_ADDED_GK */:
+          this.trackPinCodeAddedGK(enhancedEvent);
+          break;
+        case "payment_method_selected_gk" /* PAYMENT_METHOD_SELECTED_GK */:
+          this.trackPaymentMethodSelectedGK(enhancedEvent);
+          break;
+        case "payment_completed_gk" /* PAYMENT_COMPLETED_GK */:
+          this.trackPaymentCompletedGK(enhancedEvent);
+          break;
+        case "order_success" /* ORDER_SUCCESS */:
+          this.trackOrderSuccess(enhancedEvent);
+          break;
+        case "order_completed" /* ORDER_COMPLETED */:
+          this.trackOrderCompleted(enhancedEvent);
+          break;
+        case "cart_viewed" /* CART_VIEWED */:
+          this.trackCartViewed(enhancedEvent);
+          break;
+        case "checkout_started" /* CHECKOUT_STARTED */:
+          this.trackCheckoutStarted(enhancedEvent);
+          break;
+        case "checkout_completed" /* CHECKOUT_COMPLETED */:
+          this.trackCheckoutCompleted(enhancedEvent);
+          break;
+        case "add_payment_info" /* ADD_PAYMENT_INFO */:
+          this.trackAddPaymentInfo(enhancedEvent);
+          break;
+        default:
+          this.logger.debug("Event not supported", { eventType: event.type });
+          break;
+      }
+    } catch (error) {
+      this.logger.error("Error tracking GoKwik event", error, {
+        eventType: event.type
+      });
+    }
+  }
+  /**
+   * Send event to GoKwik platform
+   */
+  sendGoKwikEvent(eventName, eventData) {
+    this.logger.debug(`Sending ${eventName}`, { eventData });
+    if (typeof window !== "undefined" && window.gokwikSdk) {
+      try {
+        window.gokwikSdk.track?.(eventName, eventData);
+        this.logger.debug(`${eventName} sent via SDK successfully`);
+      } catch (error) {
+        this.logger.error(
+          `Error sending GoKwik event ${eventName} via SDK`,
+          error
+        );
+      }
+    } else {
+      if (typeof window !== "undefined") {
+        const customEvent = new CustomEvent(`gokwik_${eventName}`, {
+          detail: eventData
+        });
+        window.dispatchEvent(customEvent);
+        this.logger.debug(`${eventName} sent via custom event successfully`);
+      }
+    }
+  }
+  /**
+   * Track started checkout GK event
+   */
+  trackStartedCheckoutGK(event) {
+    this.sendGoKwikEvent("started_checkout", {
+      cart_value: event.cartValue,
+      currency: event.currency,
+      timestamp: event.timestamp || Date.now()
+    });
+  }
+  /**
+   * Track mobile added GK event
+   */
+  trackMobileAddedGK(event) {
+    this.sendGoKwikEvent("mobile_added", {
+      mobile: event.mobile,
+      timestamp: event.timestamp || Date.now()
+    });
+  }
+  /**
+   * Track address selected GK event
+   */
+  trackAddressSelectedGK(event) {
+    this.sendGoKwikEvent("address_selected", {
+      address_id: event.addressId,
+      timestamp: event.timestamp || Date.now()
+    });
+  }
+  /**
+   * Track address completed GK event
+   */
+  trackAddressCompletedGK(event) {
+    this.sendGoKwikEvent("address_completed", {
+      address_id: event.addressId,
+      timestamp: event.timestamp || Date.now()
+    });
+  }
+  /**
+   * Track address added GK event
+   */
+  trackAddressAddedGK(event) {
+    this.sendGoKwikEvent("address_added", {
+      address_id: event.addressId,
+      timestamp: event.timestamp || Date.now()
+    });
+  }
+  /**
+   * Track PIN code added GK event
+   */
+  trackPinCodeAddedGK(event) {
+    this.sendGoKwikEvent("pin_code_added", {
+      pin_code: event.pinCode,
+      timestamp: event.timestamp || Date.now()
+    });
+  }
+  /**
+   * Track payment method selected GK event
+   */
+  trackPaymentMethodSelectedGK(event) {
+    this.sendGoKwikEvent("payment_method_selected", {
+      payment_method: event.paymentMethod,
+      timestamp: event.timestamp || Date.now()
+    });
+  }
+  /**
+   * Track payment completed GK event
+   */
+  trackPaymentCompletedGK(event) {
+    this.sendGoKwikEvent("payment_completed", {
+      amount: event.amount,
+      currency: event.currency,
+      timestamp: event.timestamp || Date.now()
+    });
+  }
+  /**
+   * Track order success event
+   */
+  trackOrderSuccess(event) {
+    this.sendGoKwikEvent("order_success", {
+      order_id: event.orderId,
+      amount: event.amount,
+      currency: event.currency,
+      timestamp: event.timestamp || Date.now()
+    });
+  }
+  /**
+   * Track order completed event
+   */
+  trackOrderCompleted(event) {
+    this.sendGoKwikEvent("order_completed", {
+      order_id: event.orderId,
+      amount: event.amount,
+      currency: event.currency,
+      timestamp: event.timestamp || Date.now()
+    });
+  }
+  /**
+   * Track cart viewed event
+   */
+  trackCartViewed(event) {
+    this.sendGoKwikEvent("cart_viewed", {
+      cart_id: event.cartId,
+      products: event.products,
+      timestamp: event.timestamp || Date.now()
+    });
+  }
+  /**
+   * Track checkout started event
+   */
+  trackCheckoutStarted(event) {
+    this.sendGoKwikEvent("checkout_started", {
+      cart_value: event.cartValue,
+      currency: event.currency,
+      item_count: event.itemCount,
+      items: event.items,
+      timestamp: event.timestamp || Date.now()
+    });
+  }
+  /**
+   * Track checkout completed event
+   */
+  trackCheckoutCompleted(event) {
+    this.sendGoKwikEvent("checkout_completed", {
+      order_id: event.orderId,
+      cart_value: event.cartValue,
+      currency: event.currency,
+      item_count: event.itemCount,
+      items: event.items,
+      timestamp: event.timestamp || Date.now()
+    });
+  }
+  /**
+   * Track add payment info event
+   */
+  trackAddPaymentInfo(event) {
+    this.sendGoKwikEvent("add_payment_info", {
+      cart_value: event.cartValue,
+      currency: event.currency,
+      item_count: event.itemCount,
+      payment_type: event.paymentType,
+      items: event.items,
+      timestamp: event.timestamp || Date.now()
+    });
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BaseAdapter,
+  GoogleAdapter,
+  KwikCheckoutAdapter,
+  KwikPassAdapter,
+  MoengageAdapter,
+  PixelAdapter,
+  PostHogAdapter,
+  ShopifyAdapter
+});
+//# sourceMappingURL=index.js.map