@skrillex1224/playwright-toolkit 2.1.18 → 2.1.20

package/dist/index.cjs

@@ -562,6 +562,173 @@ 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 cursor = $GetCursor(page);
+    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 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 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 scrollablesHandle = await element.evaluateHandle((el) => {
+      const scrollables2 = [];
+      let current = el.parentElement;
+      while (current) {
+        if (isScrollable(current)) scrollables2.push(current);
+        current = current.parentElement;
+      }
+      const scrollingElement = document.scrollingElement || document.documentElement;
+      if (scrollingElement) scrollables2.push(scrollingElement);
+      return scrollables2;
+    });
+    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) => {
+        const rect = el.getBoundingClientRect();
+        if (!rect || rect.width === 0 || rect.height === 0) {
+          return { inView: false, container: null, direction: 0 };
+        }
+        const scrollables2 = [];
+        let current = el.parentElement;
+        while (current) {
+          if (isScrollable(current)) scrollables2.push(current);
+          current = current.parentElement;
+        }
+        const scrollingElement = document.scrollingElement || document.documentElement;
+        if (scrollingElement) scrollables2.push(scrollingElement);
+        for (const container of scrollables2) {
+          const crect = container === scrollingElement ? { top: 0, bottom: window.innerHeight } : container.getBoundingClientRect();
+          if (rect.top < crect.top + 2) {
+            return { inView: false, container, direction: -1 };
+          }
+          if (rect.bottom > crect.bottom - 2) {
+            return { inView: false, container, direction: 1 };
+          }
+        }
+        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 (0, import_delay2.default)(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);
+        }
+      } finally {
+        await container.dispose();
+      }
+      await (0, import_delay2.default)(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 (0, import_delay2.default)(this.jitterMs(90, 0.4));
+          }
+        } catch (error) {
+          logger4.warn(`humanScroll: restore failed: ${error.message}`);
+        } finally {
+          await item.el.dispose();
+        }
+      }
+    };
+    return { element, didScroll: true, restore };
+  },
   /**
    * 人类化点击 - 使用 ghost-cursor 模拟人类鼠标移动轨迹并点击
    * 
@@ -577,6 +744,18 @@ 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 (0, import_delay2.default)(this.jitterMs(reactionDelay, 0.4));
@@ -597,49 +776,30 @@ var Humanize = {
       } else {
         element = target;
       }
+      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 (0, import_delay2.default)(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 (0, import_delay2.default)(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 (0, import_delay2.default)(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 (0, import_delay2.default)(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 (0, import_delay2.default)(this.jitterMs(reactionDelay, 0.4));
+      await cursor.actions.click();
+      await (0, import_delay2.default)(this.jitterMs(180, 0.4));
+      await restoreOnce();
       logger4.success("humanClick");
       return true;
     } catch (error) {
+      await restoreOnce();
       logger4.fail("humanClick", error);
       throw error;
     }
@@ -693,7 +853,7 @@ var Humanize = {
     } = options;
     try {
       const locator = page.locator(selector);
-      await locator.click();
+      await Humanize.humanClick(page, locator);
       await (0, import_delay2.default)(this.jitterMs(200, 0.4));
       for (let i = 0; i < text.length; i++) {
         const char = text[i];