@skrillex1224/playwright-toolkit 2.1.19 → 2.1.21

package/dist/index.js

@@ -533,6 +533,164 @@ var Humanize = {
       throw error;
     }
   },
+  /**
+   * 渐进式滚动到元素可见（仅处理 Y 轴滚动）
+   * 返回 restore 方法，用于将滚动容器恢复到原位置
+   * 
+   * @param {import('playwright').Page} page
+   * @param {string|import('playwright').ElementHandle} target - CSS 选择器或元素句柄
+   * @param {Object} [options]
+   * @param {number} [options.maxSteps=25] - 最大滚动步数
+   * @param {number} [options.minStep=80] - 单次滚动最小步长
+   * @param {number} [options.maxStep=220] - 单次滚动最大步长
+   */
+  async humanScroll(page, target, options = {}) {
+    const { maxSteps = 25, minStep = 80, maxStep = 220 } = options;
+    let element;
+    if (typeof target === "string") {
+      element = await page.$(target);
+      if (!element) {
+        return { element: null, didScroll: false, restore: async () => {
+        } };
+      }
+    } else {
+      element = target;
+    }
+    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;
+      if (!inViewport) return true;
+      let current = el.parentElement;
+      while (current) {
+        if (isScrollable(current)) {
+          const crect = current.getBoundingClientRect();
+          if (rect.top < crect.top || rect.bottom > crect.bottom) {
+            return true;
+          }
+        }
+        current = current.parentElement;
+      }
+      return false;
+    });
+    if (!needsScroll) {
+      return { element, didScroll: false, restore: async () => {
+      } };
+    }
+    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)) addNode(current);
+        current = current.parentElement;
+      }
+      const scrollingElement = document.scrollingElement || document.documentElement;
+      if (scrollingElement) addNode(scrollingElement);
+      return scrollables;
+    });
+    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 { moved: false, inView: false };
+        }
+        const scrollables = [];
+        let current = el.parentElement;
+        while (current) {
+          if (isScrollable(current)) scrollables.push(current);
+          current = current.parentElement;
+        }
+        const scrollingElement = document.scrollingElement || document.documentElement;
+        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) {
+            target2 = { container, direction: -1 };
+            break;
+          }
+          if (rect.bottom > crect.bottom - 2) {
+            target2 = { container, direction: 1 };
+            break;
+          }
+        }
+        if (!target2) {
+          return { moved: false, inView: true };
+        }
+        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 () => {
+      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;
+            }
+          }
+          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 };
+  },
   /**
    * 人类化点击 - 使用 ghost-cursor 模拟人类鼠标移动轨迹并点击
    * 
@@ -568,49 +726,42 @@ 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;
+      }
       const box = await element.boundingBox();
       if (!box) {
+        await restoreOnce();
         if (throwOnMissing) {
           throw new Error("\u65E0\u6CD5\u83B7\u53D6\u5143\u7D20\u4F4D\u7F6E");
         }
         logger4.warn("humanClick: \u65E0\u6CD5\u83B7\u53D6\u4F4D\u7F6E\uFF0C\u8DF3\u8FC7\u70B9\u51FB");
         return false;
       }
-      const viewport = page.viewportSize() || { width: 1920, height: 1080 };
-      const isInViewport = box.x >= 0 && box.y >= 0 && box.x + box.width <= viewport.width && box.y + box.height <= viewport.height;
-      let originalScrollY = null;
-      if (!isInViewport && scrollIfNeeded) {
-        logger4.debug(`\u5143\u7D20\u4E0D\u5728\u89C6\u53E3\u5185\uFF0C\u6EDA\u52A8\u5230\u89C6\u53E3...`);
-        originalScrollY = await page.evaluate(() => window.scrollY);
-        await element.scrollIntoViewIfNeeded();
-        await delay2(this.jitterMs(300, 0.3));
-        const newBox = await element.boundingBox();
-        if (newBox) {
-          const x = newBox.x + newBox.width / 2 + (Math.random() - 0.5) * newBox.width * 0.3;
-          const y = newBox.y + newBox.height / 2 + (Math.random() - 0.5) * newBox.height * 0.3;
-          await cursor.actions.move({ x, y });
-          await delay2(this.jitterMs(reactionDelay, 0.4));
-          await cursor.actions.click();
-        } else {
-          throw new Error("\u6EDA\u52A8\u540E\u4ECD\u65E0\u6CD5\u83B7\u53D6\u5143\u7D20\u4F4D\u7F6E");
-        }
-        if (originalScrollY !== null) {
-          await delay2(this.jitterMs(200, 0.3));
-          await page.evaluate((scrollY) => {
-            window.scrollTo({ top: scrollY, behavior: "smooth" });
-          }, originalScrollY);
-          logger4.debug(`\u5DF2\u6EDA\u52A8\u56DE\u539F\u4F4D\u7F6E: ${originalScrollY}`);
-        }
-      } else {
-        const x = box.x + box.width / 2 + (Math.random() - 0.5) * box.width * 0.3;
-        const y = box.y + box.height / 2 + (Math.random() - 0.5) * box.height * 0.3;
-        await cursor.actions.move({ x, y });
-        await delay2(this.jitterMs(reactionDelay, 0.4));
-        await cursor.actions.click();
-      }
+      const x = box.x + box.width / 2 + (Math.random() - 0.5) * box.width * 0.3;
+      const y = box.y + box.height / 2 + (Math.random() - 0.5) * box.height * 0.3;
+      await cursor.actions.move({ x, y });
+      await delay2(this.jitterMs(reactionDelay, 0.4));
+      await cursor.actions.click();
+      await delay2(this.jitterMs(180, 0.4));
+      await restoreOnce();
       logger4.success("humanClick");
       return true;
     } catch (error) {
+      logger4.fail("humanClick", error);
       logger4.fail("humanClick", error);
       throw error;
     }