shopkit-analytics 1.0.0

package/dist/index.js

@@ -0,0 +1,3269 @@
+"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/index.ts
+var src_exports = {};
+__export(src_exports, {
+  AffiliateTracker: () => AffiliateTracker_default,
+  BaseAdapter: () => BaseAdapter,
+  DEFAULT_CURRENCY: () => DEFAULT_CURRENCY,
+  EventNames: () => EventNames,
+  EventType: () => EventType,
+  GoogleAdapter: () => GoogleAdapter,
+  HARDCODED_HANDLE: () => HARDCODED_HANDLE,
+  KwikCheckoutAdapter: () => KwikCheckoutAdapter,
+  KwikPassAdapter: () => KwikPassAdapter,
+  MoengageAdapter: () => MoengageAdapter,
+  PixelAdapter: () => PixelAdapter,
+  PostHogAdapter: () => PostHogAdapter,
+  ShopifyAdapter: () => ShopifyAdapter,
+  ShopkitAnalytics: () => ShopkitAnalytics_default,
+  captureAffiliateParams: () => captureAffiliateParams,
+  clearAffiliateParams: () => clearAffiliateParams,
+  createAdapterLogger: () => createAdapterLogger,
+  createLogger: () => createLogger,
+  default: () => ShopkitAnalytics_default,
+  eventPublisher: () => eventPublisher,
+  eventSubscriber: () => eventSubscriber,
+  getAffiliateParams: () => getAffiliateParams,
+  getAffiliateSource: () => getAffiliateSource,
+  hasAffiliateData: () => hasAffiliateData,
+  initTracking: () => initTracking,
+  initializeEventTracking: () => initializeEventTracking,
+  logger: () => logger,
+  publishEvent: () => publishEvent,
+  useAffiliateSource: () => useAffiliateSource,
+  useAffiliateTracker: () => useAffiliateTracker,
+  useHasAffiliateData: () => useHasAffiliateData
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/ShopkitAnalytics.tsx
+var import_react3 = require("react");
+var import_hydrogen_react2 = require("@shopify/hydrogen-react");
+
+// 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/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/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");
+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()
+    });
+  }
+};
+
+// 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");
+}
+
+// src/affiliate/AffiliateTracker.tsx
+var import_react = require("react");
+
+// src/affiliate/constants.ts
+var UTM_PARAMETERS = [
+  "utm_source",
+  "utm_medium",
+  "utm_campaign",
+  "utm_term",
+  "utm_content"
+];
+var CLICK_ID_PARAMETERS = [
+  "gclid",
+  // Google Ads
+  "fbclid",
+  // Facebook
+  "msclkid",
+  // Microsoft Ads
+  "ttclid",
+  // TikTok
+  "twclid",
+  // Twitter
+  "li_fat_id"
+  // LinkedIn
+];
+var AFFILIATE_PARAMETERS = [
+  "click_id",
+  "affiliate_id",
+  "ref",
+  "source",
+  "referrer"
+];
+var ALL_AFFILIATE_PARAMETERS = [
+  ...UTM_PARAMETERS,
+  ...CLICK_ID_PARAMETERS,
+  ...AFFILIATE_PARAMETERS
+];
+var STORAGE_CONFIG = {
+  DEFAULT_KEY: "affiliateParams",
+  DEFAULT_TTL: 30 * 24 * 60 * 60 * 1e3
+  // 30 days in milliseconds
+};
+var ATTRIBUTION_MODELS = {
+  FIRST_TOUCH: "first-touch",
+  LAST_TOUCH: "last-touch"
+};
+var STORAGE_TYPES = {
+  SESSION: "sessionStorage",
+  LOCAL: "localStorage"
+};
+
+// src/affiliate/affiliate-tracker.ts
+var DEFAULT_CONFIG = {
+  storageKey: STORAGE_CONFIG.DEFAULT_KEY,
+  storageType: STORAGE_TYPES.SESSION,
+  attribution: ATTRIBUTION_MODELS.LAST_TOUCH,
+  ttl: STORAGE_CONFIG.DEFAULT_TTL,
+  customParams: [],
+  enableReferrerCapture: true,
+  enableUserAgentCapture: false,
+  onCapture: () => {
+  },
+  onError: () => {
+  }
+};
+var currentConfig = { ...DEFAULT_CONFIG };
+var eventListeners = [];
+function configureAffiliateTracker(config = {}) {
+  currentConfig = { ...DEFAULT_CONFIG, ...config };
+}
+function generateSessionId() {
+  return `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+}
+function getStorage() {
+  if (typeof window === "undefined") return null;
+  try {
+    return currentConfig.storageType === "localStorage" ? window.localStorage : window.sessionStorage;
+  } catch (error) {
+    currentConfig.onError(new Error(`Storage not available: ${error}`));
+    return null;
+  }
+}
+function isExpired(timestamp) {
+  return Date.now() - timestamp > currentConfig.ttl;
+}
+function emitEvent(event) {
+  eventListeners.forEach((listener) => {
+    try {
+      listener(event);
+    } catch (error) {
+      currentConfig.onError(new Error(`Event listener error: ${error}`));
+    }
+  });
+}
+function addEventListener(listener) {
+  eventListeners.push(listener);
+  return () => {
+    const index = eventListeners.indexOf(listener);
+    if (index > -1) {
+      eventListeners.splice(index, 1);
+    }
+  };
+}
+function captureAffiliateParams(customConfig) {
+  if (typeof window === "undefined") return null;
+  const originalConfig = currentConfig;
+  if (customConfig) {
+    currentConfig = { ...currentConfig, ...customConfig };
+  }
+  try {
+    const storage = getStorage();
+    if (!storage) return null;
+    const urlParams = new URLSearchParams(window.location.search);
+    const allKeys = [
+      ...ALL_AFFILIATE_PARAMETERS,
+      ...currentConfig.customParams
+    ];
+    const affiliateParams = {};
+    for (const key of allKeys) {
+      const value = urlParams.get(key);
+      if (value) {
+        affiliateParams[key] = value;
+      }
+    }
+    if (currentConfig.enableReferrerCapture && document.referrer) {
+      affiliateParams.referrer = document.referrer;
+    }
+    if (Object.keys(affiliateParams).length === 0) {
+      return null;
+    }
+    const existingData = getAffiliateParams();
+    let shouldUpdate = true;
+    if (existingData && currentConfig.attribution === "first-touch") {
+      shouldUpdate = false;
+    }
+    if (shouldUpdate) {
+      const affiliateData = {
+        ...affiliateParams,
+        timestamp: Date.now(),
+        sessionId: generateSessionId(),
+        attribution: currentConfig.attribution,
+        url: window.location.href,
+        ...currentConfig.enableUserAgentCapture && {
+          userAgent: navigator.userAgent
+        }
+      };
+      storage.setItem(currentConfig.storageKey, JSON.stringify(affiliateData));
+      emitEvent({
+        type: "capture",
+        data: affiliateData,
+        timestamp: Date.now()
+      });
+      currentConfig.onCapture(affiliateData);
+      return affiliateData;
+    }
+    return existingData;
+  } catch (error) {
+    const errorObj = error instanceof Error ? error : new Error(String(error));
+    currentConfig.onError(errorObj);
+    return null;
+  } finally {
+    if (customConfig) {
+      currentConfig = originalConfig;
+    }
+  }
+}
+function getAffiliateParams() {
+  if (typeof window === "undefined") return null;
+  try {
+    const storage = getStorage();
+    if (!storage) return null;
+    const stored = storage.getItem(currentConfig.storageKey);
+    if (!stored) return null;
+    const data = JSON.parse(stored);
+    if (isExpired(data.timestamp)) {
+      clearAffiliateParams();
+      emitEvent({
+        type: "expire",
+        data,
+        timestamp: Date.now()
+      });
+      return null;
+    }
+    return data;
+  } catch (error) {
+    const errorObj = error instanceof Error ? error : new Error(String(error));
+    currentConfig.onError(errorObj);
+    return null;
+  }
+}
+function clearAffiliateParams() {
+  if (typeof window === "undefined") return;
+  try {
+    const storage = getStorage();
+    if (!storage) return;
+    const existingData = getAffiliateParams();
+    storage.removeItem(currentConfig.storageKey);
+    emitEvent({
+      type: "clear",
+      data: existingData || void 0,
+      timestamp: Date.now()
+    });
+  } catch (error) {
+    const errorObj = error instanceof Error ? error : new Error(String(error));
+    currentConfig.onError(errorObj);
+  }
+}
+function hasAffiliateData() {
+  return getAffiliateParams() !== null;
+}
+function getAffiliateSource() {
+  const data = getAffiliateParams();
+  if (!data) return null;
+  if (data.utm_source) return data.utm_source;
+  if (data.referrer) {
+    try {
+      return new URL(data.referrer).hostname;
+    } catch {
+      return data.referrer;
+    }
+  }
+  return null;
+}
+
+// src/affiliate/AffiliateTracker.tsx
+var import_jsx_runtime = require("react/jsx-runtime");
+var AffiliateTracker = ({
+  config,
+  autoCapture = true,
+  children
+}) => {
+  (0, import_react.useEffect)(() => {
+    if (config) {
+      configureAffiliateTracker(config);
+    }
+    if (autoCapture) {
+      captureAffiliateParams();
+    }
+  }, [config, autoCapture]);
+  return children ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_jsx_runtime.Fragment, { children }) : null;
+};
+var AffiliateTracker_default = AffiliateTracker;
+
+// src/affiliate/hooks.ts
+var import_react2 = require("react");
+function useAffiliateTracker(config) {
+  const [affiliateParams, setAffiliateParams] = (0, import_react2.useState)(
+    null
+  );
+  const [isLoading, setIsLoading] = (0, import_react2.useState)(true);
+  const [error, setError] = (0, import_react2.useState)(null);
+  const configRef = (0, import_react2.useRef)(config);
+  (0, import_react2.useEffect)(() => {
+    configRef.current = config;
+  }, [config]);
+  (0, import_react2.useEffect)(() => {
+    if (configRef.current) {
+      configureAffiliateTracker({
+        ...configRef.current,
+        onError: (err) => {
+          setError(err);
+          configRef.current?.onError?.(err);
+        }
+      });
+    }
+  }, []);
+  const refreshParams = (0, import_react2.useCallback)(() => {
+    setIsLoading(true);
+    setError(null);
+    try {
+      const params = getAffiliateParams();
+      setAffiliateParams(params);
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error(String(err));
+      setError(error2);
+    } finally {
+      setIsLoading(false);
+    }
+  }, []);
+  const captureParams = (0, import_react2.useCallback)(() => {
+    setError(null);
+    try {
+      const params = captureAffiliateParams(configRef.current);
+      setAffiliateParams(params);
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error(String(err));
+      setError(error2);
+    }
+  }, []);
+  const clearParams = (0, import_react2.useCallback)(() => {
+    setError(null);
+    try {
+      clearAffiliateParams();
+      setAffiliateParams(null);
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error(String(err));
+      setError(error2);
+    }
+  }, []);
+  (0, import_react2.useEffect)(() => {
+    const unsubscribe = addEventListener((event) => {
+      switch (event.type) {
+        case "capture":
+          setAffiliateParams(event.data || null);
+          break;
+        case "clear":
+        case "expire":
+          setAffiliateParams(null);
+          break;
+      }
+    });
+    return unsubscribe;
+  }, []);
+  (0, import_react2.useEffect)(() => {
+    refreshParams();
+  }, [refreshParams]);
+  return {
+    affiliateParams,
+    isLoading,
+    error,
+    captureParams,
+    clearParams,
+    refreshParams
+  };
+}
+function useHasAffiliateData() {
+  const [hasData, setHasData] = (0, import_react2.useState)(false);
+  (0, import_react2.useEffect)(() => {
+    const checkData = () => {
+      setHasData(hasAffiliateData());
+    };
+    checkData();
+    const unsubscribe = addEventListener(() => {
+      checkData();
+    });
+    return unsubscribe;
+  }, []);
+  return hasData;
+}
+function useAffiliateSource() {
+  const [source, setSource] = (0, import_react2.useState)(null);
+  (0, import_react2.useEffect)(() => {
+    const updateSource = () => {
+      setSource(getAffiliateSource());
+    };
+    updateSource();
+    const unsubscribe = addEventListener(() => {
+      updateSource();
+    });
+    return unsubscribe;
+  }, []);
+  return source;
+}
+
+// src/ShopkitAnalytics.tsx
+var import_jsx_runtime2 = require("react/jsx-runtime");
+var ShopkitAnalytics = ({
+  config,
+  children,
+  onInitialized,
+  onError
+}) => {
+  (0, import_hydrogen_react2.useShopifyCookies)({
+    hasUserConsent: true,
+    domain: config.shopify?.domain || ""
+  });
+  (0, import_react3.useEffect)(() => {
+    const initializeAnalytics = async () => {
+      if (config.autoInitialize === false) return;
+      const loggerConfig = {
+        enabled: config.logger?.enabled ?? config.enableDebugLogs ?? true,
+        level: config.logger?.level ?? "info",
+        name: "@shopkit/analytics",
+        prettyPrint: config.logger?.prettyPrint ?? false
+      };
+      const logger2 = createLogger(loggerConfig);
+      try {
+        logger2.info("Starting initialization...");
+        const adapters = [];
+        const addLoggerConfig = (adapterConfig) => ({
+          ...adapterConfig,
+          enableDebugLogs: loggerConfig.enabled,
+          logLevel: loggerConfig.level
+        });
+        if (config.googleAnalytics) {
+          const gaAdapter = new GoogleAdapter(
+            addLoggerConfig(config.googleAnalytics)
+          );
+          adapters.push(gaAdapter);
+          logger2.info("Added Google Analytics adapter");
+        }
+        if (config.facebookPixel) {
+          const pixelAdapter = new PixelAdapter(
+            addLoggerConfig(config.facebookPixel)
+          );
+          adapters.push(pixelAdapter);
+          logger2.info("Added Facebook Pixel adapter");
+        }
+        if (config.moengage) {
+          const moengageAdapter = new MoengageAdapter(
+            addLoggerConfig(config.moengage)
+          );
+          adapters.push(moengageAdapter);
+          logger2.info("Added MoEngage adapter");
+        }
+        if (config.posthog) {
+          const posthogAdapter = new PostHogAdapter(
+            addLoggerConfig(config.posthog)
+          );
+          adapters.push(posthogAdapter);
+          logger2.info("Added PostHog adapter");
+        }
+        if (config.shopify) {
+          const shopifyAdapter = new ShopifyAdapter(
+            addLoggerConfig(config.shopify)
+          );
+          adapters.push(shopifyAdapter);
+          logger2.info("Added Shopify Analytics adapter");
+        }
+        if (config.kwikpass) {
+          const kwikpassAdapter = new KwikPassAdapter(
+            addLoggerConfig(config.kwikpass)
+          );
+          adapters.push(kwikpassAdapter);
+          logger2.info("Added KwikPass Analytics adapter");
+        }
+        if (config.kwikcheckout) {
+          const kwikcheckoutAdapter = new KwikCheckoutAdapter(
+            addLoggerConfig(config.kwikcheckout)
+          );
+          adapters.push(kwikcheckoutAdapter);
+          logger2.info("Added KwikCheckout Analytics adapter");
+        }
+        if (config.customAdapters) {
+          adapters.push(...config.customAdapters);
+          logger2.info(`Added ${config.customAdapters.length} custom adapters`);
+        }
+        if (adapters.length === 0) {
+          logger2.warn("No analytics adapters configured");
+        } else {
+          await initializeEventTracking(adapters);
+          logger2.info("Event tracking initialized with adapters", {
+            adapters: adapters.map((a) => a.name)
+          });
+        }
+        logger2.info("Initialization completed successfully");
+        onInitialized?.();
+      } catch (err) {
+        const error = err instanceof Error ? err : new Error("Unknown initialization error");
+        logger2.error("Initialization failed", error);
+        onError?.(error);
+      }
+    };
+    initializeAnalytics();
+  }, [config, onInitialized, onError]);
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_jsx_runtime2.Fragment, { children: [
+    config.affiliate?.enabled !== false && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+      AffiliateTracker_default,
+      {
+        config: config.affiliate?.config,
+        autoCapture: config.affiliate?.autoCapture
+      }
+    ),
+    children ? /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_jsx_runtime2.Fragment, { children }) : null
+  ] });
+};
+var ShopkitAnalytics_default = ShopkitAnalytics;
+
+// src/events/index.ts
+init_publisher();
+init_subscriber();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AffiliateTracker,
+  BaseAdapter,
+  DEFAULT_CURRENCY,
+  EventNames,
+  EventType,
+  GoogleAdapter,
+  HARDCODED_HANDLE,
+  KwikCheckoutAdapter,
+  KwikPassAdapter,
+  MoengageAdapter,
+  PixelAdapter,
+  PostHogAdapter,
+  ShopifyAdapter,
+  ShopkitAnalytics,
+  captureAffiliateParams,
+  clearAffiliateParams,
+  createAdapterLogger,
+  createLogger,
+  eventPublisher,
+  eventSubscriber,
+  getAffiliateParams,
+  getAffiliateSource,
+  hasAffiliateData,
+  initTracking,
+  initializeEventTracking,
+  logger,
+  publishEvent,
+  useAffiliateSource,
+  useAffiliateTracker,
+  useHasAffiliateData
+});
+//# sourceMappingURL=index.js.map