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

package/lib/index.js

@@ -1252,7 +1252,19 @@
 
         _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; // 当前路由
 
@@ -1277,21 +1289,36 @@
           _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: 需要判断有哪些不能被预制的参数
@@ -1302,7 +1329,23 @@
 
         _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;
@@ -1314,10 +1357,10 @@
             _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 {
@@ -1346,7 +1389,7 @@
           } // 获取已存储的设备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;
@@ -1360,10 +1403,10 @@
           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;
@@ -1377,10 +1420,10 @@
 
         _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();
 
@@ -1395,6 +1438,7 @@
 
         _this.track = function (_a) {
           var desc = _a.desc,
+              pageKey = _a.pageKey,
               partkey = _a.partkey,
               business = _a.business,
               header = _a.header;
@@ -1402,7 +1446,7 @@
           var params = _this.getParams({
             desc: desc,
             event: "CustomTrack",
-            itemKey: _this.getItemKey(partkey),
+            itemKey: _this.getItemKey(partkey, pageKey),
             privateParamMap: {
               business: business
             }
@@ -1416,17 +1460,23 @@
 
 
         _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 取消全埋点事件
@@ -1471,12 +1521,51 @@
         _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;
@@ -1502,7 +1591,7 @@
               targetEle: targetEle,
               pointerType: e.pointerType,
               currentUrl: _this.currentUrl,
-              elementSelector: _this.getDomSelector(target) || ''
+              elementSelector: _this.getDomSelector(target) || ""
             }
           });
 
@@ -1514,7 +1603,12 @@
 
 
         _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;
 
@@ -1527,8 +1621,11 @@
             }
           });
 
-          _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);
 
@@ -1759,9 +1856,121 @@
             _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
          */
@@ -1772,13 +1981,12 @@
             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));
@@ -1788,44 +1996,126 @@
           }
         };
         /**
-         * 设置页面卸载监听器，保存队列
+         * 设置页面卸载监听器，确保数据发送
          */
 
 
         _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 可能已满或不可用
+              }
+            }
+          }
         };
         /**
          * 发送数据通用函数
@@ -1857,16 +2147,61 @@
               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,
@@ -1883,7 +2218,20 @@
                   });
                 },
                 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
@@ -1928,9 +2276,9 @@
          */
 
 
-        _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) {
@@ -1954,7 +2302,9 @@
           sampleRate: 1,
           batchSend: false,
           batchInterval: 5000,
-          batchMaxSize: 10 // 批量发送最大数量
+          batchMaxSize: 10,
+          trackPartKeyClick: false,
+          pendingRequestsMaxSize: 50 // 待发送请求队列最大数量（防止内存溢出）
 
         }; // 系统信息