@fle-sdk/event-tracking-web 1.2.0 → 1.2.2

package/lib/index.esm.js

@@ -1246,7 +1246,19 @@ function (_super) {
 
     _this.batchTimer = null; // LocalStorage 存储 key
 
-    _this.BATCH_QUEUE_STORAGE_KEY = 'web_tracking_batch_queue'; // 用户信息
+    _this.BATCH_QUEUE_STORAGE_KEY = "web_tracking_batch_queue"; // 是否使用自定义 pageKey（如果为 true，路由变化时不会自动更新 pageKey）
+
+    _this.useCustomPageKey = false; // 待发送的单个请求队列（用于页面跳转时发送）
+
+    _this.pendingRequests = []; // 页面卸载监听器是否已设置
+
+    _this.isUnloadListenerSetup = false; // 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; // 当前路由
 
@@ -1271,21 +1283,36 @@ function (_super) {
       _this.preset(initParams);
 
       var pathname = window.location.pathname;
-      _this.currentUrl = window.location.href;
-      _this.pageKey = pathname.replace(/\//g, "_").substring(1);
+      _this.currentUrl = window.location.href; // 如果传入了自定义 pageKey，使用自定义值，否则自动生成
+
+      if (initParams.pageKey) {
+        _this.pageKey = initParams.pageKey;
+        _this.useCustomPageKey = true;
+      } else {
+        _this.pageKey = pathname.replace(/\//g, "_").substring(1);
+        _this.useCustomPageKey = false;
+      }
+
       _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.setupBeforeUnloadListener();
-      }
+      _this.restorePendingRequestsFromStorage(); // 无论是否启用批量发送，都需要监听页面卸载事件，确保数据发送
+
+
+      _this.setupBeforeUnloadListener();
     };
     /**
      * TODO: 需要判断有哪些不能被预制的参数
@@ -1296,7 +1323,23 @@ function (_super) {
 
     _this.preset = function (presetParams) {
       if (presetParams instanceof Object) {
+        // 处理 pageKey 特殊逻辑
+        if (presetParams.pageKey !== undefined) {
+          if (presetParams.pageKey === null || presetParams.pageKey === '') {
+            // 恢复自动生成
+            _this.useCustomPageKey = false;
+            var pathname = window.location.pathname;
+            _this.pageKey = pathname.replace(/\//g, "_").substring(1);
+          } else {
+            _this.pageKey = presetParams.pageKey;
+            _this.useCustomPageKey = true;
+          }
+        }
+
         _this.each(presetParams, function (val, key) {
+          // 跳过 pageKey，因为已经单独处理
+          if (key === 'pageKey') return;
+
           if (_this.initConfig.hasOwnProperty(key)) {
             // TODO：后面加一些校验
             _this.initConfig[key] = val;
@@ -1308,10 +1351,10 @@ 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 {
@@ -1340,7 +1383,7 @@ function (_super) {
       } // 获取已存储的设备ID
 
 
-      var storedDeviceId = _this.getCookie('device_id') || _this.getLocalStorage('device_id');
+      var storedDeviceId = _this.getCookie("device_id") || _this.getLocalStorage("device_id");
 
       if (storedDeviceId) {
         _this.deviceId = storedDeviceId;
@@ -1354,10 +1397,10 @@ function (_super) {
       var deviceId = _this.hashFingerprint(fingerprint); // 存储设备ID（统一使用2年过期时间，与tools.ts保持一致）
 
 
-      _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);
 
       _this.deviceId = deviceId;
       return _this.deviceId;
@@ -1371,10 +1414,10 @@ function (_super) {
 
     _this.resetDeviceId = function () {
       // 清除cookie和localStorage中的设备ID
-      document.cookie = 'device_id=; expires=Thu, 01 Jan 1970 00:00:00 UTC; path=/;';
-      localStorage.removeItem('device_id'); // 清除内存中的设备ID
+      document.cookie = "device_id=; expires=Thu, 01 Jan 1970 00:00:00 UTC; path=/;";
+      localStorage.removeItem("device_id"); // 清除内存中的设备ID
 
-      _this.deviceId = ''; // 重新生成设备ID
+      _this.deviceId = ""; // 重新生成设备ID
 
       var newDeviceId = _this.getDeviceId();
 
@@ -1389,6 +1432,7 @@ function (_super) {
 
     _this.track = function (_a) {
       var desc = _a.desc,
+          pageKey = _a.pageKey,
           partkey = _a.partkey,
           business = _a.business,
           header = _a.header;
@@ -1396,7 +1440,7 @@ function (_super) {
       var params = _this.getParams({
         desc: desc,
         event: "CustomTrack",
-        itemKey: _this.getItemKey(partkey),
+        itemKey: _this.getItemKey(partkey, pageKey),
         privateParamMap: {
           business: business
         }
@@ -1410,17 +1454,23 @@ function (_super) {
 
 
     _this.listener = function () {
-      if (!!_this.initConfig.isTrackSinglePage) {
-        _this.rewriteHistory();
+      // 如果启用了全埋点，监听页面浏览事件
+      if (!!_this.initConfig.autoTrack) {
+        if (!!_this.initConfig.isTrackSinglePage) {
+          _this.rewriteHistory();
 
-        _this.addSinglePageEvent(_this.onPageViewCallback);
-      }
+          _this.addSinglePageEvent(_this.onPageViewCallback);
+        }
+
+        _this.each(["load", "beforeunload"], function (historyType) {
+          _this.addEventListener(window, historyType, _this.onPageViewCallback);
+        });
+      } // 如果启用了全埋点或启用了 data-part-key 点击追踪，监听点击事件
 
-      _this.each(["load", "beforeunload"], function (historyType) {
-        _this.addEventListener(window, historyType, _this.onPageViewCallback);
-      });
 
-      _this.addEventListener(window, "click", _this.onClickCallback);
+      if (!!_this.initConfig.autoTrack || !!_this.initConfig.trackPartKeyClick) {
+        _this.addEventListener(window, "click", _this.onClickCallback);
+      }
     };
     /**
      * @description 取消全埋点事件
@@ -1465,12 +1515,51 @@ function (_super) {
     _this.clearBatchQueue = function () {
       _this.batchQueue = [];
 
-      _this.setLocalStorage(_this.BATCH_QUEUE_STORAGE_KEY, '[]');
+      _this.setLocalStorage(_this.BATCH_QUEUE_STORAGE_KEY, "[]");
 
       if (_this.initConfig.showLog) {
-        _this.printLog('批量队列已清空');
+        _this.printLog("批量队列已清空");
+      }
+    };
+    /**
+     * @description 设置自定义页面唯一标识
+     * @param pageKey 页面唯一标识，如果传入 null 或空字符串，则恢复自动生成
+     * @param autoUpdate 路由变化时是否自动更新（默认：false，使用自定义值后不再自动更新）
+     */
+
+
+    _this.setPageKey = function (pageKey, autoUpdate) {
+      if (autoUpdate === void 0) {
+        autoUpdate = false;
+      }
+
+      if (pageKey === null || pageKey === '') {
+        // 恢复自动生成
+        _this.useCustomPageKey = false;
+        var pathname = window.location.pathname;
+        _this.pageKey = pathname.replace(/\//g, "_").substring(1);
+
+        if (_this.initConfig.showLog) {
+          _this.printLog("\u9875\u9762\u6807\u8BC6\u5DF2\u6062\u590D\u81EA\u52A8\u751F\u6210: " + _this.pageKey);
+        }
+      } else {
+        _this.pageKey = pageKey;
+        _this.useCustomPageKey = !autoUpdate;
+
+        if (_this.initConfig.showLog) {
+          _this.printLog("\u9875\u9762\u6807\u8BC6\u5DF2\u8BBE\u7F6E\u4E3A: " + pageKey + ", \u81EA\u52A8\u66F4\u65B0: " + autoUpdate);
+        }
       }
     };
+    /**
+     * @description 获取当前页面唯一标识
+     * @returns 当前页面唯一标识
+     */
+
+
+    _this.getPageKey = function () {
+      return _this.pageKey;
+    };
 
     _this.onClickCallback = function (e) {
       var _a;
@@ -1496,7 +1585,7 @@ function (_super) {
           targetEle: targetEle,
           pointerType: e.pointerType,
           currentUrl: _this.currentUrl,
-          elementSelector: _this.getDomSelector(target) || ''
+          elementSelector: _this.getDomSelector(target) || ""
         }
       });
 
@@ -1508,7 +1597,12 @@ function (_super) {
 
 
     _this.onPageViewCallback = function (e) {
-      var _a, _b;
+      var _a, _b; // 在路由变化前，先发送待发送的数据（避免被取消）
+
+
+      if (_this.pendingRequests.length > 0 || _this.initConfig.batchSend && _this.batchQueue.length > 0) {
+        _this.flushPendingData();
+      }
 
       var ORGIN = window.location.origin;
 
@@ -1521,8 +1615,11 @@ function (_super) {
         }
       });
 
-      _this.currentUrl = window.location.href;
-      _this.pageKey = window.location.pathname.replace(/\//g, "_").substring(1);
+      _this.currentUrl = window.location.href; // 如果使用自定义 pageKey，路由变化时不自动更新
+
+      if (!_this.useCustomPageKey) {
+        _this.pageKey = window.location.pathname.replace(/\//g, "_").substring(1);
+      }
 
       _this.sendRetained(e.type);
 
@@ -1753,9 +1850,121 @@ function (_super) {
         _this.printLog("\u6062\u590D\u6279\u91CF\u961F\u5217\u5931\u8D25: " + e); // 如果解析失败，清除损坏的数据
 
 
-        _this.setLocalStorage(_this.BATCH_QUEUE_STORAGE_KEY, '[]');
+        _this.setLocalStorage(_this.BATCH_QUEUE_STORAGE_KEY, "[]");
+      }
+    };
+    /**
+     * 添加到待发送请求队列
+     * @param params 数据参数
+     */
+
+
+    _this.addToPendingRequests = function (params) {
+      _this.pendingRequests.push(params); // 限制队列大小，防止内存溢出
+
+
+      var maxSize = _this.initConfig.pendingRequestsMaxSize || _this.DEFAULT_PENDING_REQUESTS_MAX_SIZE;
+
+      if (_this.pendingRequests.length > maxSize) {
+        _this.pendingRequests = _this.pendingRequests.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");
+        }
       }
     };
+    /**
+     * 从 LocalStorage 恢复待发送请求
+     */
+
+
+    _this.restorePendingRequestsFromStorage = function () {
+      try {
+        var storedRequests = _this.getLocalStorage(_this.PENDING_REQUESTS_STORAGE_KEY);
+
+        if (storedRequests) {
+          var parsedRequests = JSON.parse(storedRequests);
+
+          if (Array.isArray(parsedRequests) && parsedRequests.length > 0) {
+            _this.pendingRequests = parsedRequests;
+
+            if (_this.initConfig.showLog) {
+              _this.printLog("\u4ECE LocalStorage \u6062\u590D " + parsedRequests.length + " \u6761\u5F85\u53D1\u9001\u8BF7\u6C42");
+            } // 恢复后立即尝试发送
+
+
+            if (_this.pendingRequests.length > 0) {
+              _this.flushPendingRequests();
+            }
+          }
+        }
+      } catch (e) {
+        _this.printLog("\u6062\u590D\u5F85\u53D1\u9001\u8BF7\u6C42\u5931\u8D25: " + e); // 如果解析失败，清除损坏的数据
+
+
+        _this.setLocalStorage(_this.PENDING_REQUESTS_STORAGE_KEY, "[]");
+      }
+    };
+    /**
+     * 检查页面是否即将卸载
+     * @returns 如果页面即将卸载返回 true，否则返回 false
+     */
+
+
+    _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) {
+        if (_this.initConfig.showLog) {
+          _this.printLog("sendBeacon \u53D1\u9001\u5931\u8D25: " + e);
+        }
+
+        return false;
+      }
+    };
+    /**
+     * 刷新待发送的单个请求（正常情况下的发送）
+     * 注意：这个方法会直接发送，不会再次添加到 pendingRequests，避免循环
+     */
+
+
+    _this.flushPendingRequests = function () {
+      if (_this.pendingRequests.length === 0) {
+        return;
+      }
+
+      var requestsToSend = __spreadArray([], _this.pendingRequests);
+
+      _this.pendingRequests = []; // 清除 LocalStorage 中的待发送请求
+
+      _this.setLocalStorage(_this.PENDING_REQUESTS_STORAGE_KEY, "[]"); // 尝试发送每个请求（使用 sendData，但如果失败不再添加到 pendingRequests，避免循环）
+
+
+      requestsToSend.forEach(function (params) {
+        // 直接调用 sendData，但不处理失败情况（避免循环）
+        // 如果失败，数据会丢失，但这是可接受的，因为我们已经尝试过了
+        _this.sendData(params).catch(function (err) {
+          if (_this.initConfig.showLog) {
+            _this.printLog("\u5F85\u53D1\u9001\u8BF7\u6C42\u53D1\u9001\u5931\u8D25\uFF08\u4E0D\u518D\u91CD\u8BD5\uFF09: " + err);
+          }
+        });
+      });
+    };
     /**
      * 保存批量队列到 LocalStorage
      */
