@fle-sdk/event-tracking-web 1.2.1 → 1.2.3

package/lib/index.esm.js

@@ -1,3 +1,19 @@
+function _typeof(obj) {
+  "@babel/helpers - typeof";
+
+  if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+    _typeof = function (obj) {
+      return typeof obj;
+    };
+  } else {
+    _typeof = function (obj) {
+      return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+    };
+  }
+
+  return _typeof(obj);
+}
+
 /*! *****************************************************************************
 Copyright (c) Microsoft Corporation.
 
@@ -46,22 +62,6 @@ function __spreadArray(to, from) {
     return to;
 }
 
-function _typeof(obj) {
-  "@babel/helpers - typeof";
-
-  if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
-    _typeof = function (obj) {
-      return typeof obj;
-    };
-  } else {
-    _typeof = function (obj) {
-      return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
-    };
-  }
-
-  return _typeof(obj);
-}
-
 var WebTrackingTools =
 /** @class */
 function () {
@@ -444,7 +444,7 @@ function () {
 
     this.filterSensitiveData = function (obj, sensitiveKeys) {
       if (sensitiveKeys === void 0) {
-        sensitiveKeys = ['password', 'token', 'secret', 'key'];
+        sensitiveKeys = ["password", "token", "secret", "key"];
       }
 
       if (!_this.isObject(obj)) return obj;
@@ -453,11 +453,11 @@ function () {
       _this.each(obj, function (value, key) {
         // 检查是否是敏感字段
         var isSensitive = sensitiveKeys.some(function (sensitiveKey) {
-          return typeof key === 'string' && key.toLowerCase().includes(sensitiveKey.toLowerCase());
+          return typeof key === "string" && key.toLowerCase().includes(sensitiveKey.toLowerCase());
         });
 
         if (isSensitive) {
-          filteredObj[key] = '***';
+          filteredObj[key] = "***";
         } else if (_this.isObject(value)) {
           // 递归过滤嵌套对象
           filteredObj[key] = _this.filterSensitiveData(value, sensitiveKeys);
@@ -476,9 +476,9 @@ function () {
 
 
     this.xssFilter = function (str) {
-      if (!str) return '';
-      if (typeof str !== 'string') return str.toString();
-      return str.replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;').replace(/'/g, '&#x27;').replace(/\//g, '&#x2F;');
+      if (!str) return "";
+      if (typeof str !== "string") return str.toString();
+      return str.replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#x27;").replace(/\//g, "&#x2F;");
     };
     /**
      * 获取url中的参数
@@ -518,7 +518,7 @@ function () {
           return {};
         }
 
-        if (typeof data === 'string') {
+        if (typeof data === "string") {
           try {
             return JSON.parse(data);
           } catch (e) {
@@ -526,7 +526,7 @@ function () {
           }
         }
 
-        if (_typeof(data) === 'object') {
+        if (_typeof(data) === "object") {
           return data;
         }
 
@@ -817,7 +817,7 @@ function () {
 
     this.getDeviceId = function () {
       // 获取已存储的设备ID
-      var storedDeviceId = _this.getCookie('device_id') || _this.getLocalStorage('device_id');
+      var storedDeviceId = _this.getCookie("device_id") || _this.getLocalStorage("device_id");
 
       if (storedDeviceId) {
         return storedDeviceId;
@@ -830,10 +830,10 @@ function () {
       var deviceId = _this.hashFingerprint(fingerprint); // 存储设备ID
 
 
-      _this.setCookie('device_id', deviceId, 365 * 2); // 存储2年
+      _this.setCookie("device_id", deviceId, 365 * 2); // 存储2年
 
 
-      _this.setLocalStorage('device_id', deviceId);
+      _this.setLocalStorage("device_id", deviceId);
 
       return deviceId;
     };
@@ -890,44 +890,50 @@ function () {
 
     this.getWebGLFingerprint = function () {
       try {
-        var canvas = document.createElement('canvas');
-        var gl = canvas.getContext('webgl') || canvas.getContext('experimental-webgl');
-        if (!gl) return 'not-supported';
-        var debugInfo = gl.getExtension('WEBGL_debug_renderer_info');
-        var vendor = debugInfo ? gl.getParameter(debugInfo.UNMASKED_VENDOR_WEBGL) : 'unknown';
-        var renderer = debugInfo ? gl.getParameter(debugInfo.UNMASKED_RENDERER_WEBGL) : 'unknown';
+        var canvas = document.createElement("canvas");
+        var gl = canvas.getContext("webgl") || canvas.getContext("experimental-webgl");
+        if (!gl) return "not-supported";
+        var debugInfo = gl.getExtension("WEBGL_debug_renderer_info");
+        var vendor = debugInfo ? gl.getParameter(debugInfo.UNMASKED_VENDOR_WEBGL) : "unknown";
+        var renderer = debugInfo ? gl.getParameter(debugInfo.UNMASKED_RENDERER_WEBGL) : "unknown";
         return vendor + "|" + renderer;
       } catch (e) {
-        return 'error';
+        return "error";
       }
     };
     /**
      * 获取Canvas指纹
+     * 注意：使用固定的尺寸和绘制参数，确保在不同时间生成一致的指纹
      * @returns Canvas指纹字符串
      */
 
 
     this.getCanvasFingerprint = function () {
       try {
-        var canvas = document.createElement('canvas');
-        var ctx = canvas.getContext('2d');
-        if (!ctx) return 'not-supported'; // 绘制特定图形
-
-        ctx.textBaseline = 'top';
-        ctx.font = '14px Arial';
-        ctx.fillStyle = '#f60';
+        // 使用固定的 canvas 尺寸，确保一致性
+        var canvas = document.createElement("canvas");
+        canvas.width = 200;
+        canvas.height = 50;
+        var ctx = canvas.getContext("2d");
+        if (!ctx) return "not-supported"; // 使用固定的绘制参数，确保每次生成一致
+
+        ctx.textBaseline = "top";
+        ctx.font = "14px Arial";
+        ctx.fillStyle = "#f60";
         ctx.fillRect(125, 1, 62, 20);
-        ctx.fillStyle = '#069';
-        ctx.fillText('Canvas fingerprint', 2, 15);
-        ctx.fillStyle = 'rgba(102, 204, 0, 0.7)';
-        ctx.fillText('Canvas fingerprint', 4, 17);
-        return canvas.toDataURL().slice(-50); // 取后50个字符
+        ctx.fillStyle = "#069";
+        ctx.fillText("Canvas fingerprint", 2, 15);
+        ctx.fillStyle = "rgba(102, 204, 0, 0.7)";
+        ctx.fillText("Canvas fingerprint", 4, 17); // 取后50个字符作为指纹
+
+        return canvas.toDataURL().slice(-50);
       } catch (e) {
-        return 'error';
+        return "error";
       }
     };
     /**
      * 获取音频上下文指纹
+     * 注意：只使用稳定的 sampleRate，不使用 currentTime（会随时间变化）
      * @returns 音频指纹字符串
      */
 
@@ -935,26 +941,14 @@ function () {
     this.getAudioFingerprint = function () {
       try {
         var AudioContextClass = window.AudioContext || window.webkitAudioContext;
-        if (!AudioContextClass) return 'not-supported';
-        var context = new AudioContextClass();
-        var oscillator = context.createOscillator();
-        var analyser = context.createAnalyser();
-        var gain = context.createGain();
-        var scriptProcessor = context.createScriptProcessor(4096, 1, 1);
-        oscillator.type = 'triangle';
-        oscillator.frequency.value = 10000;
-        gain.gain.value = 0;
-        oscillator.connect(analyser);
-        analyser.connect(scriptProcessor);
-        scriptProcessor.connect(gain);
-        gain.connect(context.destination);
-        oscillator.start(0);
-        var fingerprint = context.sampleRate + '|' + context.currentTime;
-        oscillator.stop();
+        if (!AudioContextClass) return "not-supported";
+        var context = new AudioContextClass(); // 只使用稳定的 sampleRate，不使用 currentTime（会随时间变化导致指纹不一致）
+
+        var fingerprint = String(context.sampleRate || 0);
         context.close();
         return fingerprint;
       } catch (e) {
-        return 'error';
+        return "error";
       }
     };
     /**
@@ -965,15 +959,15 @@ function () {
 
     this.getFontFingerprint = function () {
       try {
-        var baseFonts_1 = ['monospace', 'sans-serif', 'serif'];
-        var testString_1 = 'mmmmmmmmmmlli';
-        var testSize_1 = '72px';
-        var canvas = document.createElement('canvas');
-        var ctx_1 = canvas.getContext('2d');
-        if (!ctx_1) return 'not-supported';
+        var baseFonts_1 = ["monospace", "sans-serif", "serif"];
+        var testString_1 = "mmmmmmmmmmlli";
+        var testSize_1 = "72px";
+        var canvas = document.createElement("canvas");
+        var ctx_1 = canvas.getContext("2d");
+        if (!ctx_1) return "not-supported";
         var detectedFonts_1 = []; // 测试字体列表
 
-        var fonts = ['Arial', 'Arial Black', 'Comic Sans MS', 'Courier New', 'Georgia', 'Helvetica', 'Impact', 'Times New Roman', 'Trebuchet MS', 'Verdana']; // 获取基准宽度
+        var fonts = ["Arial", "Arial Black", "Comic Sans MS", "Courier New", "Georgia", "Helvetica", "Impact", "Times New Roman", "Trebuchet MS", "Verdana"]; // 获取基准宽度
 
         var baseWidths_1 = {};
         baseFonts_1.forEach(function (font) {
@@ -996,9 +990,9 @@ function () {
             detectedFonts_1.push(font);
           }
         });
-        return detectedFonts_1.join(',');
+        return detectedFonts_1.join(",");
       } catch (e) {
-        return 'error';
+        return "error";
       }
     };
     /**
@@ -1021,9 +1015,9 @@ function () {
           }
         }
 
-        return plugins.join(';');
+        return plugins.join(";");
       } catch (e) {
-        return 'error';
+        return "error";
       }
     };
     /**
@@ -1034,7 +1028,7 @@ function () {
 
     this.hasLocalStorage = function () {
       try {
-        var test = '__test__';
+        var test = "__test__";
         localStorage.setItem(test, test);
         localStorage.removeItem(test);
         return true;
@@ -1050,7 +1044,7 @@ function () {
 
     this.hasSessionStorage = function () {
       try {
-        var test = '__test__';
+        var test = "__test__";
         sessionStorage.setItem(test, test);
         sessionStorage.removeItem(test);
         return true;
@@ -1065,7 +1059,7 @@ function () {
 
 
     this.hasIndexedDB = function () {
-      return 'indexedDB' in window && indexedDB !== null;
+      return "indexedDB" in window && indexedDB !== null;
     };
     /**
      * 获取网络连接指纹
@@ -1076,10 +1070,11 @@ function () {
     this.getConnectionFingerprint = function () {
       try {
         var connection = navigator.connection || navigator.mozConnection || navigator.webkitConnection;
-        if (!connection) return 'not-supported';
-        return connection.effectiveType + "|" + connection.downlink + "|" + connection.rtt;
+        if (!connection) return "not-supported"; // 只使用稳定的 effectiveType，不使用 downlink 和 rtt（会随网络状态变化导致指纹不一致）
+
+        return connection.effectiveType || "unknown";
       } catch (e) {
-        return 'error';
+        return "error";
       }
     };
     /**
@@ -1102,12 +1097,14 @@ function () {
         hash1 = (hash1 << 5) + hash1 + char; // hash1 * 33 + char
 
         hash2 = (hash2 << 5) + hash2 + char; // hash2 * 33 + char
-      } // 组合两个哈希值并转换为64位整数
+      } // 将两个32位哈希值转换为十六进制字符串并拼接，保持完整长度
+
 
+      var hash1Hex = (hash1 >>> 0).toString(16).padStart(8, '0'); // 32位 = 8个十六进制字符
 
-      var combinedHash = (hash1 >>> 0) * 4096 + (hash2 >>> 0); // 转换为36进制并添加前缀，增加长度和唯一性
+      var hash2Hex = (hash2 >>> 0).toString(16).padStart(8, '0'); // 32位 = 8个十六进制字符
 
-      var deviceId = 'fp_' + combinedHash.toString(36);
+      var deviceId = "fp_" + hash1Hex + hash2Hex;
       return deviceId;
     };
   }
@@ -1239,16 +1236,24 @@ function (_super) {
   __extends(WebTracking, _super);
 
   function WebTracking() {
-    var _this = _super.call(this) || this; // 批量发送队列
+    var _this = _super.call(this) || this; // 批量发送定时器
 
 
-    _this.batchQueue = []; // 批量发送定时器
-
     _this.batchTimer = null; // LocalStorage 存储 key
 
     _this.BATCH_QUEUE_STORAGE_KEY = "web_tracking_batch_queue"; // 是否使用自定义 pageKey（如果为 true，路由变化时不会自动更新 pageKey）
 
-    _this.useCustomPageKey = false; // 用户信息
+    _this.useCustomPageKey = false; // 页面卸载监听器是否已设置
+
+    _this.isUnloadListenerSetup = false; // 定时上报页面停留时长的定时器
+
+    _this.pageDurationTimer = null; // LocalStorage 存储 key（待发送请求）
+
+    _this.PENDING_REQUESTS_STORAGE_KEY = "web_tracking_pending_requests"; // 待发送请求队列最大大小（默认值，可通过配置覆盖）
+
+    _this.DEFAULT_PENDING_REQUESTS_MAX_SIZE = 50; // LocalStorage 最大大小限制（4MB）
+
+    _this.MAX_STORAGE_SIZE = 4 * 1024 * 1024; // 用户信息
 
     _this.userInfo = null; // 当前路由
 
@@ -1285,20 +1290,31 @@ function (_super) {
 
       _this.systemsInfo = _this.getSystemsInfo(initParams.platform); // 获取设备ID
 
-      _this.deviceId = _this.getDeviceId();
+      _this.deviceId = _this.getDeviceId(); // 如果传入了 userInfo，设置用户信息
+
+      if (initParams.userInfo && _this.isObject(initParams.userInfo)) {
+        _this.userInfo = initParams.userInfo;
+      }
 
       _this.setCookie("retainedStartTime", _this.getTimeStamp()); // 如果启用了批量发送，从 LocalStorage 恢复队列
 
 
       if (_this.initConfig.batchSend) {
-        _this.restoreBatchQueueFromStorage(); // 监听页面卸载事件，保存队列
+        _this.restoreBatchQueueFromStorage();
+      } // 恢复待发送的单个请求
+
 
+      _this.restorePendingRequestsFromStorage(); // 无论是否启用批量发送，都需要监听页面卸载事件，确保数据发送
 
-        _this.setupBeforeUnloadListener();
+
+      _this.setupBeforeUnloadListener(); // 如果启用了定时上报，启动定时器
+
+
+      if (_this.initConfig.autoTrackPageDurationInterval) {
+        _this.startPageDurationTimer();
       }
     };
     /**
-     * TODO: 需要判断有哪些不能被预制的参数
      * @description 预置参数
      * @param  {object} PresetParams     [预置参数]
      */
@@ -1324,8 +1340,14 @@ function (_super) {
           if (key === 'pageKey') return;
 
           if (_this.initConfig.hasOwnProperty(key)) {
-            // TODO：后面加一些校验
-            _this.initConfig[key] = val;
+            // 参数验证
+            var validationResult = _this.validateConfigParam(String(key), val);
+
+            if (validationResult.valid) {
+              _this.initConfig[key] = val;
+            } else {
+              _this.printLog("\u914D\u7F6E\u53C2\u6570\u9A8C\u8BC1\u5931\u8D25: " + String(key) + " = " + val + ", \u539F\u56E0: " + validationResult.message);
+            }
           }
         });
       }
@@ -1334,17 +1356,155 @@ function (_super) {
         _this.printLog("当前 server_url 为空或不正确，只在控制台打印日志，network 中不会发数据，请配置正确的 server_url！");
 
         _this.initConfig["showLog"] = true;
-      } // 如果启用了全埋点
+      } // 如果启用了全埋点或启用了 data-part-key 点击追踪
 
 
-      if (!!_this.initConfig["autoTrack"]) {
+      if (!!_this.initConfig["autoTrack"] || !!_this.initConfig["trackPartKeyClick"]) {
         // 启用监听
         _this.listener();
       } else {
         // 取消监听
         _this.unlistener();
+      } // 处理定时上报配置
+
+
+      if (_this.initConfig.autoTrackPageDurationInterval) {
+        _this.startPageDurationTimer();
+      } else {
+        _this.stopPageDurationTimer();
       }
     };
+    /**
+     * @description 验证配置参数
+     * @param key 参数名
+     * @param value 参数值
+     * @returns 验证结果
+     */
+
+
+    _this.validateConfigParam = function (key, value) {
+      switch (key) {
+        case 'sampleRate':
+          if (typeof value !== 'number' || value < 0 || value > 1) {
+            return {
+              valid: false,
+              message: 'sampleRate 必须是 0-1 之间的数字'
+            };
+          }
+
+          break;
+
+        case 'sendTimeout':
+          if (typeof value !== 'number' || value <= 0) {
+            return {
+              valid: false,
+              message: 'sendTimeout 必须是大于 0 的数字'
+            };
+          }
+
+          break;
+
+        case 'batchInterval':
+          if (typeof value !== 'number' || value <= 0) {
+            return {
+              valid: false,
+              message: 'batchInterval 必须是大于 0 的数字'
+            };
+          }
+
+          break;
+
+        case 'batchMaxSize':
+          if (typeof value !== 'number' || value <= 0 || !Number.isInteger(value)) {
+            return {
+              valid: false,
+              message: 'batchMaxSize 必须是大于 0 的整数'
+            };
+          }
+
+          break;
+
+        case 'pendingRequestsMaxSize':
+          if (typeof value !== 'number' || value <= 0 || !Number.isInteger(value)) {
+            return {
+              valid: false,
+              message: 'pendingRequestsMaxSize 必须是大于 0 的整数'
+            };
+          }
+
+          break;
+
+        case 'pageDurationInterval':
+          if (typeof value !== 'number' || value <= 0) {
+            return {
+              valid: false,
+              message: 'pageDurationInterval 必须是大于 0 的数字'
+            };
+          }
+
+          break;
+
+        case 'sendMethod':
+          if (typeof value !== 'string' || !['auto', 'xhr', 'beacon'].includes(value)) {
+            return {
+              valid: false,
+              message: 'sendMethod 必须是 auto、xhr 或 beacon'
+            };
+          }
+
+          break;
+
+        case 'showLog':
+        case 'autoTrack':
+        case 'isTrackSinglePage':
+        case 'batchSend':
+        case 'trackPartKeyClick':
+        case 'autoTrackPageDurationInterval':
+          if (typeof value !== 'boolean') {
+            return {
+              valid: false,
+              message: key + " \u5FC5\u987B\u662F\u5E03\u5C14\u503C"
+            };
+          }
+
+          break;
+
+        case 'business':
+        case 'header':
+          if (value !== null && _typeof(value) !== 'object') {
+            return {
+              valid: false,
+              message: key + " \u5FC5\u987B\u662F\u5BF9\u8C61\u6216 null"
+            };
+          }
+
+          break;
+
+        case 'contentType':
+          if (value !== 'application/json' && value !== 'application/x-www-form-urlencoded') {
+            return {
+              valid: false,
+              message: 'contentType 必须是 application/json 或 application/x-www-form-urlencoded'
+            };
+          }
+
+          break;
+
+        case 'platform':
+          if (typeof value !== 'string') {
+            return {
+              valid: false,
+              message: 'platform 必须是字符串'
+            };
+          }
+
+          break;
+      }
+
+      return {
+        valid: true
+      };
+    };
     /**
      * 用户登录
      */
@@ -1437,17 +1597,26 @@ function (_super) {
 
 
     _this.listener = function () {
-      if (!!_this.initConfig.isTrackSinglePage) {
-        _this.rewriteHistory();
+      // 先移除旧的监听器，避免重复绑定
+      _this.unlistener(); // 如果启用了全埋点，监听页面浏览事件
 
-        _this.addSinglePageEvent(_this.onPageViewCallback);
-      }
 
-      _this.each(["load", "beforeunload"], function (historyType) {
-        _this.addEventListener(window, historyType, _this.onPageViewCallback);
-      });
+      if (!!_this.initConfig.autoTrack) {
+        if (!!_this.initConfig.isTrackSinglePage) {
+          _this.rewriteHistory();
 
-      _this.addEventListener(window, "click", _this.onClickCallback);
+          _this.addSinglePageEvent(_this.onPageViewCallback);
+        }
+
+        _this.each(["load", "beforeunload"], function (historyType) {
+          _this.addEventListener(window, historyType, _this.onPageViewCallback);
+        });
+      } // 如果启用了全埋点或启用了 data-part-key 点击追踪，监听点击事件
+
+
+      if (!!_this.initConfig.autoTrack || !!_this.initConfig.trackPartKeyClick) {
+        _this.addEventListener(window, "click", _this.onClickCallback);
+      }
     };
     /**
      * @description 取消全埋点事件
@@ -1471,7 +1640,10 @@ function (_super) {
       _this.removeEventListener(window, "click", _this.onClickCallback); // 清理批量发送定时器
 
 
-      _this.clearBatchTimer();
+      _this.clearBatchTimer(); // 清理定时上报定时器
+
+
+      _this.stopPageDurationTimer();
     };
     /**
      * @description 清理批量发送定时器
@@ -1490,14 +1662,104 @@ function (_super) {
 
 
     _this.clearBatchQueue = function () {
-      _this.batchQueue = [];
-
       _this.setLocalStorage(_this.BATCH_QUEUE_STORAGE_KEY, "[]");
 
       if (_this.initConfig.showLog) {
         _this.printLog("批量队列已清空");
       }
     };
+    /**
+     * @description 从 LocalStorage 获取批量队列
+     * @returns 批量队列数组
+     */
+
+
+    _this.getBatchQueueFromStorage = function () {
+      try {
+        var storedQueue = _this.getLocalStorage(_this.BATCH_QUEUE_STORAGE_KEY);
+
+        if (storedQueue) {
+          var parsedQueue = JSON.parse(storedQueue);
+
+          if (Array.isArray(parsedQueue)) {
+            return parsedQueue;
+          }
+        }
+      } catch (e) {
+        _this.printLog("\u8BFB\u53D6\u6279\u91CF\u961F\u5217\u5931\u8D25: " + e); // 如果解析失败，清除损坏的数据
+
+
+        _this.setLocalStorage(_this.BATCH_QUEUE_STORAGE_KEY, "[]");
+      }
+
+      return [];
+    };
+    /**
+     * @description 保存批量队列到 LocalStorage
+     * @param queue 批量队列数组
+     */
+
+
+    _this.saveBatchQueueToStorage = function (queue) {
+      try {
+        var queueString = JSON.stringify(queue); // 检查存储大小，避免超出 LocalStorage 限制
+
+        if (queueString.length > _this.MAX_STORAGE_SIZE) {
+          var maxItems = Math.floor(queue.length * 0.8); // 保留 80%
+
+          var trimmedQueue = queue.slice(-maxItems);
+
+          _this.printLog("\u961F\u5217\u8FC7\u5927\uFF0C\u5DF2\u622A\u65AD\u4FDD\u7559\u6700\u65B0 " + maxItems + " \u6761\u6570\u636E\uFF08\u9650\u5236: " + _this.MAX_STORAGE_SIZE / 1024 / 1024 + "MB\uFF09");
+
+          _this.setLocalStorage(_this.BATCH_QUEUE_STORAGE_KEY, JSON.stringify(trimmedQueue));
+        } else {
+          _this.setLocalStorage(_this.BATCH_QUEUE_STORAGE_KEY, queueString);
+        }
+      } catch (e) {
+        // LocalStorage 可能已满或不可用
+        _this.printLog("\u4FDD\u5B58\u6279\u91CF\u961F\u5217\u5230 LocalStorage \u5931\u8D25: " + e);
+      }
+    };
+    /**
+     * @description 从 LocalStorage 获取待发送请求队列
+     * @returns 待发送请求队列数组
+     */
+
+
+    _this.getPendingRequestsFromStorage = function () {
+      try {
+        var storedRequests = _this.getLocalStorage(_this.PENDING_REQUESTS_STORAGE_KEY);
+
+        if (storedRequests) {
+          var parsedRequests = JSON.parse(storedRequests);
+
+          if (Array.isArray(parsedRequests)) {
+            return parsedRequests;
+          }
+        }
+      } catch (e) {
+        _this.printLog("\u8BFB\u53D6\u5F85\u53D1\u9001\u8BF7\u6C42\u5931\u8D25: " + e); // 如果解析失败，清除损坏的数据
+
+
+        _this.setLocalStorage(_this.PENDING_REQUESTS_STORAGE_KEY, "[]");
+      }
+
+      return [];
+    };
+    /**
+     * @description 保存待发送请求队列到 LocalStorage
+     * @param requests 待发送请求队列数组
+     */
+
+
+    _this.savePendingRequestsToStorage = function (requests) {
+      try {
+        _this.setLocalStorage(_this.PENDING_REQUESTS_STORAGE_KEY, JSON.stringify(requests));
+      } catch (e) {
+        // LocalStorage 可能已满或不可用
+        _this.printLog("\u4FDD\u5B58\u5F85\u53D1\u9001\u8BF7\u6C42\u5230 LocalStorage \u5931\u8D25: " + e);
+      }
+    };
     /**
      * @description 设置自定义页面唯一标识
      * @param pageKey 页面唯一标识，如果传入 null 或空字符串，则恢复自动生成
@@ -1566,7 +1828,7 @@ function (_super) {
         }
       });
 
-      return _this.sendData(params);
+      _this.sendData(params);
     };
     /**
      * @description 路由触发事件
@@ -1574,7 +1836,16 @@ function (_super) {
 
 
     _this.onPageViewCallback = function (e) {
-      var _a, _b;
+      var _a, _b; // 在路由变化前，先发送待发送的数据（避免被取消）
+
+
+      var pendingRequests = _this.getPendingRequestsFromStorage();
+
+      var batchQueue = _this.initConfig.batchSend ? _this.getBatchQueueFromStorage() : [];
+
+      if (pendingRequests.length > 0 || batchQueue.length > 0) {
+        _this.flushPendingData();
+      }
 
       var ORGIN = window.location.origin;
 
@@ -1591,6 +1862,13 @@ function (_super) {
 
       if (!_this.useCustomPageKey) {
         _this.pageKey = window.location.pathname.replace(/\//g, "_").substring(1);
+      } // 路由变化时，如果启用了定时上报，需要重启定时器
+
+
+      if (_this.initConfig.autoTrackPageDurationInterval) {
+        _this.stopPageDurationTimer();
+
+        _this.startPageDurationTimer();
       }
 
       _this.sendRetained(e.type);
@@ -1680,16 +1958,42 @@ function (_super) {
 
 
     _this.flushBatchQueue = function () {
-      if (_this.batchQueue.length === 0) return;
+      var batchQueue = _this.getBatchQueueFromStorage();
+
+      if (batchQueue.length === 0) return;
+
+      var currentTime = _this.getTimeStamp(); // 过滤出可以发送的数据（未到重试时间的不发送）
+
+
+      var readyToSend = batchQueue.filter(function (item) {
+        if (!item._nextRetryTime) {
+          return true;
+        }
+
+        return item._nextRetryTime <= currentTime;
+      });
 
-      var batchData = __spreadArray([], _this.batchQueue);
+      if (readyToSend.length === 0) {
+        if (_this.initConfig.showLog) {
+          _this.printLog("\u6279\u91CF\u961F\u5217\u4E2D\u6709 " + batchQueue.length + " \u6761\u6570\u636E\u7B49\u5F85\u91CD\u8BD5");
+        }
+
+        return;
+      } // 从队列中移除已准备发送的数据
+
+
+      var remainingQueue = batchQueue.filter(function (item) {
+        if (!item._nextRetryTime) {
+          return false;
+        }
 
-      _this.batchQueue = []; // 从 LocalStorage 中移除已发送的数据
+        return item._nextRetryTime > currentTime;
+      }); // 保存剩余的队列
 
-      _this.saveBatchQueueToStorage(); // 发送批量数据
+      _this.saveBatchQueueToStorage(remainingQueue); // 发送批量数据
 
 
-      _this.sendBatchData(batchData);
+      _this.sendBatchData(readyToSend);
     };
     /**
      * 发送批量数据
@@ -1701,7 +2005,9 @@ function (_super) {
       var _a = _this.initConfig,
           serverUrl = _a.serverUrl,
           contentType = _a.contentType,
-          showLog = _a.showLog;
+          showLog = _a.showLog,
+          sendMethod = _a.sendMethod,
+          initHeader = _a.header;
 
       if (showLog) {
         _this.printLog("\u6279\u91CF\u53D1\u9001 " + data.length + " \u6761\u6570\u636E");
@@ -1709,44 +2015,126 @@ function (_super) {
         data.forEach(function (item) {
           return _this.printLog(item);
         });
-      } // 这里可以根据实际需求决定是逐条发送还是打包发送
-      // 这里选择打包发送
-
-
-      _this.ajax({
-        url: serverUrl,
-        type: "POST",
-        data: JSON.stringify({
-          events: data
-        }),
-        contentType: contentType,
-        credentials: false,
-        timeout: _this.initConfig.sendTimeout,
-        cors: true,
-        success: function success() {
-          // 批量发送成功，数据已从队列中移除，无需额外操作
+      } // 判断是否使用 sendBeacon
+
+
+      var shouldUseBeacon = _this.shouldUseBeacon(sendMethod, undefined, initHeader); // 如果使用 sendBeacon
+
+
+      if (shouldUseBeacon) {
+        try {
+          var blob = new Blob([JSON.stringify(data)], {
+            type: contentType || "application/json"
+          });
+          var sent = navigator.sendBeacon(serverUrl, blob);
+
+          if (sent) {
+            // 发送成功，确保 LocalStorage 已清空
+            _this.saveBatchQueueToStorage([]);
+
+            if (showLog) {
+              _this.printLog("\u6279\u91CF\u53D1\u9001\u6210\u529F: " + data.length + " \u6761\u6570\u636E");
+            }
+          } else {
+            // sendBeacon 返回 false，重新加入队列以便重试
+            _this.printLog("\u6279\u91CF\u53D1\u9001\u5931\u8D25: sendBeacon \u8FD4\u56DE false\uFF0C\u6570\u636E\u5DF2\u91CD\u65B0\u52A0\u5165\u961F\u5217");
+
+            _this.retryBatchData(data);
+          }
+        } catch (e) {
+          // sendBeacon 失败，重新加入队列以便重试
+          _this.printLog("\u6279\u91CF\u53D1\u9001\u5931\u8D25: " + e + "\uFF0C\u6570\u636E\u5DF2\u91CD\u65B0\u52A0\u5165\u961F\u5217");
+
+          _this.retryBatchData(data);
+        }
+      } else {
+        // 使用 XMLHttpRequest 发送
+        _this.ajax({
+          url: serverUrl,
+          type: "POST",
+          data: JSON.stringify({
+            events: data
+          }),
+          contentType: contentType,
+          credentials: false,
+          timeout: _this.initConfig.sendTimeout,
+          cors: true,
+          success: function success() {
+            // 批量发送成功，确保 LocalStorage 已清空
+            // flushBatchQueue 在发送前已清空 LocalStorage，这里再次确认
+            _this.saveBatchQueueToStorage([]);
+
+            if (_this.initConfig.showLog) {
+              _this.printLog("\u6279\u91CF\u53D1\u9001\u6210\u529F: " + data.length + " \u6761\u6570\u636E");
+            }
+          },
+          error: function error(err) {
+            // 批量发送失败，重新加入队列以便重试
+            _this.printLog("\u6279\u91CF\u53D1\u9001\u5931\u8D25: " + err + "\uFF0C\u6570\u636E\u5DF2\u91CD\u65B0\u52A0\u5165\u961F\u5217");
+
+            _this.retryBatchData(data);
+          }
+        });
+      }
+    };
+    /**
+     * @description 批量数据重试逻辑
+     * @param data 批量数据
+     */
+
+
+    _this.retryBatchData = function (data) {
+      // 获取当前队列
+      var currentQueue = _this.getBatchQueueFromStorage(); // 去重：基于事件类型、itemKey、requestTime 生成唯一键
+
+
+      var getEventKey = function getEventKey(item) {
+        return item.event + "_" + item.itemKey + "_" + item.requestTime;
+      };
+
+      var existingKeys = new Set(currentQueue.map(getEventKey));
+      var maxRetryCount = 3; // 最大重试次数
+
+      var currentTime = _this.getTimeStamp(); // 过滤并更新重试信息
+
+
+      var retryData = data.filter(function (item) {
+        var key = getEventKey(item); // 检查是否已存在
+
+        if (existingKeys.has(key)) {
+          return false;
+        } // 检查重试次数
+
+
+        var retryCount = (item._retryCount || 0) + 1;
+
+        if (retryCount > maxRetryCount) {
           if (_this.initConfig.showLog) {
-            _this.printLog("\u6279\u91CF\u53D1\u9001\u6210\u529F: " + data.length + " \u6761\u6570\u636E");
+            _this.printLog("\u6570\u636E\u5DF2\u8FBE\u5230\u6700\u5927\u91CD\u8BD5\u6B21\u6570\uFF0C\u653E\u5F03\u91CD\u8BD5: " + key);
           }
-        },
-        error: function error(err) {
-          var _a; // 批量发送失败，重新加入队列以便重试
 
+          return false;
+        } // 更新重试信息
 
-          _this.printLog("\u6279\u91CF\u53D1\u9001\u5931\u8D25: " + err + "\uFF0C\u6570\u636E\u5DF2\u91CD\u65B0\u52A0\u5165\u961F\u5217"); // 将失败的数据重新加入队列，避免数据丢失
 
+        item._retryCount = retryCount; // 指数退避：2^retryCount * 1000ms
 
-          (_a = _this.batchQueue).unshift.apply(_a, data); // 限制重试队列大小，避免内存溢出
+        item._nextRetryTime = currentTime + Math.pow(2, retryCount) * 1000;
+        existingKeys.add(key);
+        return true;
+      }); // 将失败的数据重新加入队列（添加到队列前面，优先重试）
 
+      var retryQueue = __spreadArray(__spreadArray([], retryData), currentQueue); // 限制重试队列大小，避免内存溢出
 
-          if (_this.batchQueue.length > _this.initConfig.batchMaxSize * 2) {
-            _this.batchQueue = _this.batchQueue.slice(0, _this.initConfig.batchMaxSize);
-          } // 保存失败的数据到 LocalStorage
 
+      var maxSize = _this.initConfig.batchMaxSize * 2;
+      var trimmedQueue = retryQueue.length > maxSize ? retryQueue.slice(0, maxSize) : retryQueue; // 保存失败的数据到 LocalStorage，确保数据不丢失
 
-          _this.saveBatchQueueToStorage();
-        }
-      });
+      _this.saveBatchQueueToStorage(trimmedQueue);
+
+      if (_this.initConfig.showLog) {
+        _this.printLog("\u5DF2\u5C06 " + retryData.length + " \u6761\u6570\u636E\u52A0\u5165\u91CD\u8BD5\u961F\u5217");
+      }
     };
     /**
      * 添加到批量队列
@@ -1757,15 +2145,26 @@ function (_super) {
     _this.addToBatchQueue = function (params) {
       var _a = _this.initConfig,
           batchInterval = _a.batchInterval,
-          batchMaxSize = _a.batchMaxSize;
+          batchMaxSize = _a.batchMaxSize; // 数据采样判断（在添加到队列前判断）
+
+      if (!_this.shouldSample()) {
+        if (_this.initConfig.showLog) {
+          _this.printLog("数据已采样跳过（批量模式）");
+        }
+
+        return;
+      } // 从 LocalStorage 获取当前队列
+
 
-      _this.batchQueue.push(params); // 保存到 LocalStorage
+      var currentQueue = _this.getBatchQueueFromStorage(); // 添加新数据
 
 
-      _this.saveBatchQueueToStorage(); // 如果队列达到最大数量，立即发送
+      currentQueue.push(params); // 保存到 LocalStorage
 
+      _this.saveBatchQueueToStorage(currentQueue); // 如果队列达到最大数量，立即发送
 
-      if (_this.batchQueue.length >= batchMaxSize) {
+
+      if (currentQueue.length >= batchMaxSize) {
         _this.flushBatchQueue();
 
         return;
@@ -1786,109 +2185,289 @@ function (_super) {
 
 
     _this.restoreBatchQueueFromStorage = function () {
-      try {
-        var storedQueue = _this.getLocalStorage(_this.BATCH_QUEUE_STORAGE_KEY);
-
-        if (storedQueue) {
-          var parsedQueue = JSON.parse(storedQueue);
+      var batchQueue = _this.getBatchQueueFromStorage();
 
-          if (Array.isArray(parsedQueue) && parsedQueue.length > 0) {
-            _this.batchQueue = parsedQueue;
+      if (batchQueue.length > 0) {
+        if (_this.initConfig.showLog) {
+          _this.printLog("\u4ECE LocalStorage \u6062\u590D " + batchQueue.length + " \u6761\u5F85\u53D1\u9001\u6570\u636E");
+        } // 恢复后立即尝试发送（如果达到条件）
 
-            if (_this.initConfig.showLog) {
-              _this.printLog("\u4ECE LocalStorage \u6062\u590D " + parsedQueue.length + " \u6761\u5F85\u53D1\u9001\u6570\u636E");
-            } // 恢复后立即尝试发送（如果达到条件）
 
+        var batchMaxSize = _this.initConfig.batchMaxSize;
 
-            var batchMaxSize = _this.initConfig.batchMaxSize;
+        if (batchQueue.length >= batchMaxSize) {
+          _this.flushBatchQueue();
+        } else {
+          // 设置定时发送
+          var batchInterval = _this.initConfig.batchInterval;
 
-            if (_this.batchQueue.length >= batchMaxSize) {
+          if (!_this.batchTimer) {
+            _this.batchTimer = window.setTimeout(function () {
               _this.flushBatchQueue();
-            } else {
-              // 设置定时发送
-              var batchInterval = _this.initConfig.batchInterval;
-
-              if (!_this.batchTimer) {
-                _this.batchTimer = window.setTimeout(function () {
-                  _this.flushBatchQueue();
 
-                  _this.batchTimer = null;
-                }, batchInterval);
-              }
-            }
+              _this.batchTimer = null;
+            }, batchInterval);
           }
         }
-      } catch (e) {
-        _this.printLog("\u6062\u590D\u6279\u91CF\u961F\u5217\u5931\u8D25: " + e); // 如果解析失败，清除损坏的数据
+      }
+    };
+    /**
+     * 添加到待发送请求队列
+     * @param params 数据参数
+     */
 
 
-        _this.setLocalStorage(_this.BATCH_QUEUE_STORAGE_KEY, "[]");
+    _this.addToPendingRequests = function (params) {
+      // 从 LocalStorage 获取当前队列
+      var currentRequests = _this.getPendingRequestsFromStorage(); // 添加新数据
+
+
+      currentRequests.push(params); // 限制队列大小，防止内存溢出
+
+      var maxSize = _this.initConfig.pendingRequestsMaxSize || _this.DEFAULT_PENDING_REQUESTS_MAX_SIZE;
+
+      if (currentRequests.length > maxSize) {
+        var trimmedRequests = currentRequests.slice(-maxSize);
+
+        if (_this.initConfig.showLog) {
+          _this.printLog("\u5F85\u53D1\u9001\u8BF7\u6C42\u961F\u5217\u5DF2\u6EE1\uFF0C\u5DF2\u79FB\u9664\u6700\u65E7\u7684\u6570\u636E\uFF08\u6700\u5927\u9650\u5236: " + maxSize + "\uFF09");
+        }
+
+        _this.savePendingRequestsToStorage(trimmedRequests);
+      } else {
+        _this.savePendingRequestsToStorage(currentRequests);
       }
     };
     /**
-     * 保存批量队列到 LocalStorage
+     * 从 LocalStorage 恢复待发送请求
      */
 
 
-    _this.saveBatchQueueToStorage = function () {
-      try {
-        var queueString = JSON.stringify(_this.batchQueue); // 检查存储大小，避免超出 LocalStorage 限制（通常 5-10MB）
-        // 如果队列过大，只保留最新的数据
+    _this.restorePendingRequestsFromStorage = function () {
+      var pendingRequests = _this.getPendingRequestsFromStorage();
 
-        if (queueString.length > 4 * 1024 * 1024) {
-          // 4MB 限制
-          var maxItems = Math.floor(_this.batchQueue.length * 0.8); // 保留 80%
+      if (pendingRequests.length > 0) {
+        if (_this.initConfig.showLog) {
+          _this.printLog("\u4ECE LocalStorage \u6062\u590D " + pendingRequests.length + " \u6761\u5F85\u53D1\u9001\u8BF7\u6C42");
+        } // 注意：恢复后不立即发送，避免重复
+        // 数据会留在 LocalStorage 中，等待下次正常发送或页面卸载时发送
+        // 这样可以避免与批量队列冲突
 
-          _this.batchQueue = _this.batchQueue.slice(-maxItems);
+      }
+    };
+    /**
+     * 检查页面是否即将卸载
+     * @returns 如果页面即将卸载返回 true，否则返回 false
+     */
 
-          _this.printLog("\u961F\u5217\u8FC7\u5927\uFF0C\u5DF2\u622A\u65AD\u4FDD\u7559\u6700\u65B0 " + maxItems + " \u6761\u6570\u636E");
-        }
 
-        _this.setLocalStorage(_this.BATCH_QUEUE_STORAGE_KEY, JSON.stringify(_this.batchQueue));
+    _this.isPageUnloading = function () {
+      return document.visibilityState === "hidden";
+    };
+    /**
+     * 使用 sendBeacon 发送数据（页面卸载时的备用方案）
+     * @param params 数据参数
+     * @param serverUrl 服务器地址
+     * @param contentType 内容类型
+     * @returns 是否发送成功
+     */
+
+
+    _this.sendWithBeacon = function (params, serverUrl, contentType) {
+      try {
+        var blob = new Blob([JSON.stringify(params)], {
+          type: contentType || "application/json"
+        });
+        return navigator.sendBeacon(serverUrl, blob);
       } catch (e) {
-        // LocalStorage 可能已满或不可用
-        _this.printLog("\u4FDD\u5B58\u6279\u91CF\u961F\u5217\u5230 LocalStorage \u5931\u8D25: " + e);
+        if (_this.initConfig.showLog) {
+          _this.printLog("sendBeacon \u53D1\u9001\u5931\u8D25: " + e);
+        }
+
+        return false;
       }
     };
     /**
-     * 设置页面卸载监听器，保存队列
+     * 刷新待发送的单个请求（正常情况下的发送）
+     * 注意：这个方法会直接使用 ajax 发送，避免通过 sendData 导致重复
+     */
+
+
+    _this.flushPendingRequests = function () {
+      var pendingRequests = _this.getPendingRequestsFromStorage();
+
+      if (pendingRequests.length === 0) {
+        return;
+      } // 清除 LocalStorage 中的待发送请求
+
+
+      _this.savePendingRequestsToStorage([]); // 直接使用 ajax 发送每个请求，避免通过 sendData 导致重复
+
+
+      var _a = _this.initConfig,
+          serverUrl = _a.serverUrl,
+          sendTimeout = _a.sendTimeout,
+          contentType = _a.contentType,
+          showLog = _a.showLog,
+          initHeader = _a.header;
+      pendingRequests.forEach(function (params) {
+        // 数据采样判断
+        if (!_this.shouldSample()) {
+          if (showLog) {
+            _this.printLog("待发送请求已采样跳过");
+          }
+
+          return;
+        }
+
+        if (showLog) {
+          _this.printLog(params);
+        } // 直接使用 ajax 发送
+
+
+        _this.ajax({
+          header: initHeader,
+          url: serverUrl,
+          type: "POST",
+          data: JSON.stringify(params),
+          contentType: contentType,
+          credentials: false,
+          timeout: sendTimeout,
+          cors: true,
+          success: function success() {
+            if (showLog) {
+              _this.printLog("待发送请求发送成功");
+            }
+          },
+          error: function error(err) {
+            if (showLog) {
+              _this.printLog("\u5F85\u53D1\u9001\u8BF7\u6C42\u53D1\u9001\u5931\u8D25\uFF08\u4E0D\u518D\u91CD\u8BD5\uFF09: " + err);
+            }
+          }
+        });
+      });
+    };
+    /**
+     * 设置页面卸载监听器，确保数据发送
      */
 
 
     _this.setupBeforeUnloadListener = function () {
-      // 使用 visibilitychange 事件（更可靠）
+      // 避免重复设置监听器
+      if (_this.isUnloadListenerSetup) {
+        return;
+      }
+
+      _this.isUnloadListenerSetup = true; // 使用 visibilitychange 事件（更可靠，支持页面跳转、切换标签页等场景）
+
       document.addEventListener("visibilitychange", function () {
-        if (document.visibilityState === "hidden" && _this.batchQueue.length > 0) {
-          _this.saveBatchQueueToStorage();
+        if (_this.isPageUnloading()) {
+          _this.flushPendingData();
         }
-      }); // 使用 beforeunload 事件作为备用
+      }); // 使用 beforeunload 事件作为备用（页面关闭/刷新）
 
       window.addEventListener("beforeunload", function () {
-        if (_this.batchQueue.length > 0) {
-          // 使用 sendBeacon 尝试发送数据（如果支持）
-          if (navigator.sendBeacon && _this.initConfig.serverUrl) {
-            try {
-              var data = JSON.stringify({
-                events: _this.batchQueue
-              });
-              var blob = new Blob([data], {
-                type: "application/json"
-              });
-              navigator.sendBeacon(_this.initConfig.serverUrl, blob); // 如果 sendBeacon 成功，清除队列
+        _this.flushPendingData();
+      }); // 使用 pagehide 事件（更可靠，支持移动端）
+
+      window.addEventListener("pagehide", function () {
+        _this.flushPendingData();
+      });
+    }; // 标记是否正在刷新待发送数据，避免重复发送
+
+
+    _this.isFlushingPendingData = false;
+    /**
+     * 刷新待发送数据（在页面卸载/跳转时调用）
+     */
+
+    _this.flushPendingData = function () {
+      // 如果正在刷新，避免重复执行
+      if (_this.isFlushingPendingData) {
+        return;
+      } // 页面卸载时停止定时器
+
+
+      _this.stopPageDurationTimer(); // 收集所有待发送的数据
+
+
+      var allPendingData = []; // 如果有批量队列，添加到待发送列表
+
+      var batchQueue = _this.getBatchQueueFromStorage();
+
+      if (batchQueue.length > 0) {
+        allPendingData.push.apply(allPendingData, batchQueue);
+      } // 如果有待发送的单个请求，也添加到列表
+
+
+      var pendingRequests = _this.getPendingRequestsFromStorage();
+
+      if (pendingRequests.length > 0) {
+        allPendingData.push.apply(allPendingData, pendingRequests);
+      }
+
+      if (allPendingData.length === 0) {
+        return;
+      } // 标记正在刷新
+
+
+      _this.isFlushingPendingData = true; // 先保存到 LocalStorage，确保数据不丢失（在发送前保存）
+
+      try {
+        if (_this.initConfig.batchSend) {
+          _this.setLocalStorage(_this.BATCH_QUEUE_STORAGE_KEY, JSON.stringify(allPendingData));
+        } else {
+          _this.setLocalStorage(_this.PENDING_REQUESTS_STORAGE_KEY, JSON.stringify(allPendingData));
+        }
+      } catch (e) {
+        if (_this.initConfig.showLog) {
+          _this.printLog("\u4FDD\u5B58\u5F85\u53D1\u9001\u8BF7\u6C42\u5230 LocalStorage \u5931\u8D25: " + e);
+        }
+      } // 使用 sendBeacon 发送数据（最可靠的方式）
+
+
+      if (navigator.sendBeacon && _this.initConfig.serverUrl) {
+        try {
+          // 如果只有一条数据，直接发送；否则批量发送
+          var dataToSend = allPendingData.length === 1 ? allPendingData[0] : allPendingData;
+          var blob = new Blob([JSON.stringify(dataToSend)], {
+            type: _this.initConfig.contentType || "application/json"
+          });
+          var sent = navigator.sendBeacon(_this.initConfig.serverUrl, blob);
+
+          if (sent) {
+            // 发送成功，清除所有 LocalStorage
+            _this.setLocalStorage(_this.BATCH_QUEUE_STORAGE_KEY, "[]");
 
-              _this.batchQueue = [];
+            _this.setLocalStorage(_this.PENDING_REQUESTS_STORAGE_KEY, "[]");
 
-              _this.setLocalStorage(_this.BATCH_QUEUE_STORAGE_KEY, "[]");
-            } catch (e) {
-              // sendBeacon 失败，保存到 LocalStorage
-              _this.saveBatchQueueToStorage();
+            if (_this.initConfig.showLog) {
+              _this.printLog("\u9875\u9762\u5378\u8F7D\u65F6\u6210\u529F\u53D1\u9001 " + allPendingData.length + " \u6761\u6570\u636E");
             }
           } else {
-            // 不支持 sendBeacon，保存到 LocalStorage
-            _this.saveBatchQueueToStorage();
+            // sendBeacon 返回 false，数据已在 LocalStorage 中，等待下次恢复
+            if (_this.initConfig.showLog) {
+              _this.printLog("sendBeacon \u8FD4\u56DE false\uFF0C\u6570\u636E\u5DF2\u4FDD\u5B58\u5230 LocalStorage \u7B49\u5F85\u4E0B\u6B21\u6062\u590D");
+            }
+          }
+        } catch (e) {
+          // sendBeacon 失败，数据已在 LocalStorage 中，等待下次恢复
+          if (_this.initConfig.showLog) {
+            _this.printLog("\u9875\u9762\u5378\u8F7D\u65F6\u53D1\u9001\u6570\u636E\u5931\u8D25: " + e + "\uFF0C\u6570\u636E\u5DF2\u4FDD\u5B58\u5230 LocalStorage");
           }
+        } finally {
+          // 重置标记
+          _this.isFlushingPendingData = false;
         }
-      });
+      } else {
+        // 不支持 sendBeacon，数据已在 LocalStorage 中，等待下次恢复
+        if (_this.initConfig.showLog) {
+          _this.printLog("\u4E0D\u652F\u6301 sendBeacon\uFF0C\u6570\u636E\u5DF2\u4FDD\u5B58\u5230 LocalStorage \u7B49\u5F85\u4E0B\u6B21\u6062\u590D");
+        } // 重置标记
+
+
+        _this.isFlushingPendingData = false;
+      }
     };
     /**
      * 发送数据通用函数
@@ -1910,7 +2489,8 @@ function (_super) {
           contentType = _a.contentType,
           showLog = _a.showLog,
           initHeader = _a.header,
-          batchSend = _a.batchSend;
+          batchSend = _a.batchSend,
+          sendMethod = _a.sendMethod;
       if (!!showLog) _this.printLog(params); // 如果启用批量发送
 
       if (batchSend) {
@@ -1920,16 +2500,64 @@ function (_super) {
           success: true,
           message: "已添加到批量队列"
         });
-      }
+      } // 判断是否使用 sendBeacon
+
+
+      var shouldUseBeacon = _this.shouldUseBeacon(sendMethod, header, initHeader); // 如果使用 sendBeacon
+
+
+      if (shouldUseBeacon) {
+        // 检查页面是否即将卸载，如果是，直接使用 sendBeacon 发送，避免被取消
+        if (_this.isPageUnloading()) {
+          var sent = _this.sendWithBeacon(params, serverUrl, contentType);
+
+          if (sent) {
+            return Promise.resolve({
+              success: true,
+              message: "页面卸载时发送成功"
+            });
+          } else {
+            // sendBeacon 返回 false，添加到待发送队列
+            _this.addToPendingRequests(params);
+
+            return Promise.resolve({
+              success: true,
+              message: "已添加到待发送队列"
+            });
+          }
+        } // 正常情况使用 sendBeacon
+
 
-      if (_this.isSupportBeaconSend() === true && !header && !initHeader) {
         return _this.sendBeacon({
           contentType: contentType,
           url: serverUrl,
           data: params
+        }).catch(function (err) {
+          // sendBeacon 失败，添加到待发送队列，避免数据丢失
+          _this.addToPendingRequests(params);
+
+          return Promise.resolve({
+            success: true,
+            message: "sendBeacon 失败，已添加到待发送队列"
+          });
         });
       } else {
+        // 使用 XMLHttpRequest 发送
         return new Promise(function (resolve, reject) {
+          // 如果页面即将卸载且配置为 auto，尝试使用 sendBeacon 作为备用
+          if (_this.isPageUnloading() && sendMethod === 'auto' && _this.isSupportBeaconSend() && !header && !initHeader) {
+            var sent = _this.sendWithBeacon(params, serverUrl, contentType);
+
+            if (sent) {
+              resolve({
+                success: true,
+                message: "页面卸载时使用 sendBeacon 发送成功"
+              });
+              return;
+            } // sendBeacon 失败，继续使用 XMLHttpRequest
+
+          }
+
           _this.ajax({
             header: header || initHeader,
             url: serverUrl,
@@ -1946,7 +2574,20 @@ function (_super) {
               });
             },
             error: function error(err, status) {
-              return reject({
+              // 如果请求失败且页面即将卸载且配置为 auto，尝试使用 sendBeacon
+              if (_this.isPageUnloading() && sendMethod === 'auto' && _this.isSupportBeaconSend() && !header && !initHeader) {
+                var sent = _this.sendWithBeacon(params, serverUrl, contentType);
+
+                if (sent) {
+                  resolve({
+                    success: true,
+                    message: "XMLHttpRequest 失败，已使用 sendBeacon 发送"
+                  });
+                  return;
+                }
+              }
+
+              reject({
                 success: false,
                 message: String(err),
                 code: status
@@ -1956,6 +2597,30 @@ function (_super) {
         });
       }
     };
+    /**
+     * @description 判断是否应该使用 sendBeacon
+     * @param sendMethod 配置的发送方式
+     * @param header 自定义 header
+     * @param initHeader 初始化配置的 header
+     * @returns 是否使用 sendBeacon
+     */
+
+
+    _this.shouldUseBeacon = function (sendMethod, header, initHeader) {
+      // 如果配置为 xhr，不使用 beacon
+      if (sendMethod === 'xhr') {
+        return false;
+      } // 如果配置为 beacon，检查是否支持
+
+
+      if (sendMethod === 'beacon') {
+        return _this.isSupportBeaconSend() === true;
+      } // 如果配置为 auto（默认），使用原有逻辑
+      // 只有在支持 sendBeacon 且没有自定义 header 时才使用
+
+
+      return _this.isSupportBeaconSend() === true && !header && !initHeader;
+    };
     /**
      * @description 留存时长上报
      * @param type
@@ -1984,6 +2649,121 @@ function (_super) {
         _this.setCookie("retainedStartTime", _this.getTimeStamp());
       }
     };
+    /**
+     * @description 用户主动上报页面停留时长
+     * @param duration 自定义停留时长（毫秒），如果不传则自动计算从页面加载（或上次调用）到当前的时长
+     * @param options 可选参数，包括自定义描述、业务参数等
+     * @param resetStartTime 是否重置起始时间，默认 true（手动上报后重置，定时上报不重置）
+     * @returns Promise<TrackingResponse> 上报结果
+     */
+
+
+    _this.trackPageDuration = function (duration, options, resetStartTime) {
+      if (resetStartTime === void 0) {
+        resetStartTime = true;
+      } // 计算停留时长
+
+
+      var retainedDuration;
+
+      if (duration !== undefined && duration !== null) {
+        // 使用自定义时长
+        retainedDuration = Math.max(duration, 0);
+      } else {
+        // 自动计算时长
+        var __time = _this.getCookie("retainedStartTime");
+
+        var retainedStartTime = __time ? +__time : _this.getTimeStamp();
+
+        var currentTime = _this.getTimeStamp();
+
+        retainedDuration = Math.max(currentTime - retainedStartTime, 0);
+      } // 构建参数
+
+
+      var desc = (options === null || options === void 0 ? void 0 : options.desc) || _this.eventDescMap["PageRetained"];
+      var pageKey = (options === null || options === void 0 ? void 0 : options.pageKey) || _this.pageKey;
+      var business = (options === null || options === void 0 ? void 0 : options.business) || {};
+      var header = options === null || options === void 0 ? void 0 : options.header;
+
+      var params = _this.getParams({
+        event: "PageRetained",
+        desc: desc,
+        itemKey: _this.getItemKey(undefined, pageKey),
+        privateParamMap: {
+          business: business,
+          retainedDuration: retainedDuration
+        }
+      }); // 上报数据
+
+
+      var result = _this.sendData(params, header); // 根据 resetStartTime 参数决定是否重置起始时间
+      // 手动上报后重置起始时间，定时上报不重置（累积计算）
+
+
+      if (resetStartTime) {
+        _this.setCookie("retainedStartTime", _this.getTimeStamp());
+      }
+
+      return result;
+    };
+    /**
+     * @description 启动定时上报页面停留时长的定时器
+     */
+
+
+    _this.startPageDurationTimer = function () {
+      // 先停止现有的定时器（避免重复启动）
+      _this.stopPageDurationTimer();
+
+      var interval = _this.initConfig.pageDurationInterval || 30000; // 检查间隔时间是否有效
+
+      if (interval <= 0) {
+        if (_this.initConfig.showLog) {
+          _this.printLog("定时上报间隔时间无效，已禁用定时上报");
+        }
+
+        return;
+      } // 启动定时器
+
+
+      _this.pageDurationTimer = window.setInterval(function () {
+        // 只在页面可见时上报（避免后台上报）
+        if (document.visibilityState === "visible") {
+          // 定时上报：retainedDuration 直接使用上报间隔时间，数据工程师会清洗数据
+          _this.trackPageDuration(interval, {
+            desc: "定时上报页面停留时长",
+            business: {
+              reportType: "interval",
+              interval: interval
+            }
+          }, true).catch(function (err) {
+            if (_this.initConfig.showLog) {
+              _this.printLog("\u5B9A\u65F6\u4E0A\u62A5\u9875\u9762\u505C\u7559\u65F6\u957F\u5931\u8D25: " + err);
+            }
+          });
+        }
+      }, interval);
+
+      if (_this.initConfig.showLog) {
+        _this.printLog("\u5B9A\u65F6\u4E0A\u62A5\u9875\u9762\u505C\u7559\u65F6\u957F\u5DF2\u542F\u52A8\uFF0C\u95F4\u9694: " + interval + "ms");
+      }
+    };
+    /**
+     * @description 停止定时上报页面停留时长的定时器
+     */
+
+
+    _this.stopPageDurationTimer = function () {
+      if (_this.pageDurationTimer !== null) {
+        clearInterval(_this.pageDurationTimer);
+        _this.pageDurationTimer = null;
+
+        if (_this.initConfig.showLog) {
+          _this.printLog("定时上报页面停留时长已停止");
+        }
+      }
+    };
     /**
      * @description 获取 itemKey
      * @param  {[string]} partkey [控件/自定义事件的唯一标识]
@@ -2001,7 +2781,7 @@ function (_super) {
       }, "");
     };
 
-    _this.sdkVersion = "1.2.0"; // sdk版本
+    _this.sdkVersion = "1.2.3"; // sdk版本
 
     _this.initConfig = {
       appKey: "",
@@ -2017,7 +2797,12 @@ function (_super) {
       sampleRate: 1,
       batchSend: false,
       batchInterval: 5000,
-      batchMaxSize: 10 // 批量发送最大数量
+      batchMaxSize: 10,
+      trackPartKeyClick: false,
+      pendingRequestsMaxSize: 50,
+      autoTrackPageDurationInterval: false,
+      pageDurationInterval: 30000,
+      sendMethod: "auto" // 数据发送方式：auto（自动选择）、xhr（XMLHttpRequest）、beacon（sendBeacon）
 
     }; // 系统信息