@skrillex1224/playwright-toolkit 2.1.20 → 2.1.21

package/dist/index.js

@@ -535,7 +535,7 @@ var Humanize = {
   },
   /**
    * 渐进式滚动到元素可见（仅处理 Y 轴滚动）
-   * 使用鼠标滚轮模拟人类滚动，并返回 restore 用于回滚
+   * 返回 restore 方法，用于将滚动容器恢复到原位置
    * 
    * @param {import('playwright').Page} page
    * @param {string|import('playwright').ElementHandle} target - CSS 选择器或元素句柄
@@ -545,7 +545,6 @@ var Humanize = {
    * @param {number} [options.maxStep=220] - 单次滚动最大步长
    */
   async humanScroll(page, target, options = {}) {
-    const cursor = $GetCursor(page);
     const { maxSteps = 25, minStep = 80, maxStep = 220 } = options;
     let element;
     if (typeof target === "string") {
@@ -557,13 +556,13 @@ var Humanize = {
     } else {
       element = target;
     }
-    const isScrollable = (node) => {
-      if (!node || node === document.body) return false;
-      const style = window.getComputedStyle(node);
-      const overflowY = style.overflowY || style.overflow;
-      return (overflowY === "auto" || overflowY === "scroll" || overflowY === "overlay") && node.scrollHeight > node.clientHeight + 1;
-    };
     const needsScroll = await element.evaluate((el) => {
+      const isScrollable = (node) => {
+        if (!node || node === document.body) return false;
+        const style = window.getComputedStyle(node);
+        const overflowY = style.overflowY || style.overflow;
+        return (overflowY === "auto" || overflowY === "scroll" || overflowY === "overlay") && node.scrollHeight > node.clientHeight + 1;
+      };
       const rect = el.getBoundingClientRect();
       if (!rect || rect.width === 0 || rect.height === 0) return true;
       const inViewport = rect.top >= 0 && rect.bottom <= window.innerHeight;
@@ -584,118 +583,110 @@ var Humanize = {
       return { element, didScroll: false, restore: async () => {
       } };
     }
-    const scrollablesHandle = await element.evaluateHandle((el) => {
-      const scrollables2 = [];
+    const scrollStateHandle = await element.evaluateHandle((el) => {
+      const isScrollable = (node) => {
+        if (!node || node === document.body) return false;
+        const style = window.getComputedStyle(node);
+        const overflowY = style.overflowY || style.overflow;
+        return (overflowY === "auto" || overflowY === "scroll" || overflowY === "overlay") && node.scrollHeight > node.clientHeight + 1;
+      };
+      const scrollables = [];
+      const addNode = (node) => {
+        if (!node || scrollables.some((item) => item.el === node)) return;
+        scrollables.push({
+          el: node,
+          top: node.scrollTop
+        });
+      };
       let current = el.parentElement;
       while (current) {
-        if (isScrollable(current)) scrollables2.push(current);
+        if (isScrollable(current)) addNode(current);
         current = current.parentElement;
       }
       const scrollingElement = document.scrollingElement || document.documentElement;
-      if (scrollingElement) scrollables2.push(scrollingElement);
-      return scrollables2;
+      if (scrollingElement) addNode(scrollingElement);
+      return scrollables;
     });
-    const scrollables = [];
-    try {
-      const lengthHandle = await scrollablesHandle.getProperty("length");
-      const length = await lengthHandle.jsonValue();
-      await lengthHandle.dispose();
-      for (let i = 0; i < length; i++) {
-        const itemHandle = await scrollablesHandle.getProperty(String(i));
-        const itemEl = itemHandle.asElement();
-        if (itemEl) {
-          const top = await itemEl.evaluate((el) => el.scrollTop);
-          scrollables.push({ el: itemEl, top });
-        } else {
-          await itemHandle.dispose();
-        }
-      }
-    } finally {
-      await scrollablesHandle.dispose();
-    }
-    const pickTarget = async () => {
-      const handle = await element.evaluateHandle((el) => {
+    for (let i = 0; i < maxSteps; i++) {
+      const step = minStep + Math.floor(Math.random() * (maxStep - minStep));
+      const result = await element.evaluate((el, stepPx) => {
+        const isScrollable = (node) => {
+          if (!node || node === document.body) return false;
+          const style = window.getComputedStyle(node);
+          const overflowY = style.overflowY || style.overflow;
+          return (overflowY === "auto" || overflowY === "scroll" || overflowY === "overlay") && node.scrollHeight > node.clientHeight + 1;
+        };
         const rect = el.getBoundingClientRect();
         if (!rect || rect.width === 0 || rect.height === 0) {
-          return { inView: false, container: null, direction: 0 };
+          return { moved: false, inView: false };
         }
-        const scrollables2 = [];
+        const scrollables = [];
         let current = el.parentElement;
         while (current) {
-          if (isScrollable(current)) scrollables2.push(current);
+          if (isScrollable(current)) scrollables.push(current);
           current = current.parentElement;
         }
         const scrollingElement = document.scrollingElement || document.documentElement;
-        if (scrollingElement) scrollables2.push(scrollingElement);
-        for (const container of scrollables2) {
+        if (scrollingElement) scrollables.push(scrollingElement);
+        let target2 = null;
+        for (const container of scrollables) {
           const crect = container === scrollingElement ? { top: 0, bottom: window.innerHeight } : container.getBoundingClientRect();
           if (rect.top < crect.top + 2) {
-            return { inView: false, container, direction: -1 };
+            target2 = { container, direction: -1 };
+            break;
           }
           if (rect.bottom > crect.bottom - 2) {
-            return { inView: false, container, direction: 1 };
+            target2 = { container, direction: 1 };
+            break;
           }
         }
-        return { inView: true, container: null, direction: 0 };
-      });
-      const inViewHandle = await handle.getProperty("inView");
-      const inView = await inViewHandle.jsonValue();
-      await inViewHandle.dispose();
-      if (inView) {
-        await handle.dispose();
-        return { inView: true };
-      }
-      const directionHandle = await handle.getProperty("direction");
-      const direction = await directionHandle.jsonValue();
-      await directionHandle.dispose();
-      const containerHandle = (await handle.getProperty("container")).asElement();
-      await handle.dispose();
-      return { inView: false, direction, container: containerHandle };
-    };
-    for (let i = 0; i < maxSteps; i++) {
-      const { inView, direction, container } = await pickTarget();
-      if (inView) break;
-      if (!container || !direction) break;
-      try {
-        const box = await container.boundingBox();
-        if (!box) break;
-        const x = box.x + box.width / 2 + (Math.random() - 0.5) * box.width * 0.2;
-        const y = box.y + box.height / 2 + (Math.random() - 0.5) * box.height * 0.2;
-        await cursor.actions.move({ x, y });
-        const step = minStep + Math.floor(Math.random() * (maxStep - minStep));
-        await page.mouse.wheel(0, direction * step);
-        if (Math.random() < 0.12) {
-          await delay2(this.jitterMs(60, 0.5));
-          const backStep = Math.max(20, Math.floor(step * (0.15 + Math.random() * 0.2)));
-          await page.mouse.wheel(0, -direction * backStep);
+        if (!target2) {
+          return { moved: false, inView: true };
         }
-      } finally {
-        await container.dispose();
-      }
+        const maxScroll = target2.container.scrollHeight - target2.container.clientHeight;
+        if (maxScroll <= 0) {
+          return { moved: false, inView: false };
+        }
+        const before = target2.container.scrollTop;
+        let next = before + target2.direction * stepPx;
+        if (next < 0) next = 0;
+        if (next > maxScroll) next = maxScroll;
+        if (next === before) {
+          return { moved: false, inView: false };
+        }
+        target2.container.scrollTop = next;
+        return { moved: true, inView: false };
+      }, step);
+      if (result.inView) break;
+      if (!result.moved) break;
       await delay2(this.jitterMs(120, 0.4));
     }
     const restore = async () => {
-      for (const item of scrollables) {
-        try {
-          const box = await item.el.boundingBox();
-          if (!box) continue;
-          for (let i = 0; i < 12; i++) {
-            const current = await item.el.evaluate((el) => el.scrollTop);
-            const delta = item.top - current;
-            if (Math.abs(delta) <= 1) break;
-            const x = box.x + box.width / 2 + (Math.random() - 0.5) * box.width * 0.2;
-            const y = box.y + box.height / 2 + (Math.random() - 0.5) * box.height * 0.2;
-            await cursor.actions.move({ x, y });
-            const step = minStep + Math.floor(Math.random() * (maxStep - minStep));
-            const move = Math.sign(delta) * Math.min(Math.abs(delta), step);
-            await page.mouse.wheel(0, move);
-            await delay2(this.jitterMs(90, 0.4));
+      if (!scrollStateHandle) return;
+      try {
+        const restoreOnce = async () => page.evaluate((state) => {
+          if (!Array.isArray(state) || state.length === 0) return true;
+          let done = true;
+          for (const item of state) {
+            if (!item || !item.el) continue;
+            const current = item.el.scrollTop;
+            const target2 = item.top;
+            if (Math.abs(current - target2) > 1) {
+              done = false;
+              const delta = target2 - current;
+              const step = Math.sign(delta) * Math.max(20, Math.min(120, Math.abs(delta) * 0.3));
+              item.el.scrollTop = current + step;
+            }
           }
-        } catch (error) {
-          logger4.warn(`humanScroll: restore failed: ${error.message}`);
-        } finally {
-          await item.el.dispose();
+          return done;
+        }, scrollStateHandle);
+        for (let i = 0; i < 10; i++) {
+          const done = await restoreOnce();
+          if (done) break;
+          await delay2(this.jitterMs(80, 0.4));
         }
+      } finally {
+        await scrollStateHandle.dispose();
       }
     };
     return { element, didScroll: true, restore };
@@ -715,18 +706,6 @@ var Humanize = {
     const { reactionDelay = 250, throwOnMissing = true, scrollIfNeeded = true } = options;
     const targetDesc = target == null ? "Current Position" : typeof target === "string" ? target : "ElementHandle";
     logger4.start("humanClick", `target=${targetDesc}`);
-    let restoreScroll = async () => {
-    };
-    let restored = false;
-    const restoreOnce = async () => {
-      if (restored) return;
-      restored = true;
-      try {
-        await restoreScroll();
-      } catch (restoreError) {
-        logger4.warn(`humanClick: \u6062\u590D\u6EDA\u52A8\u4F4D\u7F6E\u5931\u8D25: ${restoreError.message}`);
-      }
-    };
     try {
       if (target == null) {
         await delay2(this.jitterMs(reactionDelay, 0.4));
@@ -747,6 +726,18 @@ var Humanize = {
       } else {
         element = target;
       }
+      let restoreScroll = async () => {
+      };
+      let restored = false;
+      const restoreOnce = async () => {
+        if (restored) return;
+        restored = true;
+        try {
+          await restoreScroll();
+        } catch (restoreError) {
+          logger4.warn(`humanClick: \u6062\u590D\u6EDA\u52A8\u4F4D\u7F6E\u5931\u8D25: ${restoreError.message}`);
+        }
+      };
       if (scrollIfNeeded) {
         const scrollResult = await this.humanScroll(page, element);
         restoreScroll = scrollResult.restore || restoreScroll;
@@ -770,7 +761,7 @@ var Humanize = {
       logger4.success("humanClick");
       return true;
     } catch (error) {
-      await restoreOnce();
+      logger4.fail("humanClick", error);
       logger4.fail("humanClick", error);
       throw error;
     }