@skrillex1224/playwright-toolkit 2.1.46 → 2.1.47

package/dist/index.cjs

@@ -2308,8 +2308,11 @@ var Mutation = {
    * @param {Object} [options] - 配置选项
    * @param {number} [options.stableTime] - 无变化持续时间后 resolve (毫秒, 默认: 5000)
    * @param {number} [options.timeout] - 整体超时时间 (毫秒, 默认: 60000)
-   * @param {Function} [options.onMutation] - 变化时的回调钩子 (mutationCount: number) => void
-   * @returns {Promise<{ mutationCount: number, stableTime: number }>} - 返回变化次数和稳定时长
+   * @param {Function} [options.onMutation] - 变化时的回调钩子
+   *   签名: ({ mutationCount, innerHTML, innerText }) => any
+   *   返回 null/undefined: 正常重置稳定计时
+   *   返回其他值: 暂停稳定计时（timeout 仍然生效）
+   * @returns {Promise<{ mutationCount: number, stableTime: number, wasPaused: boolean }>}
    */
   async waitForStable(page, selectors, options = {}) {
     const selectorList = Array.isArray(selectors) ? selectors : [selectors];
@@ -2317,25 +2320,28 @@ var Mutation = {
     const timeout = options.timeout ?? 6e4;
     const onMutation = options.onMutation;
     logger9.start("waitForStable", `\u76D1\u63A7 ${selectorList.length} \u4E2A\u9009\u62E9\u5668, \u7A33\u5B9A\u65F6\u95F4=${stableTime}ms`);
-    const eventName = generateKey("pk_mut_evt");
     const callbackName = generateKey("pk_mut_cb");
     if (onMutation) {
       try {
-        await page.exposeFunction(callbackName, (count) => {
+        await page.exposeFunction(callbackName, async (context) => {
           try {
-            onMutation(count);
+            const result2 = await onMutation(context);
+            return result2 === null || result2 === void 0 ? "__CONTINUE__" : "__PAUSE__";
           } catch (e) {
+            return "__CONTINUE__";
           }
         });
       } catch (e) {
       }
     }
     const result = await page.evaluate(
-      async ({ selectorList: selectorList2, stableTime: stableTime2, timeout: timeout2, eventName: eventName2, callbackName: callbackName2, hasCallback }) => {
+      async ({ selectorList: selectorList2, stableTime: stableTime2, timeout: timeout2, callbackName: callbackName2, hasCallback }) => {
         return new Promise((resolve, reject) => {
           let mutationCount = 0;
           let stableTimer = null;
           let timeoutTimer = null;
+          let isPaused = false;
+          let wasPaused = false;
           const observers = [];
           const cleanup = () => {
             observers.forEach((obs) => obs.disconnect());
@@ -2344,24 +2350,53 @@ var Mutation = {
           };
           const resetStableTimer = () => {
             if (stableTimer) clearTimeout(stableTimer);
+            if (isPaused) return;
             stableTimer = setTimeout(() => {
               cleanup();
-              resolve({ mutationCount, stableTime: stableTime2 });
+              resolve({ mutationCount, stableTime: stableTime2, wasPaused });
             }, stableTime2);
           };
+          const pauseStableTimer = () => {
+            if (stableTimer) {
+              clearTimeout(stableTimer);
+              stableTimer = null;
+            }
+            isPaused = true;
+            wasPaused = true;
+          };
+          const resumeStableTimer = () => {
+            isPaused = false;
+            resetStableTimer();
+          };
           timeoutTimer = setTimeout(() => {
             cleanup();
-            reject(new Error(`waitForStable \u8D85\u65F6 (${timeout2}ms), \u5DF2\u68C0\u6D4B\u5230 ${mutationCount} \u6B21\u53D8\u5316`));
+            reject(new Error(`waitForStable \u8D85\u65F6 (${timeout2}ms), \u5DF2\u68C0\u6D4B\u5230 ${mutationCount} \u6B21\u53D8\u5316, isPaused=${isPaused}`));
           }, timeout2);
           selectorList2.forEach((selector) => {
             const elements = document.querySelectorAll(selector);
             elements.forEach((element) => {
-              const observer = new MutationObserver((mutations) => {
+              const observer = new MutationObserver(async (mutations) => {
                 mutationCount += mutations.length;
                 if (hasCallback && window[callbackName2]) {
-                  window[callbackName2](mutationCount);
+                  const innerHTML = element.innerHTML || "";
+                  const innerText = element.innerText || element.textContent || "";
+                  try {
+                    const signal = await window[callbackName2]({
+                      mutationCount,
+                      innerHTML,
+                      innerText
+                    });
+                    if (signal === "__PAUSE__") {
+                      pauseStableTimer();
+                    } else {
+                      resumeStableTimer();
+                    }
+                  } catch (e) {
+                    resumeStableTimer();
+                  }
+                } else {
+                  resetStableTimer();
                 }
-                resetStableTimer();
               });
               observer.observe(element, {
                 childList: true,
@@ -2374,15 +2409,38 @@ var Mutation = {
           });
           if (observers.length === 0) {
             cleanup();
-            resolve({ mutationCount: 0, stableTime: 0 });
+            resolve({ mutationCount: 0, stableTime: 0, wasPaused: false });
             return;
           }
-          resetStableTimer();
+          const runInitialCheck = async () => {
+            if (hasCallback && window[callbackName2]) {
+              const firstSelector = selectorList2[0];
+              const firstElement = document.querySelector(firstSelector);
+              if (firstElement) {
+                const innerHTML = firstElement.innerHTML || "";
+                const innerText = firstElement.innerText || firstElement.textContent || "";
+                try {
+                  const signal = await window[callbackName2]({
+                    mutationCount: 0,
+                    innerHTML,
+                    innerText
+                  });
+                  if (signal === "__PAUSE__") {
+                    pauseStableTimer();
+                    return;
+                  }
+                } catch (e) {
+                }
+              }
+            }
+            resetStableTimer();
+          };
+          runInitialCheck();
         });
       },
-      { selectorList, stableTime, timeout, eventName, callbackName, hasCallback: !!onMutation }
+      { selectorList, stableTime, timeout, callbackName, hasCallback: !!onMutation }
     );
-    logger9.success("waitForStable", `DOM \u7A33\u5B9A, \u603B\u5171 ${result.mutationCount} \u6B21\u53D8\u5316`);
+    logger9.success("waitForStable", `DOM \u7A33\u5B9A, \u603B\u5171 ${result.mutationCount} \u6B21\u53D8\u5316${result.wasPaused ? ", \u66FE\u6682\u505C\u8BA1\u65F6" : ""}`);
     return result;
   },
   /**