@uxda/appkit 4.2.93 → 4.2.94

package/src/shared/tracking/tracking-sdk.ts

@@ -0,0 +1,986 @@
+/**
+ * 全埋点SDK - 精简版
+ * 集成核心埋点功能，支持自动埋点和手动埋点
+ */
+
+import { onAppHide, setStorageSync, getSystemInfo, getNetworkType, getStorageSync, getEnv, getAccountInfoSync, getPerformance, request } from '@tarojs/taro'
+import pako from 'pako'
+import { isApp } from '../../utils/utils'
+
+// 埋点事件类型枚举
+export enum TrackingEventType {
+  PAGE_VIEW = 'page_view', // 页面访问
+  PAGE_LEAVE = 'page_leave', // 页面离开
+  APP_DEVICE_INFO = 'app_device_info', // app和device信息
+  CLICK = 'click', // 点击事件
+  CUSTOM = 'custom', // 自定义事件
+}
+
+// 导出枚举值供外部使用
+export const { PAGE_VIEW, PAGE_LEAVE, CLICK, CUSTOM, APP_DEVICE_INFO } = TrackingEventType
+
+// 日志类型（支持组合类型，如 "page/event/error/device/app"）
+export type LogType = 'page' | 'event' | 'error' | 'device' | 'app' | 'performance' | string
+
+// 来源类型
+export type SourceType = 'app' | 'H5' | 'PC' | string
+
+// 页面信息接口
+export interface PageData {
+  page_name?: string // 页面名称
+  page_url?: string // 页面URL
+  page_referrer?: string // 页面来源
+  previous_page_name?: string // 上一页名称
+  page_start_time?: string // 页面开始时间 (ISO 8601格式)
+  page_duration?: number // 页面停留时长（毫秒）
+}
+
+// 事件信息接口
+export interface EventData {
+  event_type?: string // 事件类型
+  event_name?: string // 事件名称
+  element_id?: string // 元素ID
+}
+
+// 应用信息接口
+export interface AppData {
+  app_version?: string // 应用版本
+  package_name?: string // 包名
+  app_channel?: string // 应用渠道
+}
+
+// 设备信息接口
+export interface DeviceData {
+  device_type?: string // 设备类型 (mobile/tablet/desktop)
+  os?: string // 操作系统
+  os_version?: string // 操作系统版本
+  brand?: string // 品牌
+  model?: string // 型号
+  network_type?: string // 网络类型
+}
+
+// 性能信息接口
+export interface PerformanceData {
+  page_load_time?: number // 页面加载时间（毫秒）
+  response_time?: number // 响应时间（毫秒）
+  fps?: number // 帧率
+  memory_usage?: number // 内存使用率（%）
+  battery_usage?: number // 电池使用率（%）
+  network_latency?: number // 网络延迟（毫秒）
+  crash_rate?: number // 崩溃率（%）
+}
+
+// 错误信息接口
+export interface ErrorData {
+  error_code?: string // 错误代码
+  error_message?: string // 错误消息
+  stack_trace?: string // 堆栈跟踪
+  error_level?: string // 错误级别 (info/warning/error)
+  error_context?: string // 错误上下文
+}
+
+// 日志数据接口
+export interface LogData {
+  page?: PageData
+  event?: EventData
+  app?: AppData
+  device?: DeviceData
+  performance?: PerformanceData
+  error?: ErrorData
+}
+
+// 埋点主数据接口（符合新的数据结构）
+export interface TrackingMainData {
+  log_id?: string // 日志ID
+  log_time: number // 日志时间戳
+  log_type: LogType // 日志类型（支持组合类型，如 "page/event/error/device/app"）
+  tenant_id?: string // 租户ID
+  user_id?: string // 用户ID
+  source: SourceType // 来源 (app/H5/PC)
+  session_id: string // 会话ID
+  log_data: LogData // 日志数据
+}
+
+// 内部使用的数据结构（用于方法参数）
+interface TrackingData {
+  logTime?: number // 时间戳
+  sessionId?: string // 会话ID
+  userId?: string // 用户ID
+  tenantId?: string // 租户ID
+  pagePath?: string // 页面路径
+  pageTitle?: string // 页面标题
+  lastPagePath?: string // 上一页路径
+  lastPageTitle?: string // 上一页标题
+  elementId?: string // 元素ID
+  elementText?: string // 元素文本
+  businessData?: Record<string, unknown> // 业务数据
+}
+
+// 用户信息接口
+export interface TrackingUserInfo {
+  userId?: string // 用户ID
+  tenantId?: string // 租户ID
+  sessionId?: string // 会话ID
+}
+
+// 埋点配置接口
+export interface TrackingConfig {
+  enabled: boolean // 是否启用埋点
+  debug: boolean // 是否开启调试模式
+  batchSize: number // 批量发送大小
+  flushInterval: number // 刷新间隔(ms)
+  apiEndpoint: string // API端点
+  userInfo?: TrackingUserInfo // 用户信息
+}
+
+// 默认配置
+const DEFAULT_CONFIG: TrackingConfig = {
+  enabled: true,
+  debug: false,
+  batchSize: 30,
+  flushInterval: 100000,
+  apiEndpoint: '',
+}
+
+/**
+ * 全埋点SDK类
+ */
+// 页面历史记录接口
+interface PageHistory {
+  route: string
+  title: string
+  timestamp: number
+}
+
+class TrackingSDK {
+  private config: TrackingConfig
+  private eventQueue: TrackingMainData[] = []
+  private currentPage: string = ''
+  private pageStartTime: number = 0
+  private flushTimer: ReturnType<typeof setInterval> | null = null
+  private isInitialized: boolean = false
+  private pageHistory: PageHistory[] = [] // 页面历史记录
+  private readonly PAGE_HISTORY_KEY = 'tracking_page_history' // 存储键
+  private readonly MAX_HISTORY_LENGTH = 10 // 最大历史记录数
+  private userInfo: TrackingUserInfo | undefined = undefined // 用户信息（优先使用）
+
+  constructor(config: Partial<TrackingConfig> = {}) {
+    this.config = { ...DEFAULT_CONFIG, ...config }
+    // 保存传入的用户信息
+    if (config.userInfo) {
+      this.userInfo = config.userInfo
+    }
+    this.init()
+  }
+
+  /**
+   * 初始化SDK
+   */
+  private init(): void {
+    if (this.isInitialized) return
+
+    this.isInitialized = true
+    this.loadPageHistory() // 加载页面历史记录
+    this.setupAutoTracking()
+    this.startFlushTimer()
+
+    if (this.config.debug) {
+      console.log('[TrackingSDK] 初始化完成', this.config)
+    }
+  }
+
+  /**
+   * 加载页面历史记录
+   */
+  private loadPageHistory(): void {
+    try {
+      const historyStr = getStorageSync(this.PAGE_HISTORY_KEY)
+      if (historyStr) {
+        this.pageHistory = JSON.parse(historyStr)
+      }
+    } catch (error) {
+      if (this.config.debug) {
+        console.log('[TrackingSDK] 加载页面历史失败:', error)
+      }
+      this.pageHistory = []
+    }
+  }
+
+  /**
+   * 简单的Token加密 (Base64 + 反转)
+   * @returns 加密后的token字符串
+   */
+  private encryptToken(): string {
+    const raw = `Ddjf@Log1125|${Date.now()}`
+
+    // Base64 编码（兼容 H5 和小程序环境）
+    let base64: string
+    if (typeof btoa !== 'undefined') {
+      // H5 环境使用 btoa
+      base64 = btoa(unescape(encodeURIComponent(raw)))
+    } else {
+      // 小程序环境使用手动实现的 Base64 编码
+      base64 = this.base64Encode(raw)
+    }
+
+    // 反转字符串
+    return base64.split('').reverse().join('')
+  }
+  /**
+   * Base64 编码（降级方案）
+   */
+  private base64Encode(str: string): string {
+    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/='
+    let output = ''
+    let i = 0
+
+    while (i < str.length) {
+      const a = str.charCodeAt(i++)
+      const b = i < str.length ? str.charCodeAt(i++) : 0
+      const c = i < str.length ? str.charCodeAt(i++) : 0
+
+      const bitmap = (a << 16) | (b << 8) | c
+
+      output += chars.charAt((bitmap >> 18) & 63)
+      output += chars.charAt((bitmap >> 12) & 63)
+      output += i - 2 < str.length ? chars.charAt((bitmap >> 6) & 63) : '='
+      output += i - 1 < str.length ? chars.charAt(bitmap & 63) : '='
+    }
+
+    return output
+  }
+
+  /**
+   * 保存页面历史记录
+   */
+  private savePageHistory(): void {
+    try {
+      setStorageSync(this.PAGE_HISTORY_KEY, JSON.stringify(this.pageHistory))
+    } catch (error) {
+      if (this.config.debug) {
+        console.log('[TrackingSDK] 保存页面历史失败:', error)
+      }
+    }
+  }
+
+  /**
+   * 添加页面到历史记录
+   */
+  private addPageToHistory(route: string, title: string): void {
+    const history: PageHistory = {
+      route,
+      title,
+      timestamp: Date.now(),
+    }
+
+    // 添加到历史记录
+    this.pageHistory.push(history)
+
+    // 保持历史记录在最大长度内
+    if (this.pageHistory.length > this.MAX_HISTORY_LENGTH) {
+      this.pageHistory.shift()
+    }
+
+    // 保存到本地存储
+    this.savePageHistory()
+  }
+
+  /**
+   * 获取上一页信息（从历史记录中）
+   */
+  private getLastPageFromHistory(): PageHistory | null {
+    if (this.pageHistory.length >= 2) {
+      // 返回倒数第二个页面（最后一个是当前页面）
+      return this.pageHistory[this.pageHistory.length - 2]
+    }
+    return null
+  }
+
+  /**
+   * 清空页面历史记录
+   */
+  public clearPageHistory(): void {
+    this.pageHistory = []
+    this.savePageHistory()
+  }
+
+  /**
+   * 获取用户信息
+   * 优先级：1. 初始化时传入的userInfo 2. Storage中的用户信息 3. 生成新的sessionId
+   */
+  private getUserInfo(): { userId?: string; tenantId?: string; sessionId?: string } {
+    if (this.userInfo) {
+      return {
+        userId: this.userInfo.userId,
+        tenantId: this.userInfo.tenantId,
+        sessionId: this.userInfo.sessionId || this.generateSessionId(),
+      }
+    }
+
+    return { sessionId: this.generateSessionId() }
+  }
+
+  /**
+   * 生成会话ID
+   */
+  private generateSessionId(): string {
+    return `session_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`
+  }
+
+  /**
+   * 获取设备信息
+   */
+  private async getDeviceInfo(): Promise<DeviceData> {
+    try {
+      const systemInfo = await getSystemInfo()
+
+      // 获取网络类型
+      let networkType = ''
+      try {
+        const networkInfo = await getNetworkType()
+        networkType = networkInfo.networkType || ''
+      } catch {
+        // 网络类型获取失败，使用空字符串
+        networkType = ''
+      }
+
+      return {
+        device_type:
+          systemInfo.platform === 'ios' || systemInfo.platform === 'android' ? 'mobile' : 'desktop',
+        os: systemInfo.platform,
+        os_version: systemInfo.system,
+        brand: systemInfo.brand || '',
+        model: systemInfo.model || '',
+        network_type: networkType,
+      }
+    } catch {
+      return {}
+    }
+  }
+
+  /**
+   * 获取应用信息
+   */
+  private getAppInfo(): AppData {
+    try {
+      const env = getEnv()
+      if (env === 'WEAPP') {
+        const accountInfo = getAccountInfoSync?.()
+        return {
+          app_version: accountInfo?.miniProgram?.version || '1.0.0',
+          package_name: accountInfo?.miniProgram?.appId || '',
+          app_channel: 'WeChat',
+        }
+      } else {
+        return {
+          app_version: '1.0.0',
+          package_name: '',
+          app_channel: env === 'WEB' ? 'H5' : 'App Store',
+        }
+      }
+    } catch {
+      return {
+        app_version: '1.0.0',
+        package_name: '',
+        app_channel: getEnv() === 'WEB' ? 'H5' : 'Unknown',
+      }
+    }
+  }
+
+  /**
+   * 获取来源类型
+   */
+  private getSourceType(): SourceType {
+    const env = getEnv()
+    if (isApp()) return 'app'
+    if (env === 'WEB') return 'H5'
+    if (env === 'WEAPP') return 'app'
+    return 'PC'
+  }
+
+  /**
+   * 获取页面性能数据
+   */
+  private async getPerformanceData(): Promise<PerformanceData> {
+    try {
+      const performanceData: PerformanceData = {}
+      const env = getEnv()
+
+      if (env === 'WEB') {
+        // H5 环境：使用浏览器原生 Performance API
+        if (typeof window !== 'undefined' && window.performance) {
+          const perfEntries = window.performance.getEntriesByType('navigation')
+          if (perfEntries && perfEntries.length > 0) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const navigationTiming = perfEntries[0] as any
+            // 页面加载完成时间
+            performanceData.page_load_time = Math.round(navigationTiming.duration || 0)
+            // 响应时间
+            performanceData.response_time = Math.round(
+              (navigationTiming.responseEnd || 0) - (navigationTiming.requestStart || 0)
+            )
+          }
+
+          // 获取内存信息（部分浏览器支持）
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          const memory = (window.performance as any).memory
+          if (memory) {
+            const usedMemory = memory.usedJSHeapSize || 0
+            const totalMemory = memory.jsHeapSizeLimit || 0
+            if (totalMemory > 0) {
+              performanceData.memory_usage = Number(((usedMemory / totalMemory) * 100).toFixed(2))
+            }
+          }
+        }
+      } else {
+        // 小程序环境：使用 Taro.getPerformance()
+        const performance = await getPerformance()
+        if (performance) {
+          // 页面加载时间
+          const entryList = performance.getEntriesByType?.('navigation')
+          if (entryList && entryList.length > 0) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const navigationTiming = entryList[0] as any
+            // 页面加载完成时间
+            performanceData.page_load_time = Math.round(navigationTiming.duration || 0)
+            // 响应时间
+            performanceData.response_time = Math.round(
+              (navigationTiming.responseEnd || 0) - (navigationTiming.requestStart || 0)
+            )
+          }
+
+          // 获取内存信息（仅小程序支持）
+          if (env === 'WEAPP') {
+            try {
+              // eslint-disable-next-line @typescript-eslint/no-explicit-any
+              const performanceObj = performance as any
+              const memoryInfo = performanceObj?.getMemoryInfo?.()
+              if (memoryInfo) {
+                // 计算内存使用率
+                const usedMemory = memoryInfo.usedJSHeapSize || 0
+                const totalMemory = memoryInfo.totalJSHeapSize || memoryInfo.jsHeapSizeLimit || 0
+                if (totalMemory > 0) {
+                  performanceData.memory_usage = Number(
+                    ((usedMemory / totalMemory) * 100).toFixed(2)
+                  )
+                }
+              }
+            } catch {
+              // 内存信息获取失败，忽略
+            }
+          }
+        }
+      }
+
+      return performanceData
+    } catch (error) {
+      if (this.config.debug) {
+        console.log('[TrackingSDK] 获取性能数据失败:', error)
+      }
+      return {}
+    }
+  }
+
+  /**
+   * 创建基础埋点数据（新版数据结构）
+   */
+  private async createBaseTrackingData(
+    eventType: TrackingEventType,
+    customData?: Partial<TrackingData>
+  ): Promise<TrackingMainData> {
+    const userInfo = this.getUserInfo()
+    const pagePath = customData?.pagePath || this.currentPage || ''
+    const now = Date.now()
+    const pageData: PageData = {}
+    const eventData: EventData = {}
+    let logType: string = ''
+
+    // 判断是否需要包含app和device信息
+    let appInfo: AppData = {}
+    let deviceInfo: DeviceData = {}
+    let performanceData: PerformanceData = {}
+
+    if (eventType === TrackingEventType.APP_DEVICE_INFO) {
+      deviceInfo = await this.getDeviceInfo()
+      appInfo = this.getAppInfo()
+    } else {
+      // 构建页面数据
+      if (pagePath) {
+        pageData.page_url = pagePath
+        pageData.page_name = customData?.pageTitle || this.getPageTitle(pagePath)
+        pageData.page_referrer = customData?.lastPagePath || ''
+        pageData.previous_page_name = customData?.lastPageTitle || ''
+        if (this.pageStartTime) {
+          pageData.page_start_time = new Date(this.pageStartTime).toISOString()
+          pageData.page_duration = now - this.pageStartTime
+        }
+      }
+
+      // 构建事件数据
+      if (eventType === TrackingEventType.CLICK) {
+        eventData.event_type = 'click'
+        eventData.event_name =
+          customData?.elementText || (customData?.businessData?.elementText as string) || '点击事件'
+        eventData.element_id = customData?.elementId || ''
+      } else if (eventType === TrackingEventType.CUSTOM) {
+        eventData.event_type = 'custom'
+        eventData.event_name = (customData?.businessData?.eventName as string) || '自定义事件'
+      } else {
+        eventData.event_type = eventType
+        eventData.event_name = eventType
+      }
+
+      // 如果是页面访问事件，自动采集性能数据
+      if (eventType === TrackingEventType.PAGE_VIEW || customData?.businessData?.performance) {
+        performanceData = await this.getPerformanceData()
+      }
+    }
+
+    // 构建日志类型
+    if ([TrackingEventType.CLICK, TrackingEventType.CUSTOM].includes(eventType)) {
+      logType = 'event'
+    } else if ([TrackingEventType.PAGE_VIEW, TrackingEventType.PAGE_LEAVE].includes(eventType)) {
+      logType = 'page'
+    } else if ([TrackingEventType.APP_DEVICE_INFO].includes(eventType)) {
+      logType = 'device'
+    }
+
+    // 合并性能数据：优先使用自动采集的，其次使用手动传入的
+    const finalPerformanceData: PerformanceData = {
+      ...performanceData,
+      ...(customData?.businessData?.performance as PerformanceData),
+    }
+
+    // 构建 log_data，过滤掉空值
+    const logData: LogData = {}
+    if (Object.keys(pageData).length > 0) {
+      logData.page = pageData
+    }
+    if (Object.keys(eventData).length > 0) {
+      logData.event = eventData
+    }
+    if (Object.keys(appInfo).length > 0) {
+      logData.app = appInfo
+    }
+    if (Object.keys(deviceInfo).length > 0) {
+      logData.device = deviceInfo
+    }
+    if (Object.keys(finalPerformanceData).length > 0) {
+      logData.performance = finalPerformanceData
+    }
+    const errorData = customData?.businessData?.error as ErrorData
+    if (errorData && Object.keys(errorData).length > 0) {
+      logData.error = errorData
+    }
+
+    const trackingData: TrackingMainData = {
+      log_id: `${now}_${Math.random().toString(36).substr(2, 9)}`,
+      log_time: now,
+      log_type: logType || 'event',
+      tenant_id: customData?.tenantId || userInfo.tenantId || '',
+      user_id: customData?.userId || userInfo.userId || '',
+      source: this.getSourceType(),
+      session_id: userInfo.sessionId || '',
+      log_data: logData,
+    }
+
+    return trackingData
+  }
+
+  /**
+   * 根据页面路径获取页面标题
+   */
+  private getPageTitle(pagePath: string): string {
+    const titleMap: Record<string, string> = {
+      '/aiapprove/pages': 'AI审批',
+      '/aiapprove/views': '企明星',
+      '/pages/beidou': '北斗星',
+      '/pages/contracts': '蜂鸟签约',
+      '/pages/user': '我的',
+    }
+
+    for (const [path, title] of Object.entries(titleMap)) {
+      if (pagePath.includes(path)) {
+        return title
+      }
+    }
+
+    return pagePath
+  }
+
+  /**
+   * 添加埋点数据到队列
+   */
+  private addToQueue(data: TrackingMainData): void {
+    if (!this.config.enabled) return
+
+    this.eventQueue.push(data)
+
+    if (this.config.debug) {
+      console.log('[TrackingSDK] 添加埋点数据:', data)
+    }
+
+    // 检查是否需要立即发送
+    if (this.eventQueue.length >= this.config.batchSize) {
+      this.flush()
+    }
+  }
+
+  /**
+   * 发送埋点数据
+   */
+  private async flush(): Promise<void> {
+    if (this.eventQueue.length === 0) return
+
+    const events = [...this.eventQueue]
+    this.eventQueue = []
+
+    try {
+      // 将对象数组转为 JSON 字符串
+      const jsonStr = JSON.stringify(events)
+
+      // 使用 pako 压缩
+      const compressed = pako.deflate(jsonStr)
+
+      // if (this.config.debug) {
+      //   console.log('[TrackingSDK] 原始数据大小:', new Blob([jsonStr]).size, 'bytes')
+      //   console.log('[TrackingSDK] 压缩后大小:', compressed.length, 'bytes')
+      //   console.log(
+      //     '[TrackingSDK] 压缩率:',
+      //     ((compressed.length / new Blob([jsonStr]).size) * 100).toFixed(2) + '%'
+      //   )
+      // }
+
+      // 批量发送埋点数据
+      const encryptedToken = this.encryptToken()
+      const { success } = await this.http({
+        url: `${this.config.apiEndpoint}?contentId=${encryptedToken}`,
+        method: 'POST',
+        data: compressed,
+        header: {
+          'Content-Encoding': 'deflate',
+        },
+      })
+
+      if (success && this.config.debug) {
+        console.log('[TrackingSDK] 埋点数据发送成功:', events.length, '条')
+      }
+    } catch (error) {
+      console.error('[TrackingSDK] 埋点数据发送失败:', error)
+
+      // 重试逻辑 - 将失败的数据放回队列
+      if (events.length > 0) {
+        this.eventQueue.unshift(...events)
+      }
+    }
+  }
+
+  /**
+   * 请求拦截
+   */
+  private http(params: {
+    url: string
+    method: 'GET' | 'POST'
+    data: any
+    header: any
+  }): Promise<any> {
+    return new Promise((resolve, reject) => {
+      request({
+        url: params.url,
+        method: params.method || 'GET',
+        data: params.data,
+        header: params.header,
+      })
+        .then((res) => {
+          console.log('===res', res)
+          resolve(res.data)
+        })
+        .catch((err) => {
+          reject(err)
+        })
+    })
+  }
+
+  /**
+   * 启动定时刷新
+   */
+  private startFlushTimer(): void {
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer)
+    }
+
+    this.flushTimer = setInterval(() => {
+      this.flush()
+    }, this.config.flushInterval)
+  }
+
+  /**
+   * 设置自动埋点
+   */
+  private setupAutoTracking(): void {
+    // 监听页面隐藏 - 立即发送剩余数据
+    onAppHide(() => {
+      this.trackPageLeave()
+      // 立即发送剩余的埋点数据
+      this.flushNow()
+    })
+
+    // H5 环境：监听页面卸载事件
+    if (getEnv() === 'WEB' && typeof window !== 'undefined') {
+      // 使用 beforeunload 事件
+      window.addEventListener('beforeunload', () => {
+        this.flushNow()
+      })
+
+      // 使用 visibilitychange 事件（页面隐藏时发送）
+      document.addEventListener('visibilitychange', () => {
+        if (document.visibilityState === 'hidden') {
+          this.flushNow()
+        }
+      })
+
+      // 使用 pagehide 事件（更可靠）
+      window.addEventListener('pagehide', () => {
+        this.flushNow()
+      })
+    }
+  }
+
+  /**
+   * 手动埋点 - 页面访问
+   */
+  public async trackPageView(pageTitle?: string): Promise<void> {
+    const currentPage = this.getPageInfoByIndex()
+    const currentPath = (currentPage.route as string) || ''
+    const currentTitle =
+      pageTitle ||
+      (currentPage.options?.title as string) ||
+      currentPage.config?.navigationBarTitleText ||
+      ''
+
+    // 添加当前页到历史记录
+    if (currentPath) {
+      this.addPageToHistory(currentPath, currentTitle)
+    }
+
+    // 从历史记录获取上一页信息
+    let lastPath = ''
+    let lastTitle = ''
+    const lastPageHistory = this.getLastPageFromHistory()
+    if (lastPageHistory) {
+      lastPath = lastPageHistory.route
+      lastTitle = lastPageHistory.title
+    }
+
+    this.currentPage = currentPath
+    this.pageStartTime = Date.now()
+
+    const data = await this.createBaseTrackingData(TrackingEventType.PAGE_VIEW, {
+      pagePath: currentPath,
+      pageTitle: currentTitle,
+      lastPagePath: lastPath,
+      lastPageTitle: lastTitle,
+    })
+
+    // if (this.config.debug) {
+    //   console.log('[TrackingSDK] 页面访问埋点:', {
+    //     current: { path: currentPath, title: currentTitle },
+    //     last: { path: lastPath, title: lastTitle },
+    //     historyLength: this.pageHistory.length,
+    //   })
+    // }
+
+    this.addToQueue(data)
+  }
+
+  /**
+   * 手动埋点 - 页面离开
+   */
+  public async trackPageLeave(pagePath?: string): Promise<void> {
+    const path = pagePath || this.currentPage
+    if (!path) return
+
+    const data = await this.createBaseTrackingData(TrackingEventType.PAGE_LEAVE, {
+      pagePath: path,
+    })
+
+    this.addToQueue(data)
+  }
+
+  /**
+   * 手动埋点 - 点击事件
+   */
+  public async trackClick(elementId?: string, elementText?: string): Promise<void> {
+    const data = await this.createBaseTrackingData(TrackingEventType.CLICK, {
+      elementId,
+      elementText,
+    })
+
+    this.addToQueue(data)
+  }
+
+  /**
+   * 手动埋点 - 自定义事件
+   */
+  public async trackCustom(eventName: string, customData?: Record<string, unknown>): Promise<void> {
+    const data = await this.createBaseTrackingData(TrackingEventType.CUSTOM, {
+      businessData: {
+        eventName,
+        ...customData,
+      },
+    })
+
+    this.addToQueue(data)
+  }
+
+  /**
+   * 手动埋点 - 业务事件
+   */
+  public async trackBusiness(
+    event: TrackingEventType,
+    businessData?: Record<string, unknown>
+  ): Promise<void> {
+    const data = await this.createBaseTrackingData(event, {
+      businessData,
+    })
+
+    this.addToQueue(data)
+  }
+
+  /**
+   * 手动埋点 - app 和 device 信息
+   */
+  public async trackAppDeviceInfo(): Promise<void> {
+    const data = await this.createBaseTrackingData(TrackingEventType.APP_DEVICE_INFO, {})
+
+    this.addToQueue(data)
+  }
+
+  /**
+   * 获取指定页面信息
+   */
+  public getPageInfoByIndex(index = 1): {
+    route?: string
+    options?: Record<string, unknown>
+    config?: { navigationBarTitleText?: string }
+    [key: string]: unknown
+  } {
+    try {
+      const pages = getCurrentPages()
+      const currentPage = pages[pages.length - index]
+      return currentPage || {}
+    } catch {
+      return {}
+    }
+  }
+
+  /**
+   * 更新配置
+   */
+  public updateConfig(newConfig: Partial<TrackingConfig>): void {
+    this.config = { 
+      enabled: newConfig.enabled ?? this.config.enabled,
+      debug: newConfig.debug ?? this.config.debug,
+      batchSize: newConfig.batchSize ?? this.config.batchSize,
+      flushInterval: newConfig.flushInterval ?? this.config.flushInterval,
+      apiEndpoint: newConfig.apiEndpoint ?? this.config.apiEndpoint,
+      userInfo: newConfig.userInfo ?? this.userInfo,
+     };
+
+    // 更新用户信息
+    if (newConfig.userInfo !== undefined) {
+      this.userInfo = newConfig.userInfo
+    }
+
+    if (newConfig.flushInterval) {
+      this.startFlushTimer()
+    }
+  }
+
+  /**
+   * 立即发送所有待发送的数据（同步方式）
+   */
+  public flushNow(): void {
+    if (this.eventQueue.length === 0) return
+
+    const events = [...this.eventQueue]
+    this.eventQueue = []
+
+    try {
+      // 使用同步方式发送（适用于页面关闭场景）
+      const env = getEnv()
+
+      if (env === 'WEB' && typeof navigator !== 'undefined' && navigator.sendBeacon) {
+        // H5 环境：使用 sendBeacon API（专为页面卸载场景设计）（sendBeacon无法指定header头， 无法deflate压缩）
+        const blob = new Blob([JSON.stringify(events)], {
+          type: 'application/json',
+        })
+        const encryptedToken = this.encryptToken()
+        const sent = navigator.sendBeacon(
+          `${this.config.apiEndpoint}?contentId=${encryptedToken}`,
+          blob
+        )
+
+        if (this.config.debug) {
+          console.log(
+            '[TrackingSDK] 使用 sendBeacon 发送:',
+            sent ? '成功' : '失败',
+            events.length,
+            '条'
+          )
+        }
+
+        // 如果 sendBeacon 失败，降级使用普通请求
+        if (!sent) {
+          this.eventQueue.unshift(...events)
+          this.flush().catch(console.error)
+        }
+      } else {
+        // 小程序环境：使用普通异步请求
+        this.flush().catch((error) => {
+          console.error('[TrackingSDK] 立即发送失败:', error)
+          // 发送失败，重新加入队列
+          this.eventQueue.unshift(...events)
+        })
+      }
+    } catch (error) {
+      console.error('[TrackingSDK] flushNow 执行失败:', error)
+      // 发送失败，重新加入队列
+      this.eventQueue.unshift(...events)
+    }
+  }
+
+  /**
+   * 销毁SDK
+   */
+  public destroy(): void {
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer)
+      this.flushTimer = null
+    }
+
+    // 立即发送剩余数据
+    this.flushNow()
+
+    this.isInitialized = false
+  }
+}
+
+// 创建全局实例
+export const trackingSDK = new TrackingSDK()
+
+// 导出便捷方法（异步版本）
+export const trackPageView = async (pageTitle?: string): Promise<void> =>
+  await trackingSDK.trackPageView(pageTitle)
+export const trackClick = async (elementId?: string, elementText?: string): Promise<void> =>
+  await trackingSDK.trackClick(elementId, elementText)
+export const trackCustom = async (
+  eventName: string,
+  customData?: Record<string, unknown>
+): Promise<void> => await trackingSDK.trackCustom(eventName, customData)
+export const trackBusiness = async (
+  event: TrackingEventType,
+  businessData?: Record<string, unknown>
+): Promise<void> => await trackingSDK.trackBusiness(event, businessData)
+
+export default trackingSDK