@hubstr/kit 0.1.4 → 0.1.6

package/analytics/dist/index.js

@@ -0,0 +1,985 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  AnalyticsManager: () => AnalyticsManager,
+  BaseAnalytics: () => BaseAnalytics,
+  GoogleAnalyticsProvider: () => GoogleAnalyticsProvider,
+  PostHogAnalyticsProvider: () => PostHogAnalyticsProvider,
+  XAdsAnalyticsProvider: () => XAdsAnalyticsProvider,
+  clearGlobalAnalytics: () => clearGlobalAnalytics,
+  createAnalytics: () => createAnalytics,
+  createSingletonAnalytics: () => createSingletonAnalytics,
+  default: () => AnalyticsManager,
+  getGlobalAnalytics: () => getGlobalAnalytics,
+  getGlobalAnalyticsNames: () => getGlobalAnalyticsNames,
+  getGlobalAnalyticsOptional: () => getGlobalAnalyticsOptional,
+  getSingletonAnalytics: () => getSingletonAnalytics,
+  getSingletonAnalyticsOptional: () => getSingletonAnalyticsOptional,
+  hasGlobalAnalytics: () => hasGlobalAnalytics,
+  hasSingletonAnalytics: () => hasSingletonAnalytics,
+  removeGlobalAnalytics: () => removeGlobalAnalytics,
+  resetSingletonAnalytics: () => resetSingletonAnalytics,
+  setGlobalAnalytics: () => setGlobalAnalytics
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/base.ts
+var BaseAnalytics = class {
+  constructor(config) {
+    var _a, _b;
+    this.debug = (_a = config.debug) != null ? _a : false;
+    this.enabled = (_b = config.enabled) != null ? _b : true;
+    this.business = config.business;
+  }
+  /**
+   * Check if provider is enabled
+   */
+  isEnabled() {
+    if (!this.enabled) {
+      this.log("Provider is disabled");
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Validate event data
+   */
+  validateEvent(event) {
+    if (!event.name) {
+      this.logError("Event name is required");
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Log debug message
+   */
+  log(message, data) {
+    if (this.debug) {
+      console.log(`[${this.getProviderName()}] ${message}`, data || "");
+    }
+  }
+  /**
+   * Log error message
+   */
+  logError(message, error) {
+    console.error(`[${this.getProviderName()}] ${message}`, error || "");
+  }
+  /**
+   * 丰富属性数据，自动处理 spm 前缀
+   * 确保无论通过哪种方式调用都会添加 business 前缀
+   */
+  enrichProperties(properties) {
+    const enriched = { ...properties };
+    enriched.business = this.business;
+    if (enriched.spm && typeof enriched.spm === "string" && enriched.spm.trim()) {
+      if (enriched.spm !== this.business && !enriched.spm.startsWith(`${this.business}.`)) {
+        enriched.spm = `${this.business}.${enriched.spm}`;
+      }
+    } else {
+      enriched.spm = this.business;
+    }
+    return enriched;
+  }
+};
+
+// src/manager.ts
+var AnalyticsManager = class {
+  constructor(business, debug = false) {
+    this.providers = /* @__PURE__ */ new Map();
+    this.globalContext = {};
+    this.initialized = false;
+    this.business = business;
+    this.debug = debug;
+  }
+  /**
+   * 注册分析工具提供商
+   */
+  registerProvider(name, provider) {
+    this.providers.set(name, provider);
+    this.log(`Registered provider: ${name}`);
+    return this;
+  }
+  /**
+   * 移除分析工具提供商
+   */
+  unregisterProvider(name) {
+    this.providers.delete(name);
+    this.log(`Unregistered provider: ${name}`);
+    return this;
+  }
+  getProvider(name) {
+    return this.providers.get(name);
+  }
+  /**
+   * 获取所有提供商
+   */
+  getAllProviders() {
+    return Array.from(this.providers.values());
+  }
+  /**
+   * 初始化所有提供商
+   */
+  async initialize() {
+    if (this.initialized) {
+      this.log("Already initialized");
+      return;
+    }
+    const results = await this.executeOnAllProviders("initialize");
+    this.initialized = true;
+    this.log(`Initialized ${results.success.length}/${this.providers.size} providers`);
+    if (results.errors.length > 0) {
+      console.warn(`[AnalyticsManager] ${results.errors.length} providers failed to initialize`);
+    }
+  }
+  /**
+   * 追踪事件到所有提供商
+   */
+  async track(event) {
+    if (!this.ensureInitialized()) return;
+    const enrichedEvent = this.enrichEvent(event);
+    await this.executeOnAllProviders("track", enrichedEvent);
+  }
+  /**
+   * 类型安全的事件追踪
+   */
+  async trackEvent(eventName, properties) {
+    await this.track({
+      name: eventName,
+      properties
+    });
+  }
+  /**
+   * 识别用户
+   */
+  async identify(userId, properties) {
+    if (!this.ensureInitialized()) return;
+    const mergedProperties = { ...this.globalContext, ...properties };
+    await this.executeOnAllProviders("identify", userId, mergedProperties);
+  }
+  /**
+   * 追踪页面浏览
+   */
+  async trackPageView(page, properties) {
+    if (!this.ensureInitialized()) return;
+    const mergedProperties = { ...this.globalContext, ...properties };
+    await this.executeOnAllProviders("trackPageView", page, mergedProperties);
+  }
+  /**
+   * 重置用户身份
+   */
+  async reset() {
+    if (!this.ensureInitialized()) return;
+    await this.executeOnAllProviders("reset");
+  }
+  /**
+   * 设置全局上下文
+   */
+  setGlobalContext(context) {
+    this.globalContext = { ...this.globalContext, ...context };
+    this.log("Updated global context", this.globalContext);
+    return this;
+  }
+  /**
+   * 获取全局上下文
+   */
+  getGlobalContext() {
+    return { ...this.globalContext };
+  }
+  /**
+   * 获取管理器状态
+   */
+  getStatus() {
+    return {
+      initialized: this.initialized,
+      providersCount: this.providers.size
+    };
+  }
+  /**
+   * 检查是否已初始化
+   */
+  ensureInitialized() {
+    if (!this.initialized) {
+      console.warn("[AnalyticsManager] Not initialized. Call initialize() first.");
+      return false;
+    }
+    return true;
+  }
+  /**
+   * 在所有提供商上执行操作
+   */
+  async executeOnAllProviders(method, ...args) {
+    const results = {
+      errors: [],
+      success: []
+    };
+    const promises = Array.from(this.providers.entries()).map(async ([name, provider]) => {
+      try {
+        await provider[method](...args);
+        results.success.push(name);
+      } catch (error) {
+        results.errors.push({ error, provider: name });
+        console.error(
+          `[AnalyticsManager] ${method} failed for ${provider.getProviderName()}:`,
+          error
+        );
+      }
+    });
+    await Promise.allSettled(promises);
+    return results;
+  }
+  /**
+   * 丰富事件数据
+   */
+  enrichEvent(event) {
+    return {
+      ...event,
+      properties: {
+        ...this.globalContext,
+        ...event.properties
+      },
+      timestamp: event.timestamp || /* @__PURE__ */ new Date()
+    };
+  }
+  /**
+   * 记录日志
+   */
+  log(message, data) {
+    if (this.debug) {
+      console.log(`[AnalyticsManager] ${message}`, data || "");
+    }
+  }
+};
+
+// src/providers/ga4.ts
+var GoogleAnalyticsProvider = class extends BaseAnalytics {
+  constructor(config, business) {
+    super({ business, debug: config.debug, enabled: config.enabled });
+    this.initialized = false;
+    this.config = config;
+  }
+  getProviderName() {
+    return "Google Analytics 4";
+  }
+  async initialize() {
+    var _a;
+    if (!this.isEnabled() || this.initialized) {
+      return;
+    }
+    try {
+      if (typeof window === "undefined") {
+        this.logError("GA4 provider requires browser environment");
+        return;
+      }
+      window.dataLayer = window.dataLayer || [];
+      const gtag = window.gtag || function() {
+        window.dataLayer.push(arguments);
+      };
+      window.gtag = gtag;
+      const existingScript = document.querySelector(
+        `script[src*="gtag/js"], script[id*="ga"], script[id*="gtag"]`
+      );
+      if (!existingScript) {
+        const script = document.createElement("script");
+        script.async = true;
+        script.src = `https://www.googletagmanager.com/gtag/js?id=${this.config.measurementId}`;
+        document.head.append(script);
+      }
+      gtag("js", /* @__PURE__ */ new Date());
+      const configOptions = {
+        // User's gtag config options
+        ...this.config.gtagConfig,
+        // Our internal config (these override user config for consistency)
+        debug_mode: this.debug || ((_a = this.config.gtagConfig) == null ? void 0 : _a.debug_mode)
+      };
+      gtag("config", this.config.measurementId, configOptions);
+      this.initialized = true;
+      this.log("Google Analytics 4 initialized successfully");
+      this.log(`Measurement ID: ${this.config.measurementId}`);
+      this.log(`Business context will be added to all events: ${this.business}`);
+    } catch (error) {
+      this.logError("Failed to initialize Google Analytics 4", error);
+      throw error;
+    }
+  }
+  async track(event) {
+    if (!this.isEnabled() || !this.initialized || !this.validateEvent(event)) {
+      return;
+    }
+    try {
+      const gtag = window.gtag;
+      if (!gtag) {
+        this.logError("gtag function not available");
+        return;
+      }
+      const enrichedProperties = this.enrichProperties(event.properties);
+      const eventParams = {
+        ...enrichedProperties,
+        // Add user_id if provided in the event
+        ...event.userId && { user_id: event.userId }
+      };
+      gtag("event", event.name, eventParams);
+      this.log(`Tracked event: ${event.name}`, { ...event, properties: enrichedProperties });
+    } catch (error) {
+      this.logError(`Failed to track event: ${event.name}`, error);
+    }
+  }
+  async identify(userId, properties) {
+    if (!this.isEnabled() || !this.initialized) {
+      return;
+    }
+    try {
+      const gtag = window.gtag;
+      if (!gtag) {
+        this.logError("gtag function not available");
+        return;
+      }
+      gtag("config", this.config.measurementId, {
+        user_id: userId
+      });
+      if (properties && Object.keys(properties).length > 0) {
+        const enrichedProperties = this.enrichProperties(properties);
+        gtag("set", {
+          user_properties: enrichedProperties
+        });
+      }
+      gtag("event", "login", {
+        user_id: userId,
+        ...this.enrichProperties()
+      });
+      this.log(`Identified user: ${userId}`, properties);
+    } catch (error) {
+      this.logError(`Failed to identify user: ${userId}`, error);
+    }
+  }
+  async trackPageView(page, properties) {
+    if (!this.isEnabled() || !this.initialized) {
+      return;
+    }
+    try {
+      const enrichedProperties = this.enrichProperties(properties);
+      await this.track({
+        name: "page_view",
+        properties: {
+          page_location: page,
+          page_title: page,
+          ...enrichedProperties
+        }
+      });
+      this.log(`Tracked page view: ${page}`, enrichedProperties);
+    } catch (error) {
+      this.logError(`Failed to track page view: ${page}`, error);
+    }
+  }
+  async reset() {
+    if (!this.isEnabled() || !this.initialized) {
+      return;
+    }
+    try {
+      const gtag = window.gtag;
+      if (!gtag) {
+        this.logError("gtag function not available");
+        return;
+      }
+      gtag("config", this.config.measurementId, {
+        user_id: null
+      });
+      gtag("set", {
+        user_properties: {}
+      });
+      gtag("event", "logout", this.enrichProperties());
+      this.log("Reset user identity and tracked logout");
+    } catch (error) {
+      this.logError("Failed to reset user identity", error);
+    }
+  }
+  /**
+   * Check if feature flag is enabled
+   * Note: GA4 doesn't have built-in feature flags like PostHog,
+   * so this always returns false
+   */
+  isFeatureEnabled(flag) {
+    this.log(`Feature flags not supported in GA4. Flag "${flag}" returns false`);
+    return false;
+  }
+  /**
+   * Get the native gtag function for direct access to GA4 APIs
+   *
+   * Note: When using the native gtag function directly, events will NOT automatically
+   * include the business and spm properties. You need to add them manually if desired.
+   *
+   * @returns gtag function or null if not initialized
+   *
+   * @example
+   * ```typescript
+   * const analytics = createAnalytics({ business: 'myapp', ... });
+   * const ga4Provider = analytics.getProvider('ga4');
+   * const gtag = ga4Provider.getNativeInstance();
+   *
+   * // Manual business context addition required for direct calls
+   * gtag?.('event', 'custom_event', {
+   *   custom: 'data',
+   *   business: 'myapp',
+   *   spm: 'myapp.custom_section'
+   * });
+   * ```
+   */
+  getNativeInstance() {
+    if (!this.isEnabled() || !this.initialized) {
+      this.log("Cannot get native instance: provider not enabled or not initialized");
+      return null;
+    }
+    const gtag = window.gtag;
+    if (!gtag) {
+      this.log("gtag function not available");
+      return null;
+    }
+    return gtag;
+  }
+  /**
+   * Get current measurement ID
+   */
+  getMeasurementId() {
+    return this.config.measurementId;
+  }
+  /**
+   * Get current business context
+   */
+  getCurrentBusiness() {
+    return this.business;
+  }
+};
+
+// src/providers/posthog.ts
+var import_posthog_js = require("posthog-js");
+var PostHogAnalyticsProvider = class extends BaseAnalytics {
+  constructor(config, business) {
+    super({ business, debug: config.debug, enabled: config.enabled });
+    this.initialized = false;
+    this.config = config;
+  }
+  getProviderName() {
+    return "PostHog";
+  }
+  async initialize() {
+    var _a;
+    if (!this.isEnabled() || this.initialized) {
+      return;
+    }
+    try {
+      const { key, host, ...posthogConfig } = this.config;
+      const initConfig = {
+        ...posthogConfig,
+        // User's posthog-js config options
+        api_host: host || posthogConfig.api_host || "https://app.posthog.com",
+        capture_pageview: (_a = posthogConfig.capture_pageview) != null ? _a : "history_change",
+        // Use before_send to dynamically add business context to all events
+        before_send: this.createBeforeSendHandler(posthogConfig.before_send),
+        debug: this.debug,
+        loaded: () => this.log("PostHog loaded and ready")
+      };
+      import_posthog_js.posthog.init(key, initConfig);
+      this.initialized = true;
+      this.log("PostHog initialized successfully");
+      this.log(`Using before_send to add business context: ${this.business}`);
+    } catch (error) {
+      this.logError("Failed to initialize PostHog", error);
+      throw error;
+    }
+  }
+  async track(event) {
+    if (!this.isEnabled() || !this.initialized || !this.validateEvent(event)) {
+      return;
+    }
+    try {
+      const enrichedProperties = this.enrichProperties(event.properties);
+      import_posthog_js.posthog.capture(event.name, {
+        ...enrichedProperties,
+        ...event.userId && { distinct_id: event.userId }
+      });
+      this.log(`Tracked event: ${event.name}`, { ...event, properties: enrichedProperties });
+    } catch (error) {
+      this.logError(`Failed to track event: ${event.name}`, error);
+    }
+  }
+  async identify(userId, properties) {
+    if (!this.isEnabled() || !this.initialized) {
+      return;
+    }
+    try {
+      const enrichedProperties = this.enrichProperties(properties);
+      import_posthog_js.posthog.identify(userId, enrichedProperties);
+      this.log(`Identified user: ${userId}`, enrichedProperties);
+    } catch (error) {
+      this.logError(`Failed to identify user: ${userId}`, error);
+    }
+  }
+  async trackPageView(page, properties) {
+    if (!this.isEnabled() || !this.initialized) {
+      return;
+    }
+    try {
+      const enrichedProperties = this.enrichProperties(properties);
+      await this.track({
+        name: "$pageview",
+        properties: { page, ...enrichedProperties }
+      });
+      this.log(`Tracked page view: ${page}`, enrichedProperties);
+    } catch (error) {
+      this.logError(`Failed to track page view: ${page}`, error);
+    }
+  }
+  async reset() {
+    if (!this.isEnabled() || !this.initialized) {
+      return;
+    }
+    try {
+      import_posthog_js.posthog.reset();
+      this.log("Reset user identity");
+    } catch (error) {
+      this.logError("Failed to reset user identity", error);
+    }
+  }
+  /**
+   * Check if feature flag is enabled
+   */
+  isFeatureEnabled(flag) {
+    if (!this.initialized) {
+      return false;
+    }
+    try {
+      return Boolean(import_posthog_js.posthog.isFeatureEnabled(flag));
+    } catch (error) {
+      this.logError(`Failed to check feature flag: ${flag}`, error);
+      return false;
+    }
+  }
+  /**
+   * Get the native PostHog instance for direct access to PostHog APIs
+   *
+   * Note: When using the native instance directly, events will still include
+   * the business spm prefix because it's registered as a global property.
+   *
+   * @returns PostHog native instance or null if not initialized
+   *
+   * @example
+   * ```typescript
+   * const analytics = createAnalytics({ business: 'myapp', ... });
+   * const posthogProvider = analytics.getProvider('posthog');
+   * const posthog = posthogProvider.getNativeInstance();
+   *
+   * // These calls will automatically include spm: 'myapp'
+   * posthog?.capture('custom_event', { custom: 'data' });
+   * posthog?.isFeatureEnabled('new_feature');
+   * posthog?.group('company', 'company_123');
+   * ```
+   */
+  getNativeInstance() {
+    if (!this.isEnabled() || !this.initialized) {
+      this.log("Cannot get native instance: provider not enabled or not initialized");
+      return null;
+    }
+    return import_posthog_js.posthog;
+  }
+  /**
+   * Create a before_send handler that adds business context to all events
+   * This ensures both wrapper calls and direct PostHog calls include business information
+   */
+  createBeforeSendHandler(userBeforeSend) {
+    return (event) => {
+      var _a;
+      if (!event) {
+        return null;
+      }
+      const originallyHadSpm = ((_a = event.properties) == null ? void 0 : _a.spm) !== void 0;
+      let processedEvent = event;
+      if (userBeforeSend) {
+        if (Array.isArray(userBeforeSend)) {
+          for (const fn of userBeforeSend) {
+            processedEvent = fn(processedEvent);
+            if (!processedEvent) {
+              return null;
+            }
+          }
+        } else if (typeof userBeforeSend === "function") {
+          processedEvent = userBeforeSend(processedEvent);
+          if (!processedEvent) {
+            return null;
+          }
+        }
+      }
+      if (!processedEvent.properties) {
+        processedEvent.properties = {};
+      }
+      processedEvent.properties.business = this.business;
+      const currentSpm = processedEvent.properties.spm;
+      const shouldSetDefaultSpm = !originallyHadSpm && (!currentSpm || typeof currentSpm === "string" && !currentSpm.trim());
+      if (shouldSetDefaultSpm) {
+        processedEvent.properties.spm = this.business;
+      }
+      return processedEvent;
+    };
+  }
+  /**
+   * Update the business context dynamically
+   * This will affect all future events
+   */
+  updateBusiness(newBusiness) {
+    if (!this.isEnabled() || !this.initialized) {
+      this.log("Cannot update business: provider not enabled or not initialized");
+      return;
+    }
+    this.log(`Business update requested: ${newBusiness} (current: ${this.business})`);
+    this.log("Note: Dynamic business updates require storing business in a mutable field");
+  }
+  /**
+   * Get current business context
+   */
+  getCurrentBusiness() {
+    return this.business;
+  }
+};
+
+// src/providers/xads.ts
+var X_ADS_SCRIPT_SELECTOR = 'script[src="https://static.ads-twitter.com/uwt.js"]';
+var X_ADS_SCRIPT_SRC = "https://static.ads-twitter.com/uwt.js";
+var XAdsAnalyticsProvider = class extends BaseAnalytics {
+  constructor(config, business) {
+    super({ business, debug: config.debug, enabled: config.enabled });
+    this.initialized = false;
+    this.config = config;
+  }
+  getProviderName() {
+    return "X Ads";
+  }
+  async initialize() {
+    if (!this.isEnabled() || this.initialized) {
+      return;
+    }
+    if (typeof window === "undefined") {
+      this.logError("X Ads provider requires browser environment");
+      return;
+    }
+    if (!this.config.pixelId) {
+      this.logError("X Ads pixelId is required");
+      return;
+    }
+    try {
+      const twq = this.ensureTwq();
+      const state = this.getGlobalState();
+      this.ensureScript(state);
+      if (!state.configuredPixelIds.has(this.config.pixelId)) {
+        twq("config", this.config.pixelId);
+        state.configuredPixelIds.add(this.config.pixelId);
+      }
+      this.initialized = true;
+      this.log("X Ads initialized successfully");
+      this.log(`Pixel ID: ${this.config.pixelId}`);
+    } catch (error) {
+      this.logError("Failed to initialize X Ads", error);
+      throw error;
+    }
+  }
+  async track(event) {
+    if (!this.isEnabled() || !this.initialized || !this.validateEvent(event)) {
+      return;
+    }
+    const eventId = this.getEventId(event.name);
+    if (!eventId) {
+      this.log(`Skipping event: ${event.name} is not configured for X Ads`);
+      return;
+    }
+    const twq = window.twq;
+    if (!twq) {
+      this.logError("twq function not available");
+      return;
+    }
+    try {
+      const eventParams = this.getEventParameters(event);
+      if (eventParams) {
+        twq("event", eventId, eventParams);
+      } else {
+        twq("event", eventId);
+      }
+      this.log(`Tracked event: ${event.name}`, {
+        event: event.name,
+        eventId,
+        ...eventParams
+      });
+    } catch (error) {
+      this.logError(`Failed to track event: ${event.name}`, error);
+    }
+  }
+  async identify() {
+    this.log("Identify is not supported in X Ads provider");
+  }
+  async trackPageView() {
+    this.log("Page views are handled by the X Pixel base code");
+  }
+  async reset() {
+    this.log("Reset is not supported in X Ads provider");
+  }
+  ensureScript(state) {
+    if (state.scriptRequested || document.querySelector(X_ADS_SCRIPT_SELECTOR)) {
+      state.scriptRequested = true;
+      return;
+    }
+    const script = document.createElement("script");
+    script.async = true;
+    script.src = X_ADS_SCRIPT_SRC;
+    document.head.append(script);
+    state.scriptRequested = true;
+  }
+  ensureTwq() {
+    if (window.twq) {
+      return window.twq;
+    }
+    const twq = (...args) => {
+      if (twq.exe) {
+        twq.exe(...args);
+        return;
+      }
+      const queue = twq.queue || [];
+      queue.push(args);
+      twq.queue = queue;
+    };
+    twq.version = "1.1";
+    twq.queue = [];
+    window.twq = twq;
+    return twq;
+  }
+  getGlobalState() {
+    if (!window.__HUBSTR_ANALYTICS_X_ADS_STATE__) {
+      window.__HUBSTR_ANALYTICS_X_ADS_STATE__ = {
+        configuredPixelIds: /* @__PURE__ */ new Set(),
+        scriptRequested: false
+      };
+    }
+    return window.__HUBSTR_ANALYTICS_X_ADS_STATE__;
+  }
+  getEventId(eventName) {
+    var _a, _b, _c;
+    if (eventName === "purchase") {
+      return (_b = this.config.purchaseEventId) != null ? _b : (_a = this.config.eventIds) == null ? void 0 : _a[eventName];
+    }
+    return (_c = this.config.eventIds) == null ? void 0 : _c[eventName];
+  }
+  getEventParameters(event) {
+    if (event.name === "purchase") {
+      return this.mapPurchaseEventParameters(event.properties);
+    }
+    return void 0;
+  }
+  mapPurchaseEventParameters(properties) {
+    const eventParams = {};
+    const currency = properties == null ? void 0 : properties.currency;
+    if (typeof currency === "string" && currency.trim()) {
+      eventParams.currency = currency.trim().toUpperCase();
+    }
+    const value = this.toFiniteNumber(properties == null ? void 0 : properties.value);
+    if (value !== void 0) {
+      eventParams.value = value;
+    }
+    const transactionId = properties == null ? void 0 : properties.transaction_id;
+    if (typeof transactionId === "string" || typeof transactionId === "number") {
+      eventParams.conversion_id = String(transactionId);
+    }
+    const contents = this.mapContents(properties == null ? void 0 : properties.items);
+    if (contents.length > 0) {
+      eventParams.contents = contents;
+    }
+    return eventParams;
+  }
+  mapContents(items) {
+    if (!Array.isArray(items)) {
+      return [];
+    }
+    const contents = items.map((item) => {
+      if (!item || typeof item !== "object") {
+        return null;
+      }
+      const content = item;
+      const contentItem = {};
+      const contentPrice = this.toFiniteNumber(content.price);
+      const numItems = this.toFiniteNumber(content.quantity);
+      if (typeof content.item_id === "string" && content.item_id.trim()) {
+        contentItem.content_id = content.item_id;
+      }
+      if (typeof content.item_name === "string" && content.item_name.trim()) {
+        contentItem.content_name = content.item_name;
+      }
+      if (contentPrice !== void 0) {
+        contentItem.content_price = contentPrice;
+      }
+      if (numItems !== void 0) {
+        contentItem.num_items = numItems;
+      }
+      return Object.keys(contentItem).length > 0 ? contentItem : null;
+    }).filter((content) => content !== null);
+    return contents;
+  }
+  toFiniteNumber(value) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+      return value;
+    }
+    if (typeof value === "string" && value.trim()) {
+      const parsed = Number(value);
+      if (Number.isFinite(parsed)) {
+        return parsed;
+      }
+    }
+    return void 0;
+  }
+};
+
+// src/config.ts
+function createAnalytics(config) {
+  var _a, _b, _c, _d;
+  const manager = new AnalyticsManager(config.business, config.debug);
+  if ((_a = config.providers.posthog) == null ? void 0 : _a.enabled) {
+    const provider = new PostHogAnalyticsProvider(config.providers.posthog, config.business);
+    manager.registerProvider("posthog", provider);
+  }
+  if ((_b = config.providers.ga4) == null ? void 0 : _b.enabled) {
+    const provider = new GoogleAnalyticsProvider(config.providers.ga4, config.business);
+    manager.registerProvider("ga4", provider);
+  }
+  if ((_c = config.providers.xAds) == null ? void 0 : _c.enabled) {
+    const provider = new XAdsAnalyticsProvider(config.providers.xAds, config.business);
+    manager.registerProvider("xAds", provider);
+  }
+  if ((_d = config.providers.posthogNode) == null ? void 0 : _d.enabled) {
+    console.warn(
+      'PostHog Node.js provider is not available in the client entry point. Please use "@hubstr/kit/analytics/server" for server-side analytics.'
+    );
+  }
+  return manager;
+}
+
+// src/global.ts
+var GLOBAL_STATE_KEY = "__HUBSTR_ANALYTICS_GLOBAL_STATE__";
+function getGlobalState() {
+  if (!globalThis[GLOBAL_STATE_KEY]) {
+    globalThis[GLOBAL_STATE_KEY] = {
+      instances: /* @__PURE__ */ new Map(),
+      singletonConfig: null,
+      singletonInstance: null
+    };
+  }
+  return globalThis[GLOBAL_STATE_KEY];
+}
+var DEFAULT_INSTANCE_NAME = "__default__";
+function setGlobalAnalytics(instance, name = DEFAULT_INSTANCE_NAME) {
+  const state = getGlobalState();
+  state.instances.set(name, instance);
+}
+function getGlobalAnalytics(name = DEFAULT_INSTANCE_NAME) {
+  const state = getGlobalState();
+  const instance = state.instances.get(name);
+  if (!instance) {
+    throw new Error(
+      `Global analytics instance "${name}" not found. Make sure to register it first using setGlobalAnalytics() or use AnalyticsProvider.`
+    );
+  }
+  return instance;
+}
+function getGlobalAnalyticsOptional(name = DEFAULT_INSTANCE_NAME) {
+  const state = getGlobalState();
+  return state.instances.get(name) || null;
+}
+function hasGlobalAnalytics(name = DEFAULT_INSTANCE_NAME) {
+  const state = getGlobalState();
+  return state.instances.has(name);
+}
+function removeGlobalAnalytics(name = DEFAULT_INSTANCE_NAME) {
+  const state = getGlobalState();
+  return state.instances.delete(name);
+}
+function clearGlobalAnalytics() {
+  const state = getGlobalState();
+  state.instances.clear();
+}
+function getGlobalAnalyticsNames() {
+  const state = getGlobalState();
+  return Array.from(state.instances.keys());
+}
+function isConfigEqual(config1, config2) {
+  try {
+    return JSON.stringify(config1) === JSON.stringify(config2);
+  } catch (e) {
+    return false;
+  }
+}
+function createSingletonAnalytics(config) {
+  const state = getGlobalState();
+  if (state.singletonInstance && state.singletonConfig && isConfigEqual(state.singletonConfig, config)) {
+    return state.singletonInstance;
+  }
+  state.singletonInstance = createAnalytics(config);
+  state.singletonConfig = config;
+  setGlobalAnalytics(state.singletonInstance);
+  return state.singletonInstance;
+}
+function getSingletonAnalytics() {
+  const state = getGlobalState();
+  if (!state.singletonInstance) {
+    throw new Error(
+      "Singleton analytics instance not created. Call createSingletonAnalytics() first or use getGlobalAnalytics()."
+    );
+  }
+  return state.singletonInstance;
+}
+function getSingletonAnalyticsOptional() {
+  const state = getGlobalState();
+  return state.singletonInstance;
+}
+function hasSingletonAnalytics() {
+  const state = getGlobalState();
+  return state.singletonInstance !== null;
+}
+function resetSingletonAnalytics() {
+  const state = getGlobalState();
+  state.singletonInstance = null;
+  state.singletonConfig = null;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AnalyticsManager,
+  BaseAnalytics,
+  GoogleAnalyticsProvider,
+  PostHogAnalyticsProvider,
+  XAdsAnalyticsProvider,
+  clearGlobalAnalytics,
+  createAnalytics,
+  createSingletonAnalytics,
+  getGlobalAnalytics,
+  getGlobalAnalyticsNames,
+  getGlobalAnalyticsOptional,
+  getSingletonAnalytics,
+  getSingletonAnalyticsOptional,
+  hasGlobalAnalytics,
+  hasSingletonAnalytics,
+  removeGlobalAnalytics,
+  resetSingletonAnalytics,
+  setGlobalAnalytics
+});
+//# sourceMappingURL=index.js.map