@qhr123/sa2kit 0.2.0 → 0.3.1

package/dist/analytics/index.js

@@ -0,0 +1,1215 @@
+'use strict';
+
+var react = require('react');
+
+// src/analytics/types.ts
+var EventType = /* @__PURE__ */ ((EventType2) => {
+  EventType2["PAGE_VIEW"] = "page_view";
+  EventType2["PAGE_LEAVE"] = "page_leave";
+  EventType2["CLICK"] = "click";
+  EventType2["SCROLL"] = "scroll";
+  EventType2["INPUT"] = "input";
+  EventType2["SUBMIT"] = "submit";
+  EventType2["LOGIN"] = "login";
+  EventType2["LOGOUT"] = "logout";
+  EventType2["REGISTER"] = "register";
+  EventType2["SEARCH"] = "search";
+  EventType2["SHARE"] = "share";
+  EventType2["PERFORMANCE"] = "performance";
+  EventType2["ERROR"] = "error";
+  EventType2["API_CALL"] = "api_call";
+  EventType2["CUSTOM"] = "custom";
+  return EventType2;
+})(EventType || {});
+var EventPriority = /* @__PURE__ */ ((EventPriority2) => {
+  EventPriority2[EventPriority2["LOW"] = 0] = "LOW";
+  EventPriority2[EventPriority2["NORMAL"] = 1] = "NORMAL";
+  EventPriority2[EventPriority2["HIGH"] = 2] = "HIGH";
+  EventPriority2[EventPriority2["CRITICAL"] = 3] = "CRITICAL";
+  return EventPriority2;
+})(EventPriority || {});
+
+// src/analytics/core/EventQueue.ts
+var EventQueue = class {
+  constructor(maxSize = 100) {
+    this.queue = [];
+    this.maxSize = maxSize;
+  }
+  /**
+   * 添加事件到队列
+   */
+  enqueue(event) {
+    if (this.queue.length >= this.maxSize) {
+      this.removeLowestPriorityEvent();
+    }
+    this.queue.push(event);
+    this.queue.sort((a, b) => b.priority - a.priority);
+  }
+  /**
+   * 批量添加事件
+   */
+  enqueueBatch(events) {
+    events.forEach((event) => this.enqueue(event));
+  }
+  /**
+   * 获取指定数量的事件
+   */
+  dequeue(count) {
+    return this.queue.splice(0, count);
+  }
+  /**
+   * 获取所有事件
+   */
+  dequeueAll() {
+    const events = [...this.queue];
+    this.queue = [];
+    return events;
+  }
+  /**
+   * 获取高优先级事件
+   */
+  getHighPriorityEvents() {
+    const highPriorityEvents = this.queue.filter(
+      (event) => event.priority >= 2
+      // HIGH 和 CRITICAL
+    );
+    this.queue = this.queue.filter((event) => event.priority < 2);
+    return highPriorityEvents;
+  }
+  /**
+   * 查看队列长度
+   */
+  size() {
+    return this.queue.length;
+  }
+  /**
+   * 队列是否为空
+   */
+  isEmpty() {
+    return this.queue.length === 0;
+  }
+  /**
+   * 队列是否已满
+   */
+  isFull() {
+    return this.queue.length >= this.maxSize;
+  }
+  /**
+   * 清空队列
+   */
+  clear() {
+    this.queue = [];
+  }
+  /**
+   * 移除最低优先级的事件
+   */
+  removeLowestPriorityEvent() {
+    if (this.queue.length === 0) return;
+    let lowestPriorityIndex = 0;
+    let lowestPriority = this.queue[0]?.priority ?? 0;
+    for (let i = 1; i < this.queue.length; i++) {
+      const currentPriority = this.queue[i]?.priority ?? 0;
+      if (currentPriority < lowestPriority) {
+        lowestPriority = currentPriority;
+        lowestPriorityIndex = i;
+      }
+    }
+    this.queue.splice(lowestPriorityIndex, 1);
+  }
+  /**
+   * 获取队列快照（不移除事件）
+   */
+  snapshot() {
+    return [...this.queue];
+  }
+};
+
+// src/analytics/core/Uploader.ts
+var Uploader = class {
+  constructor(config) {
+    this.uploading = false;
+    this.retryQueue = /* @__PURE__ */ new Map();
+    this.config = config;
+  }
+  /**
+   * 上传事件
+   */
+  async upload(events) {
+    if (events.length === 0) return true;
+    const isOnline = await this.config.networkAdapter.isOnline();
+    if (!isOnline) {
+      await this.saveToLocal(events);
+      return false;
+    }
+    try {
+      this.uploading = true;
+      const response = await this.config.networkAdapter.upload(this.config.endpoint, events);
+      if (response.success) {
+        this.config.onSuccess?.(events);
+        return true;
+      } else {
+        throw new Error(response.message || "Upload failed");
+      }
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      this.config.onError?.(err, events);
+      await this.addToRetryQueue(events);
+      return false;
+    } finally {
+      this.uploading = false;
+    }
+  }
+  /**
+   * 批量上传
+   */
+  async uploadBatch(events) {
+    const batches = this.splitIntoBatches(events, this.config.batchSize);
+    const results = await Promise.all(batches.map((batch) => this.upload(batch)));
+    return results.every((result) => result);
+  }
+  /**
+   * 重试失败的上传
+   */
+  async retryFailedUploads() {
+    if (this.uploading || this.retryQueue.size === 0) return;
+    const isOnline = await this.config.networkAdapter.isOnline();
+    if (!isOnline) return;
+    const entries = Array.from(this.retryQueue.entries());
+    for (const [key, item] of entries) {
+      if (item.retryCount >= this.config.retryTimes) {
+        await this.saveToLocal(item.events);
+        this.retryQueue.delete(key);
+        continue;
+      }
+      await this.delay(this.config.retryInterval * (item.retryCount + 1));
+      const success = await this.upload(item.events);
+      if (success) {
+        this.retryQueue.delete(key);
+      } else {
+        item.retryCount++;
+      }
+    }
+  }
+  /**
+   * 上传本地缓存的事件
+   */
+  async uploadCachedEvents() {
+    try {
+      const cachedEvents = await this.config.storageAdapter.getEvents();
+      if (cachedEvents.length > 0) {
+        const success = await this.uploadBatch(cachedEvents);
+        if (success) {
+          await this.config.storageAdapter.clearEvents();
+        }
+      }
+    } catch (error) {
+      console.error("Failed to upload cached events:", error);
+    }
+  }
+  /**
+   * 保存事件到本地存储
+   */
+  async saveToLocal(events) {
+    try {
+      const existingEvents = await this.config.storageAdapter.getEvents();
+      const allEvents = [...existingEvents, ...events];
+      await this.config.storageAdapter.saveEvents(allEvents);
+    } catch (error) {
+      console.error("Failed to save events to local storage:", error);
+    }
+  }
+  /**
+   * 添加到重试队列
+   */
+  async addToRetryQueue(events) {
+    const key = `${Date.now()}_${Math.random()}`;
+    this.retryQueue.set(key, {
+      events,
+      retryCount: 0
+    });
+  }
+  /**
+   * 分割成批次
+   */
+  splitIntoBatches(events, batchSize) {
+    const batches = [];
+    for (let i = 0; i < events.length; i += batchSize) {
+      batches.push(events.slice(i, i + batchSize));
+    }
+    return batches;
+  }
+  /**
+   * 延迟函数
+   */
+  delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  /**
+   * 是否正在上传
+   */
+  isUploading() {
+    return this.uploading;
+  }
+  /**
+   * 获取重试队列大小
+   */
+  getRetryQueueSize() {
+    return this.retryQueue.size;
+  }
+  /**
+   * 清空重试队列
+   */
+  clearRetryQueue() {
+    this.retryQueue.clear();
+  }
+};
+
+// src/analytics/core/Analytics.ts
+var SDK_VERSION = "1.0.0";
+var Analytics = class {
+  constructor(config, storageAdapter, networkAdapter, deviceAdapter) {
+    this.sessionId = "";
+    this.deviceId = "";
+    this.deviceInfo = null;
+    this.initialized = false;
+    this.batchTimer = null;
+    if (config.adapter) {
+      this.storageAdapter = config.adapter.storage;
+      this.networkAdapter = config.adapter.network;
+      this.deviceAdapter = config.adapter.device;
+    } else if (storageAdapter && networkAdapter && deviceAdapter) {
+      this.storageAdapter = storageAdapter;
+      this.networkAdapter = networkAdapter;
+      this.deviceAdapter = deviceAdapter;
+    } else {
+      throw new Error("Analytics initialization failed: adapter is required");
+    }
+    const serverUrl = config.serverUrl || config.endpoint || "/api/analytics/events";
+    const platform = config.platform || "web";
+    this.config = {
+      ...config,
+      appId: config.appId,
+      appVersion: config.appVersion || "1.0.0",
+      platform,
+      endpoint: serverUrl,
+      batchSize: config.batchSize ?? 10,
+      batchInterval: config.batchInterval ?? 5e3,
+      maxQueueSize: config.maxQueueSize ?? 100,
+      retryTimes: config.retryTimes ?? 3,
+      retryInterval: config.retryInterval ?? 1e3,
+      enableAutoPageView: config.enableAutoPageView ?? true,
+      enableAutoClick: config.enableAutoClick ?? false,
+      enableAutoError: config.enableAutoError ?? true,
+      enableAutoPerformance: config.enableAutoPerformance ?? true,
+      debug: config.debug ?? false,
+      ignoreUrls: config.ignoreUrls ?? [],
+      ignoreErrors: config.ignoreErrors ?? [],
+      beforeSend: config.beforeSend
+    };
+    this.eventQueue = new EventQueue(this.config.maxQueueSize);
+    this.uploader = new Uploader({
+      endpoint: this.config.endpoint,
+      batchSize: this.config.batchSize,
+      retryTimes: this.config.retryTimes,
+      retryInterval: this.config.retryInterval,
+      networkAdapter: this.networkAdapter,
+      storageAdapter: this.storageAdapter,
+      onSuccess: (events) => this.onUploadSuccess(events),
+      onError: (error, events) => this.onUploadError(error, events)
+    });
+    this.init().catch((error) => {
+      console.error("Failed to initialize Analytics:", error);
+    });
+  }
+  /**
+   * 初始化
+   */
+  async init() {
+    if (this.initialized) {
+      this.log("Analytics already initialized");
+      return;
+    }
+    try {
+      await this.initDeviceInfo();
+      await this.initSession();
+      await this.uploader.uploadCachedEvents();
+      this.startBatchTimer();
+      if (typeof window !== "undefined") {
+        window.addEventListener("analytics-debug-changed", ((e) => {
+          this.log(`Debug mode changed: ${e.detail.enabled ? "enabled" : "disabled"}`);
+        }));
+      }
+      this.initialized = true;
+      this.log("Analytics initialized successfully");
+    } catch (error) {
+      console.error("Failed to initialize analytics:", error);
+      throw error;
+    }
+  }
+  /**
+   * 追踪事件（简化版本，支持两种调用方式）
+   */
+  track(eventNameOrType, propertiesOrName, maybeProperties, priority = 1 /* NORMAL */) {
+    if (!this.initialized) {
+      console.warn("Analytics not initialized yet, queuing event...");
+      setTimeout(
+        () => this.track(eventNameOrType, propertiesOrName, maybeProperties, priority),
+        100
+      );
+      return;
+    }
+    let eventType;
+    let eventName;
+    let properties;
+    if (typeof propertiesOrName === "string") {
+      eventType = eventNameOrType;
+      eventName = propertiesOrName;
+      properties = maybeProperties;
+    } else {
+      eventType = "custom" /* CUSTOM */;
+      eventName = eventNameOrType;
+      properties = propertiesOrName;
+    }
+    const event = this.createEvent(eventType, eventName, properties, priority);
+    const processedEvent = this.config.beforeSend?.(event) ?? event;
+    if (!processedEvent) {
+      this.log("Event filtered by beforeSend hook", event);
+      return;
+    }
+    this.eventQueue.enqueue(processedEvent);
+    this.log("Event tracked", processedEvent);
+    if (priority >= 2 /* HIGH */) {
+      this.flushHighPriority();
+    }
+    if (this.eventQueue.isFull()) {
+      this.flush();
+    }
+  }
+  /**
+   * 追踪页面浏览
+   */
+  trackPageView(pageUrl, pageTitle, properties) {
+    this.track(
+      "page_view" /* PAGE_VIEW */,
+      "page_view",
+      {
+        page_url: pageUrl,
+        page_title: pageTitle,
+        ...properties
+      },
+      1 /* NORMAL */
+    );
+  }
+  /**
+   * 追踪点击事件
+   */
+  trackClick(elementInfo, properties) {
+    this.track(
+      "click" /* CLICK */,
+      "click",
+      {
+        ...elementInfo,
+        ...properties
+      },
+      0 /* LOW */
+    );
+  }
+  /**
+   * 追踪错误
+   */
+  trackError(errorMessage, errorStack, errorType, properties) {
+    this.track(
+      "error" /* ERROR */,
+      "error",
+      {
+        error_message: errorMessage,
+        error_stack: errorStack,
+        error_type: errorType,
+        ...properties
+      },
+      2 /* HIGH */
+    );
+  }
+  /**
+   * 追踪性能指标
+   */
+  trackPerformance(metricName, metricValue, metricUnit, properties) {
+    this.track(
+      "performance" /* PERFORMANCE */,
+      "performance",
+      {
+        metric_name: metricName,
+        metric_value: metricValue,
+        metric_unit: metricUnit,
+        ...properties
+      },
+      0 /* LOW */
+    );
+  }
+  /**
+   * 追踪 API 调用
+   */
+  trackApiCall(apiUrl, apiMethod, apiStatus, duration, success, properties) {
+    this.track(
+      "api_call" /* API_CALL */,
+      "api_call",
+      {
+        api_url: apiUrl,
+        api_method: apiMethod,
+        api_status: apiStatus,
+        duration,
+        success,
+        ...properties
+      },
+      1 /* NORMAL */
+    );
+  }
+  /**
+   * 设置用户ID
+   */
+  setUserId(userId) {
+    this.config.userId = userId;
+    this.log("User ID set", userId);
+  }
+  /**
+   * 设置用户信息（包括用户ID和其他属性）
+   */
+  setUser(userInfo) {
+    const { userId, ...otherProps } = userInfo;
+    this.config.userId = userId;
+    this.config.customProperties = {
+      ...this.config.customProperties,
+      ...otherProps
+    };
+    this.log("User info set", userInfo);
+  }
+  /**
+   * 设置自定义属性
+   */
+  setCustomProperties(properties) {
+    this.config.customProperties = {
+      ...this.config.customProperties,
+      ...properties
+    };
+    this.log("Custom properties set", properties);
+  }
+  /**
+   * 立即上传所有事件
+   */
+  async flush() {
+    if (this.eventQueue.isEmpty()) {
+      return;
+    }
+    const events = this.eventQueue.dequeueAll();
+    await this.uploader.upload(events);
+  }
+  /**
+   * 立即上传高优先级事件
+   */
+  async flushHighPriority() {
+    const highPriorityEvents = this.eventQueue.getHighPriorityEvents();
+    if (highPriorityEvents.length > 0) {
+      await this.uploader.upload(highPriorityEvents);
+    }
+  }
+  /**
+   * 销毁实例
+   */
+  async destroy() {
+    if (this.batchTimer) {
+      clearInterval(this.batchTimer);
+      this.batchTimer = null;
+    }
+    await this.flush();
+    this.initialized = false;
+    this.log("Analytics destroyed");
+  }
+  /**
+   * 创建事件对象
+   */
+  createEvent(eventType, eventName, properties, priority = 1 /* NORMAL */) {
+    let pageUrl;
+    let pageTitle;
+    let referrer;
+    if (typeof window !== "undefined") {
+      pageUrl = window.location.href;
+      pageTitle = document.title;
+      referrer = document.referrer || void 0;
+    }
+    return {
+      event_id: this.generateEventId(),
+      event_type: eventType,
+      event_name: eventName,
+      timestamp: Date.now(),
+      priority,
+      user_id: this.config.userId,
+      session_id: this.sessionId,
+      device_id: this.deviceId,
+      page_url: pageUrl,
+      page_title: pageTitle,
+      referrer,
+      properties: {
+        ...this.config.customProperties,
+        ...properties
+      },
+      platform: this.getPlatform(),
+      app_version: this.config.appVersion,
+      sdk_version: SDK_VERSION
+    };
+  }
+  /**
+   * 初始化设备信息
+   */
+  async initDeviceInfo() {
+    try {
+      let cachedDeviceInfo = await this.storageAdapter.getDeviceInfo();
+      if (!cachedDeviceInfo) {
+        this.deviceInfo = await this.deviceAdapter.getDeviceInfo();
+        this.deviceId = await this.deviceAdapter.generateDeviceId();
+        await this.storageAdapter.saveDeviceInfo(this.deviceInfo);
+      } else {
+        this.deviceInfo = cachedDeviceInfo;
+        this.deviceId = cachedDeviceInfo.device_id;
+      }
+    } catch (error) {
+      console.error("Failed to init device info:", error);
+      this.deviceId = `temp_${Date.now()}_${Math.random()}`;
+    }
+  }
+  /**
+   * 初始化会话
+   */
+  async initSession() {
+    try {
+      const cachedSessionId = await this.storageAdapter.getSessionId();
+      if (cachedSessionId) {
+        this.sessionId = cachedSessionId;
+      } else {
+        this.sessionId = this.generateSessionId();
+        await this.storageAdapter.saveSessionId(this.sessionId);
+      }
+    } catch (error) {
+      console.error("Failed to init session:", error);
+      this.sessionId = this.generateSessionId();
+    }
+  }
+  /**
+   * 启动批量上传定时器
+   */
+  startBatchTimer() {
+    this.batchTimer = setInterval(() => {
+      if (!this.eventQueue.isEmpty()) {
+        this.flush();
+      }
+      this.uploader.retryFailedUploads();
+    }, this.config.batchInterval);
+  }
+  /**
+   * 上传成功回调
+   */
+  onUploadSuccess(events) {
+    this.log("Events uploaded successfully", events);
+  }
+  /**
+   * 上传失败回调
+   */
+  onUploadError(error, events) {
+    this.log("Failed to upload events", { error, events });
+  }
+  /**
+   * 生成事件ID
+   */
+  generateEventId() {
+    return `${Date.now()}_${Math.random().toString(36).substring(2, 15)}`;
+  }
+  /**
+   * 生成会话ID
+   */
+  generateSessionId() {
+    return `session_${Date.now()}_${Math.random().toString(36).substring(2, 15)}`;
+  }
+  /**
+   * 获取平台标识
+   */
+  getPlatform() {
+    return this.config.platform || "unknown";
+  }
+  /**
+   * 日志输出
+   */
+  log(message, data) {
+    const dynamicDebug = typeof window !== "undefined" ? localStorage.getItem("analytics-debug") === "true" : false;
+    if (this.config.debug || dynamicDebug) {
+      console.log(`[Analytics] ${message}`, data ?? "");
+    }
+  }
+  /**
+   * 获取队列状态
+   */
+  getQueueStatus() {
+    return {
+      size: this.eventQueue.size(),
+      isFull: this.eventQueue.isFull(),
+      isEmpty: this.eventQueue.isEmpty()
+    };
+  }
+  /**
+   * 获取初始化状态
+   */
+  isInitialized() {
+    return this.initialized;
+  }
+};
+
+// src/analytics/client/presets.ts
+function createWebConfig(appId, options = {}) {
+  return {
+    appId,
+    appVersion: options.appVersion || "1.0.0",
+    endpoint: options.endpoint || "/api/analytics/events",
+    platform: "web",
+    enableAutoPageView: options.enableAutoPageView ?? true,
+    debug: options.debug ?? (typeof process !== "undefined" && process.env?.NODE_ENV === "development")
+    // adapter 需要由调用者提供
+  };
+}
+function createMobileConfig(appId, options = {}) {
+  return {
+    appId,
+    appVersion: options.appVersion || "1.0.0",
+    endpoint: options.endpoint || "/api/analytics/events",
+    platform: "mobile",
+    enableAutoPageView: false,
+    debug: options.debug ?? false
+    // adapter 需要由调用者提供
+  };
+}
+function createMiniappConfig(appId, options = {}) {
+  return {
+    appId,
+    appVersion: options.appVersion || "1.0.0",
+    endpoint: options.endpoint || "/api/analytics/events",
+    platform: "miniapp",
+    enableAutoPageView: true,
+    debug: options.debug ?? false
+    // adapter 需要由调用者提供
+  };
+}
+function createDesktopConfig(appId, options = {}) {
+  return {
+    appId,
+    appVersion: options.appVersion || "1.0.0",
+    endpoint: options.endpoint || "/api/analytics/events",
+    platform: "desktop",
+    enableAutoPageView: false,
+    debug: options.debug ?? false
+    // adapter 需要由调用者提供
+  };
+}
+
+// src/analytics/client/singleton.ts
+var instances = /* @__PURE__ */ new Map();
+function createAnalytics(instanceKey, config) {
+  if (!instances.has(instanceKey)) {
+    instances.set(instanceKey, new Analytics(config));
+  }
+  return instances.get(instanceKey);
+}
+function getAnalyticsInstance(instanceKey) {
+  return instances.get(instanceKey) || null;
+}
+function resetAnalytics(instanceKey) {
+  instances.delete(instanceKey);
+}
+function resetAllAnalytics() {
+  instances.clear();
+}
+function isAnalyticsInitialized(instanceKey) {
+  return instances.has(instanceKey);
+}
+function getAllInstanceKeys() {
+  return Array.from(instances.keys());
+}
+
+// src/analytics/utils/helpers.ts
+function throttle(func, wait) {
+  let timeout = null;
+  let previous = 0;
+  return function(...args) {
+    const now = Date.now();
+    const remaining = wait - (now - previous);
+    if (remaining <= 0 || remaining > wait) {
+      if (timeout) {
+        clearTimeout(timeout);
+        timeout = null;
+      }
+      previous = now;
+      func.apply(this, args);
+    } else if (!timeout) {
+      timeout = setTimeout(() => {
+        previous = Date.now();
+        timeout = null;
+        func.apply(this, args);
+      }, remaining);
+    }
+  };
+}
+function debounce(func, wait) {
+  let timeout = null;
+  return function(...args) {
+    if (timeout) {
+      clearTimeout(timeout);
+    }
+    timeout = setTimeout(() => {
+      func.apply(this, args);
+    }, wait);
+  };
+}
+function formatEvent(event) {
+  return JSON.stringify(event, null, 2);
+}
+function validateEvent(event) {
+  if (!event.event_id || !event.event_type || !event.event_name) {
+    return false;
+  }
+  if (!event.timestamp || event.timestamp <= 0) {
+    return false;
+  }
+  if (!event.session_id || !event.device_id) {
+    return false;
+  }
+  return true;
+}
+function validateEvents(events) {
+  const valid = [];
+  const invalid = [];
+  events.forEach((event) => {
+    if (validateEvent(event)) {
+      valid.push(event);
+    } else {
+      invalid.push(event);
+    }
+  });
+  return { valid, invalid };
+}
+function getEventSize(event) {
+  return new Blob([JSON.stringify(event)]).size;
+}
+function getBatchSize(events) {
+  return events.reduce((total, event) => total + getEventSize(event), 0);
+}
+function sanitizeEvent(event, sensitiveKeys = ["password", "token", "secret", "key"]) {
+  const sanitized = { ...event };
+  if (sanitized.properties) {
+    const cleanProperties = { ...sanitized.properties };
+    sensitiveKeys.forEach((key) => {
+      if (key in cleanProperties) {
+        cleanProperties[key] = "***";
+      }
+    });
+    sanitized.properties = cleanProperties;
+  }
+  return sanitized;
+}
+function mergeEventProperties(baseProperties, ...additionalProperties) {
+  return Object.assign({}, baseProperties, ...additionalProperties);
+}
+function generateUniqueId(prefix = "") {
+  const timestamp = Date.now();
+  const random = Math.random().toString(36).substring(2, 15);
+  return prefix ? `${prefix}_${timestamp}_${random}` : `${timestamp}_${random}`;
+}
+function isMobile() {
+  if (typeof navigator === "undefined") return false;
+  return /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent);
+}
+function isDevelopment() {
+  return process.env.NODE_ENV === "development";
+}
+function formatTimestamp(timestamp, format = "datetime") {
+  const date = new Date(timestamp);
+  switch (format) {
+    case "date":
+      return date.toLocaleDateString();
+    case "time":
+      return date.toLocaleTimeString();
+    case "datetime":
+    default:
+      return date.toLocaleString();
+  }
+}
+function deepClone(obj) {
+  return JSON.parse(JSON.stringify(obj));
+}
+function safeStringify(obj, fallback = "{}") {
+  try {
+    return JSON.stringify(obj);
+  } catch (error) {
+    console.error("Failed to stringify object:", error);
+    return fallback;
+  }
+}
+function safeParse(json, fallback) {
+  try {
+    return JSON.parse(json);
+  } catch (error) {
+    console.error("Failed to parse JSON:", error);
+    return fallback;
+  }
+}
+function getPageDuration(startTime) {
+  return Date.now() - startTime;
+}
+function getCurrentPageUrl() {
+  if (typeof window !== "undefined") {
+    return window.location.href;
+  }
+  return "";
+}
+function getCurrentPageTitle() {
+  if (typeof document !== "undefined") {
+    return document.title;
+  }
+  return "";
+}
+function getReferrer() {
+  if (typeof document !== "undefined") {
+    return document.referrer;
+  }
+  return "";
+}
+
+// src/analytics/utils/decorators.ts
+function Track(eventName, priority = 1 /* NORMAL */) {
+  return function(_target, propertyKey, descriptor) {
+    const originalMethod = descriptor.value;
+    descriptor.value = async function(...args) {
+      const analytics = getAnalyticsInstance2(this);
+      const finalEventName = eventName || propertyKey;
+      const startTime = Date.now();
+      try {
+        const result = await originalMethod.apply(this, args);
+        analytics?.track(
+          "custom" /* CUSTOM */,
+          finalEventName,
+          {
+            success: true,
+            duration: Date.now() - startTime,
+            args: JSON.stringify(args)
+          },
+          priority
+        );
+        return result;
+      } catch (error) {
+        analytics?.track(
+          "error" /* ERROR */,
+          `${finalEventName}_error`,
+          {
+            success: false,
+            duration: Date.now() - startTime,
+            error: error instanceof Error ? error.message : String(error)
+          },
+          2 /* HIGH */
+        );
+        throw error;
+      }
+    };
+    return descriptor;
+  };
+}
+function TrackClick(eventName) {
+  return function(_target, propertyKey, descriptor) {
+    const originalMethod = descriptor.value;
+    descriptor.value = function(...args) {
+      const analytics = getAnalyticsInstance2(this);
+      const finalEventName = eventName || propertyKey;
+      analytics?.track(
+        "click" /* CLICK */,
+        finalEventName,
+        {
+          args: JSON.stringify(args)
+        },
+        0 /* LOW */
+      );
+      return originalMethod.apply(this, args);
+    };
+    return descriptor;
+  };
+}
+function TrackPerformance(metricName) {
+  return function(_target, propertyKey, descriptor) {
+    const originalMethod = descriptor.value;
+    descriptor.value = async function(...args) {
+      const analytics = getAnalyticsInstance2(this);
+      const finalMetricName = metricName || propertyKey;
+      const startTime = performance.now();
+      try {
+        const result = await originalMethod.apply(this, args);
+        const duration = performance.now() - startTime;
+        analytics?.trackPerformance(finalMetricName, duration, "ms", {
+          success: true
+        });
+        return result;
+      } catch (error) {
+        const duration = performance.now() - startTime;
+        analytics?.trackPerformance(finalMetricName, duration, "ms", {
+          success: false,
+          error: error instanceof Error ? error.message : String(error)
+        });
+        throw error;
+      }
+    };
+    return descriptor;
+  };
+}
+function CatchError(_eventName) {
+  return function(_target, propertyKey, descriptor) {
+    const originalMethod = descriptor.value;
+    descriptor.value = async function(...args) {
+      try {
+        return await originalMethod.apply(this, args);
+      } catch (error) {
+        const analytics = getAnalyticsInstance2(this);
+        analytics?.trackError(
+          error instanceof Error ? error.message : String(error),
+          error instanceof Error ? error.stack : void 0,
+          error instanceof Error ? error.name : "Error",
+          {
+            method: propertyKey,
+            args: JSON.stringify(args)
+          }
+        );
+        throw error;
+      }
+    };
+    return descriptor;
+  };
+}
+function getAnalyticsInstance2(instance) {
+  if (instance.analytics) {
+    return instance.analytics;
+  }
+  if (instance._analytics) {
+    return instance._analytics;
+  }
+  if (globalThis.__analytics__) {
+    return globalThis.__analytics__;
+  }
+  return null;
+}
+function setGlobalAnalytics(analytics) {
+  globalThis.__analytics__ = analytics;
+}
+function getGlobalAnalytics() {
+  return globalThis.__analytics__ || null;
+}
+function useAnalytics(analytics) {
+  return analytics;
+}
+function usePageView(analytics, pageUrl, pageTitle) {
+  react.useEffect(() => {
+    if (!analytics) return;
+    const url = pageUrl || (typeof window !== "undefined" ? window.location.href : "");
+    const title = pageTitle || (typeof document !== "undefined" ? document.title : "");
+    analytics.trackPageView(url, title);
+  }, [analytics, pageUrl, pageTitle]);
+}
+function useTrackEvent(analytics) {
+  return react.useCallback(
+    (eventType, eventName, properties, priority) => {
+      if (analytics) {
+        analytics.track(eventType, eventName, properties, priority);
+      }
+    },
+    [analytics]
+  );
+}
+function useTrackClick(analytics) {
+  return react.useCallback(
+    (elementInfo) => {
+      if (analytics) {
+        analytics.trackClick(elementInfo);
+      }
+    },
+    [analytics]
+  );
+}
+function usePageDuration(analytics) {
+  const startTimeRef = react.useRef(Date.now());
+  react.useEffect(() => {
+    startTimeRef.current = Date.now();
+    return () => {
+      if (analytics) {
+        const duration = Date.now() - startTimeRef.current;
+        analytics.track(
+          "page_leave" /* PAGE_LEAVE */,
+          "page_leave",
+          {
+            duration,
+            page_url: typeof window !== "undefined" ? window.location.href : ""
+          },
+          1 /* NORMAL */
+        );
+      }
+    };
+  }, [analytics]);
+}
+function usePerformanceTracking(analytics) {
+  react.useEffect(() => {
+    if (!analytics || typeof window === "undefined") return;
+    if ("performance" in window && "timing" in window.performance) {
+      const timing = window.performance.timing;
+      const loadTime = timing.loadEventEnd - timing.navigationStart;
+      const domReadyTime = timing.domContentLoadedEventEnd - timing.navigationStart;
+      const firstPaintTime = timing.responseStart - timing.navigationStart;
+      analytics.trackPerformance("page_load_time", loadTime, "ms");
+      analytics.trackPerformance("dom_ready_time", domReadyTime, "ms");
+      analytics.trackPerformance("first_paint_time", firstPaintTime, "ms");
+    }
+    if ("PerformanceObserver" in window) {
+      const observer = new PerformanceObserver((list) => {
+        list.getEntries().forEach((entry) => {
+          if (entry.entryType === "resource") {
+            analytics.trackPerformance("resource_load_time", entry.duration, "ms", {
+              resource_name: entry.name
+            });
+          }
+        });
+      });
+      observer.observe({ entryTypes: ["resource"] });
+      return () => observer.disconnect();
+    }
+    return void 0;
+  }, [analytics]);
+}
+function useErrorTracking(analytics) {
+  react.useEffect(() => {
+    if (!analytics || typeof window === "undefined") return;
+    const handleError = (event) => {
+      analytics.trackError(event.message, event.error?.stack, event.error?.name, {
+        filename: event.filename,
+        lineno: event.lineno,
+        colno: event.colno
+      });
+    };
+    const handleUnhandledRejection = (event) => {
+      analytics.trackError("Unhandled Promise Rejection", void 0, "PromiseRejection", {
+        reason: String(event.reason)
+      });
+    };
+    window.addEventListener("error", handleError);
+    window.addEventListener("unhandledrejection", handleUnhandledRejection);
+    return () => {
+      window.removeEventListener("error", handleError);
+      window.removeEventListener("unhandledrejection", handleUnhandledRejection);
+    };
+  }, [analytics]);
+}
+function useAutoTracking(analytics, options = {}) {
+  const {
+    trackPageView = true,
+    trackPageDuration = true,
+    trackPerformance = true,
+    trackErrors = true
+  } = options;
+  react.useEffect(() => {
+    if (trackPageView && analytics) {
+      const url = typeof window !== "undefined" ? window.location.href : "";
+      const title = typeof document !== "undefined" ? document.title : "";
+      analytics.trackPageView(url, title);
+    }
+  }, [analytics, trackPageView]);
+  const startTimeRef = react.useRef(Date.now());
+  react.useEffect(() => {
+    if (!trackPageDuration || !analytics) return;
+    startTimeRef.current = Date.now();
+    return () => {
+      const duration = Date.now() - startTimeRef.current;
+      analytics.track(
+        "page_leave" /* PAGE_LEAVE */,
+        "page_leave",
+        {
+          duration,
+          page_url: typeof window !== "undefined" ? window.location.href : ""
+        },
+        1 /* NORMAL */
+      );
+    };
+  }, [analytics, trackPageDuration]);
+  react.useEffect(() => {
+    if (!trackPerformance || !analytics || typeof window === "undefined") return;
+    const handleLoad = () => {
+      if ("performance" in window && "timing" in window.performance) {
+        const timing = window.performance.timing;
+        const loadTime = timing.loadEventEnd - timing.navigationStart;
+        analytics.trackPerformance("page_load_time", loadTime, "ms");
+      }
+    };
+    window.addEventListener("load", handleLoad);
+    return () => window.removeEventListener("load", handleLoad);
+  }, [analytics, trackPerformance]);
+  react.useEffect(() => {
+    if (!trackErrors || !analytics || typeof window === "undefined") return;
+    const handleError = (event) => {
+      analytics.trackError(event.message, event.error?.stack, event.error?.name);
+    };
+    window.addEventListener("error", handleError);
+    return () => window.removeEventListener("error", handleError);
+  }, [analytics, trackErrors]);
+}
+
+// src/analytics/index.ts
+var ANALYTICS_VERSION = "1.0.0";
+
+exports.ANALYTICS_VERSION = ANALYTICS_VERSION;
+exports.Analytics = Analytics;
+exports.CatchError = CatchError;
+exports.EventPriority = EventPriority;
+exports.EventQueue = EventQueue;
+exports.EventType = EventType;
+exports.Track = Track;
+exports.TrackClick = TrackClick;
+exports.TrackPerformance = TrackPerformance;
+exports.Uploader = Uploader;
+exports.createAnalytics = createAnalytics;
+exports.createDesktopConfig = createDesktopConfig;
+exports.createMiniappConfig = createMiniappConfig;
+exports.createMobileConfig = createMobileConfig;
+exports.createWebConfig = createWebConfig;
+exports.debounce = debounce;
+exports.deepClone = deepClone;
+exports.formatEvent = formatEvent;
+exports.formatTimestamp = formatTimestamp;
+exports.generateUniqueId = generateUniqueId;
+exports.getAllInstanceKeys = getAllInstanceKeys;
+exports.getAnalyticsInstance = getAnalyticsInstance;
+exports.getBatchSize = getBatchSize;
+exports.getCurrentPageTitle = getCurrentPageTitle;
+exports.getCurrentPageUrl = getCurrentPageUrl;
+exports.getEventSize = getEventSize;
+exports.getGlobalAnalytics = getGlobalAnalytics;
+exports.getPageDuration = getPageDuration;
+exports.getReferrer = getReferrer;
+exports.isAnalyticsInitialized = isAnalyticsInitialized;
+exports.isDevelopment = isDevelopment;
+exports.isMobile = isMobile;
+exports.mergeEventProperties = mergeEventProperties;
+exports.resetAllAnalytics = resetAllAnalytics;
+exports.resetAnalytics = resetAnalytics;
+exports.safeParse = safeParse;
+exports.safeStringify = safeStringify;
+exports.sanitizeEvent = sanitizeEvent;
+exports.setGlobalAnalytics = setGlobalAnalytics;
+exports.throttle = throttle;
+exports.useAnalytics = useAnalytics;
+exports.useAutoTracking = useAutoTracking;
+exports.useErrorTracking = useErrorTracking;
+exports.usePageDuration = usePageDuration;
+exports.usePageView = usePageView;
+exports.usePerformanceTracking = usePerformanceTracking;
+exports.useTrackClick = useTrackClick;
+exports.useTrackEvent = useTrackEvent;
+exports.validateEvent = validateEvent;
+exports.validateEvents = validateEvents;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map