@skrillex1224/playwright-toolkit 2.1.30 → 2.1.31

package/dist/index.js

@@ -655,155 +655,91 @@ var Humanize = {
    * @param {number} [options.maxStep=220] - 单次滚动最大步长
    */
   async humanScroll(page, target, options = {}) {
-    const { maxSteps = 25, minStep = 80, maxStep = 220 } = options;
+    const { maxSteps = 30, minStep = 80, maxStep = 250 } = options;
     const targetDesc = typeof target === "string" ? target : "ElementHandle";
-    logger4.debug(`humanScroll| target=${targetDesc}`);
+    logger4.debug(`humanScroll | \u76EE\u6807=${targetDesc}`);
     let element;
     if (typeof target === "string") {
       element = await page.$(target);
       if (!element) {
-        logger4.warn(`humanScroll| Element not found: ${target}`);
-        return { element: null, didScroll: false, restore: async () => {
-        } };
+        logger4.warn(`humanScroll | \u5143\u7D20\u672A\u627E\u5230: ${target}`);
+        return { element: null, didScroll: false };
       }
     } else {
       element = target;
     }
+    const cursor = $GetCursor(page);
     let didScroll = false;
-    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 checkVisibility = async () => {
+      return await element.evaluate((el) => {
         const rect = el.getBoundingClientRect();
         if (!rect || rect.width === 0 || rect.height === 0) {
-          return { moved: false, inView: false };
+          return { code: "ZERO_DIMENSIONS", reason: "\u5C3A\u5BF8\u4E3A\u96F6" };
         }
-        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);
         const cx = rect.left + rect.width / 2;
         const cy = rect.top + rect.height / 2;
         const viewH = window.innerHeight;
-        let isObstructed = false;
-        if (cy < 0 || cy > viewH) {
-          isObstructed = true;
-        } else {
-          const pointElement = document.elementFromPoint(cx, cy);
-          if (pointElement && !el.contains(pointElement) && !pointElement.contains(el)) {
-            isObstructed = true;
-          }
+        const viewW = window.innerWidth;
+        if (cy < 0 || cy > viewH || cx < 0 || cx > viewW) {
+          const direction = cy < 0 ? "up" : cy > viewH ? "down" : "unknown";
+          return { code: "OUT_OF_VIEWPORT", reason: "\u4E0D\u5728\u89C6\u53E3\u5185", direction, cy, viewH };
         }
-        let target2 = null;
-        for (const container of scrollables) {
-          const crect = container === scrollingElement ? { top: 0, bottom: viewH } : 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 (isObstructed) {
-            const containerCenter = (crect.top + crect.bottom) / 2;
-            const elementCenter = (rect.top + rect.bottom) / 2;
-            const forceDirection = elementCenter > containerCenter ? 1 : -1;
-            const canScroll = forceDirection === 1 ? container.scrollTop < container.scrollHeight - container.clientHeight : container.scrollTop > 0;
-            if (canScroll) {
-              target2 = { container, direction: forceDirection };
-              break;
+        const pointElement = document.elementFromPoint(cx, cy);
+        if (pointElement && !el.contains(pointElement) && !pointElement.contains(el)) {
+          return {
+            code: "OBSTRUCTED",
+            reason: "\u88AB\u906E\u6321",
+            obstruction: {
+              tag: pointElement.tagName,
+              id: pointElement.id,
+              className: pointElement.className
             }
-          }
+          };
         }
-        if (!target2) {
-          return { moved: false, inView: !isObstructed };
+        return { code: "VISIBLE" };
+      });
+    };
+    try {
+      for (let i = 0; i < maxSteps; i++) {
+        const status = await checkVisibility();
+        if (status.code === "VISIBLE") {
+          logger4.debug("humanScroll | \u5143\u7D20\u53EF\u89C1\u4E14\u65E0\u906E\u6321");
+          return { element, didScroll };
         }
-        const maxScroll = target2.container.scrollHeight - target2.container.clientHeight;
-        if (maxScroll <= 0) {
-          return { moved: false, inView: !isObstructed };
+        logger4.debug(`humanScroll | \u6B65\u9AA4 ${i + 1}/${maxSteps}: ${status.reason} ${status.direction ? `(${status.direction})` : ""}`);
+        if (status.code === "OBSTRUCTED" && status.obstruction) {
+          logger4.debug(`humanScroll | \u88AB\u4EE5\u4E0B\u5143\u7D20\u906E\u6321 <${status.obstruction.tag} id="${status.obstruction.id}">`);
         }
-        const before = target2.container.scrollTop;
-        let next = before + target2.direction * stepPx;
-        if (next < 0) next = 0;
-        if (next > maxScroll) next = maxScroll;
-        if (Math.abs(next - before) < 1) {
-          return { moved: false, inView: !isObstructed };
+        let deltaY = 0;
+        if (status.code === "OUT_OF_VIEWPORT") {
+          if (status.direction === "down") {
+            deltaY = minStep + Math.random() * (maxStep - minStep);
+          } else if (status.direction === "up") {
+            deltaY = -(minStep + Math.random() * (maxStep - minStep));
+          } else {
+            deltaY = 100;
+          }
+        } else if (status.code === "OBSTRUCTED") {
+          deltaY = (Math.random() > 0.5 ? 1 : -1) * (minStep + Math.random() * 50);
         }
-        target2.container.scrollTop = next;
-        return { moved: true, inView: false };
-      }, step);
-      if (result.moved) didScroll = true;
-      if (result.inView) break;
-      if (!result.moved && !result.inView) {
-        logger4.warn("humanScroll| Stuck: cannot scroll further but element still obstructed/hidden");
-        break;
-      }
-      await delay2(this.jitterMs(120, 0.4));
-    }
-    const restore = async () => {
-      if (!scrollStateHandle) return;
-      try {
-        const restoreOnce2 = 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;
-            }
+        if (i === 0 || Math.random() < 0.2) {
+          const viewSize = page.viewportSize();
+          if (viewSize) {
+            const safeX = viewSize.width * 0.5 + (Math.random() - 0.5) * 100;
+            const safeY = viewSize.height * 0.5 + (Math.random() - 0.5) * 100;
+            await cursor.actions.move({ x: safeX, y: safeY });
           }
-          return done;
-        }, scrollStateHandle);
-        for (let i = 0; i < 10; i++) {
-          const done = await restoreOnce2();
-          if (done) break;
-          await delay2(this.jitterMs(80, 0.4));
         }
-      } finally {
-        await scrollStateHandle.dispose();
+        await page.mouse.wheel(0, deltaY);
+        didScroll = true;
+        await delay2(this.jitterMs(150 + Math.random() * 200, 0.2));
       }
-    };
-    logger4.success("humanScroll", "Scroll completed");
-    return { element, didScroll, restore };
+      logger4.warn(`humanScroll | \u5728 ${maxSteps} \u6B65\u540E\u65E0\u6CD5\u786E\u4FDD\u53EF\u89C1\u6027`);
+      return { element, didScroll };
+    } catch (error) {
+      logger4.fail("humanScroll", error);
+      throw error;
+    }
   },
   /**
    * 人类化点击 - 使用 ghost-cursor 模拟人类鼠标移动轨迹并点击