@@ -1766,13 +1975,12 @@ function (_super) {
         var queueString = JSON.stringify(_this.batchQueue); // 检查存储大小，避免超出 LocalStorage 限制（通常 5-10MB）
         // 如果队列过大，只保留最新的数据
 
-        if (queueString.length > 4 * 1024 * 1024) {
-          // 4MB 限制
+        if (queueString.length > _this.MAX_STORAGE_SIZE) {
           var maxItems = Math.floor(_this.batchQueue.length * 0.8); // 保留 80%
 
           _this.batchQueue = _this.batchQueue.slice(-maxItems);
 
-          _this.printLog("\u961F\u5217\u8FC7\u5927\uFF0C\u5DF2\u622A\u65AD\u4FDD\u7559\u6700\u65B0 " + maxItems + " \u6761\u6570\u636E");
+          _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(_this.batchQueue));
@@ -1782,44 +1990,126 @@ function (_super) {
       }
     };
     /**
-     * 设置页面卸载监听器，保存队列
+     * 设置页面卸载监听器，确保数据发送
      */
 
 
     _this.setupBeforeUnloadListener = function () {
-      // 使用 visibilitychange 事件（更可靠）
-      document.addEventListener('visibilitychange', function () {
-        if (document.visibilityState === 'hidden' && _this.batchQueue.length > 0) {
-          _this.saveBatchQueueToStorage();
+      // 避免重复设置监听器
+      if (_this.isUnloadListenerSetup) {
+        return;
+      }
+
+      _this.isUnloadListenerSetup = true; // 使用 visibilitychange 事件（更可靠，支持页面跳转、切换标签页等场景）
+
+      document.addEventListener("visibilitychange", function () {
+        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 成功，清除队列
+      window.addEventListener("beforeunload", function () {
+        _this.flushPendingData();
+      }); // 使用 pagehide 事件（更可靠，支持移动端）
 
-              _this.batchQueue = [];
+      window.addEventListener("pagehide", function () {
+        _this.flushPendingData();
+      });
+    };
+    /**
+     * 刷新待发送数据（在页面卸载/跳转时调用）
+     */
 
-              _this.setLocalStorage(_this.BATCH_QUEUE_STORAGE_KEY, '[]');
-            } catch (e) {
-              // sendBeacon 失败，保存到 LocalStorage
-              _this.saveBatchQueueToStorage();
+
+    _this.flushPendingData = function () {
+      // 收集所有待发送的数据
+      var allPendingData = []; // 如果有批量队列，添加到待发送列表
+
+      if (_this.batchQueue.length > 0) {
+        allPendingData.push.apply(allPendingData, _this.batchQueue);
+      } // 如果有待发送的单个请求，也添加到列表
+
+
+      if (_this.pendingRequests.length > 0) {
+        allPendingData.push.apply(allPendingData, _this.pendingRequests);
+      }
+
+      if (allPendingData.length === 0) {
+        return;
+      } // 使用 sendBeacon 发送数据（最可靠的方式）
+
+
+      if (navigator.sendBeacon && _this.initConfig.serverUrl) {
+        try {
+          // 如果只有一条数据，直接发送；否则批量发送
+          var dataToSend = allPendingData.length === 1 ? allPendingData[0] : {
+            events: allPendingData
+          };
+          var blob = new Blob([JSON.stringify(dataToSend)], {
+            type: _this.initConfig.contentType || "application/json"
+          });
+          var sent = navigator.sendBeacon(_this.initConfig.serverUrl, blob);
+
+          if (sent) {
+            // 发送成功，清除所有队列
+            _this.batchQueue = [];
+            _this.pendingRequests = [];
+
+            _this.setLocalStorage(_this.BATCH_QUEUE_STORAGE_KEY, "[]");
+
+            if (_this.initConfig.showLog) {
+              _this.printLog("\u9875\u9762\u5378\u8F7D\u65F6\u6210\u529F\u53D1\u9001 " + allPendingData.length + " \u6761\u6570\u636E");
             }
           } else {
-            // 不支持 sendBeacon，保存到 LocalStorage
+            // sendBeacon 返回 false，保存到 LocalStorage（批量模式）
+            if (_this.initConfig.batchSend && _this.batchQueue.length > 0) {
+              _this.saveBatchQueueToStorage();
+            } // 保存 pendingRequests 到 LocalStorage（如果支持）
+
+
+            if (_this.pendingRequests.length > 0) {
+              try {
+                _this.setLocalStorage(_this.PENDING_REQUESTS_STORAGE_KEY, JSON.stringify(_this.pendingRequests));
+              } catch (e) {
+                // LocalStorage 可能已满或不可用
+                if (_this.initConfig.showLog) {
+                  _this.printLog("\u4FDD\u5B58\u5F85\u53D1\u9001\u8BF7\u6C42\u5230 LocalStorage \u5931\u8D25: " + e);
+                }
+              }
+            }
+          }
+        } catch (e) {
+          // sendBeacon 失败，保存到 LocalStorage（批量模式）
+          if (_this.initConfig.batchSend && _this.batchQueue.length > 0) {
             _this.saveBatchQueueToStorage();
+          } // 保存 pendingRequests 到 LocalStorage（如果支持）
+
+
+          if (_this.pendingRequests.length > 0) {
+            try {
+              _this.setLocalStorage(_this.PENDING_REQUESTS_STORAGE_KEY, JSON.stringify(_this.pendingRequests));
+            } catch (e) {// LocalStorage 可能已满或不可用
+            }
+          }
+
+          if (_this.initConfig.showLog) {
+            _this.printLog("\u9875\u9762\u5378\u8F7D\u65F6\u53D1\u9001\u6570\u636E\u5931\u8D25: " + e);
           }
         }
-      });
+      } else {
+        // 不支持 sendBeacon，保存到 LocalStorage（批量模式）
+        if (_this.initConfig.batchSend && _this.batchQueue.length > 0) {
+          _this.saveBatchQueueToStorage();
+        } // 保存 pendingRequests 到 LocalStorage（如果支持）
+
+
+        if (_this.pendingRequests.length > 0) {
+          try {
+            _this.setLocalStorage(_this.PENDING_REQUESTS_STORAGE_KEY, JSON.stringify(_this.pendingRequests));
+          } catch (e) {// LocalStorage 可能已满或不可用
+          }
+        }
+      }
     };
     /**
      * 发送数据通用函数
@@ -1851,16 +2141,61 @@ function (_super) {
           success: true,
           message: "已添加到批量队列"
         });
-      }
+      } // 如果使用 sendBeacon 且没有自定义 header
+
 
       if (_this.isSupportBeaconSend() === true && !header && !initHeader) {
+        // 检查页面是否即将卸载，如果是，直接使用 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
+
+
         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) {
+          // 如果页面即将卸载，也尝试使用 sendBeacon 作为备用
+          if (_this.isPageUnloading() && _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,
@@ -1877,7 +2212,20 @@ function (_super) {
               });
             },
             error: function error(err, status) {
-              return reject({
+              // 如果请求失败且页面即将卸载，尝试使用 sendBeacon
+              if (_this.isPageUnloading() && _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
@@ -1922,9 +2270,9 @@ function (_super) {
      */
 
 
-    _this.getItemKey = function (partkey) {
+    _this.getItemKey = function (partkey, pageKey) {
       var appKey = _this.initConfig.appKey;
-      var keys = [appKey, _this.pageKey, partkey ? partkey.toString() : undefined].filter(function (key) {
+      var keys = [appKey, (pageKey || _this.pageKey).toString(), partkey ? partkey.toString() : undefined].filter(function (key) {
         return !!key;
       });
       return keys.reduce(function (str, key) {
@@ -1948,7 +2296,9 @@ function (_super) {
       sampleRate: 1,
       batchSend: false,
       batchInterval: 5000,
-      batchMaxSize: 10 // 批量发送最大数量
+      batchMaxSize: 10,
+      trackPartKeyClick: false,
+      pendingRequestsMaxSize: 50 // 待发送请求队列最大数量（防止内存溢出）
 
     }; // 系统信息