@skrillex1224/playwright-toolkit 2.1.246 → 2.1.248

package/dist/index.cjs

@@ -3460,23 +3460,6 @@ var initializedPages = /* @__PURE__ */ new WeakSet();
 var DEFAULT_TAP_TIMEOUT_MS = 2500;
 var DEFAULT_MOUSE_TAP_FALLBACK_TIMEOUT_MS = 1200;
 var DEFAULT_ACTIVATE_FALLBACK_TIMEOUT_MS = 900;
-var INTERACTIVE_SELECTOR = [
-  "button",
-  '[role="button"]',
-  "a[href]",
-  "label",
-  "input",
-  "textarea",
-  "select",
-  "summary",
-  '[contenteditable="true"]',
-  '[tabindex]:not([tabindex="-1"])'
-].join(",");
-var EDITABLE_SELECTOR = [
-  "input",
-  "textarea",
-  '[contenteditable="true"]'
-].join(",");
 var clamp = (value, min, max) => Math.min(max, Math.max(min, value));
 var resolveViewport = (page) => page?.viewportSize?.() || { width: 390, height: 844 };
 var describeTarget = (target) => {
@@ -3516,7 +3499,7 @@ var withTimeout = async (operation, timeoutMs, label) => {
   }
 };
 var checkElementVisibility = async (element) => {
-  return element.evaluate((el, interactiveSelector) => {
+  return element.evaluate((el) => {
     const targetStyle = window.getComputedStyle(el);
     if (!targetStyle || targetStyle.display === "none" || targetStyle.visibility === "hidden" || targetStyle.visibility === "collapse") {
       return { code: "NOT_INTERACTABLE", reason: "\u5143\u7D20\u4E0D\u53EF\u89C1", direction: "down" };
@@ -3578,16 +3561,30 @@ var checkElementVisibility = async (element) => {
         positioning
       };
     }
-    const targetInteractive = typeof el.closest === "function" ? el.closest(interactiveSelector) : null;
-    const sameInteractiveTarget = (pointElement) => {
+    const isRootNode = (node) => !node || node === document || node === document.body || node === document.documentElement;
+    const commonAncestor = (a, b) => {
+      for (let current = a; current && !isRootNode(current); current = current.parentElement) {
+        if (current.contains(b)) return current;
+      }
+      return null;
+    };
+    const sameTapTarget = (pointElement) => {
       if (!pointElement) return false;
       if (pointElement === el || el.contains(pointElement) || pointElement.contains(el)) {
         return true;
       }
-      if (!targetInteractive || typeof pointElement.closest !== "function") {
+      const common = commonAncestor(el, pointElement);
+      if (!common) return false;
+      const commonRect = common.getBoundingClientRect?.();
+      if (!commonRect || commonRect.width <= 0 || commonRect.height <= 0) return false;
+      const commonArea = commonRect.width * commonRect.height;
+      const targetArea = Math.max(1, rect.width * rect.height);
+      const maxSharedRegionArea = Math.max(targetArea * 12, 4096);
+      if (commonArea > maxSharedRegionArea) return false;
+      if (commonRect.width > Math.max(rect.width * 8, 120) || commonRect.height > Math.max(rect.height * 8, 120)) {
         return false;
       }
-      return pointElement.closest(interactiveSelector) === targetInteractive;
+      return common.contains(el) && common.contains(pointElement);
     };
     const describeElement = (node) => {
       if (!node) return null;
@@ -3616,7 +3613,7 @@ var checkElementVisibility = async (element) => {
     let obstruction = null;
     for (const point of samplePoints) {
       const pointElement = document.elementFromPoint(point.x, point.y);
-      if (sameInteractiveTarget(pointElement)) {
+      if (sameTapTarget(pointElement)) {
         return { code: "VISIBLE", isFixed, positioning };
       }
       obstruction = obstruction || describeElement(pointElement);
@@ -3634,10 +3631,10 @@ var checkElementVisibility = async (element) => {
       };
     }
     return { code: "VISIBLE", isFixed, positioning };
-  }, INTERACTIVE_SELECTOR);
+  });
 };
 var resolveSafeTapPoint = async (element) => {
-  return element.evaluate((el, interactiveSelector) => {
+  return element.evaluate((el) => {
     const rect = el.getBoundingClientRect();
     if (!rect || rect.width <= 0 || rect.height <= 0) {
       return null;
@@ -3674,16 +3671,30 @@ var resolveSafeTapPoint = async (element) => {
     if (visibleWidth <= 1 || visibleHeight <= 1) {
       return null;
     }
-    const targetInteractive = typeof el.closest === "function" ? el.closest(interactiveSelector) : null;
-    const sameInteractiveTarget = (pointElement) => {
+    const isRootNode = (node) => !node || node === document || node === document.body || node === document.documentElement;
+    const commonAncestor = (a, b) => {
+      for (let current = a; current && !isRootNode(current); current = current.parentElement) {
+        if (current.contains(b)) return current;
+      }
+      return null;
+    };
+    const sameTapTarget = (pointElement) => {
       if (!pointElement) return false;
       if (pointElement === el || el.contains(pointElement) || pointElement.contains(el)) {
         return true;
       }
-      if (!targetInteractive || typeof pointElement.closest !== "function") {
+      const common = commonAncestor(el, pointElement);
+      if (!common) return false;
+      const commonRect = common.getBoundingClientRect?.();
+      if (!commonRect || commonRect.width <= 0 || commonRect.height <= 0) return false;
+      const commonArea = commonRect.width * commonRect.height;
+      const targetArea = Math.max(1, rect.width * rect.height);
+      const maxSharedRegionArea = Math.max(targetArea * 12, 4096);
+      if (commonArea > maxSharedRegionArea) return false;
+      if (commonRect.width > Math.max(rect.width * 8, 120) || commonRect.height > Math.max(rect.height * 8, 120)) {
         return false;
       }
-      return pointElement.closest(interactiveSelector) === targetInteractive;
+      return common.contains(el) && common.contains(pointElement);
     };
     const cx = visibleLeft + visibleWidth / 2;
     const cy = visibleTop + visibleHeight / 2;
@@ -3702,7 +3713,7 @@ var resolveSafeTapPoint = async (element) => {
     ];
     const safePoints = points.filter((point) => {
       const pointElement = document.elementFromPoint(point.x, point.y);
-      return sameInteractiveTarget(pointElement);
+      return sameTapTarget(pointElement);
     });
     const candidates = safePoints.length ? safePoints : points;
     const chosen = candidates[Math.floor(Math.random() * candidates.length)];
@@ -3711,46 +3722,57 @@ var resolveSafeTapPoint = async (element) => {
       x: chosen.x,
       y: chosen.y
     };
-  }, INTERACTIVE_SELECTOR);
+  });
 };
 var activateElementFallback = async (element, point = null, options = {}) => {
-  return element.evaluate((el, { innerPoint, innerOptions, interactiveSelector, editableSelector }) => {
-    const pointElement = innerPoint ? document.elementFromPoint(innerPoint.x, innerPoint.y) : null;
-    const nearestInteractive = (node) => {
-      if (!node || typeof node.closest !== "function") return null;
-      return node.closest(interactiveSelector);
+  return element.evaluate((el, { innerOptions }) => {
+    const isEditable = (node) => {
+      if (!node || node.nodeType !== Node.ELEMENT_NODE) return false;
+      if (node.isContentEditable) return true;
+      if (node instanceof HTMLTextAreaElement) return !node.disabled && !node.readOnly;
+      if (node instanceof HTMLInputElement) {
+        return !node.disabled && !node.readOnly && typeof node.select === "function";
+      }
+      return false;
+    };
+    const findEditable = (node) => {
+      for (let current = node; current && current !== document.body; current = current.parentElement) {
+        if (isEditable(current)) return current;
+      }
+      return null;
     };
-    const targetInteractive = nearestInteractive(el);
-    const pointInteractive = nearestInteractive(pointElement);
-    let target = null;
-    if (pointInteractive && (pointInteractive === targetInteractive || pointInteractive === el || pointInteractive.contains(el) || el.contains(pointInteractive))) {
-      target = pointInteractive;
-    }
-    target = target || targetInteractive || el;
-    const editable = typeof target.closest === "function" ? target.closest(editableSelector) : null;
+    const editable = findEditable(el);
     if (editable && typeof editable.focus === "function") {
       editable.focus({ preventScroll: true });
       if (innerOptions.editableOnly) {
         return { activated: true, method: "focus", tag: editable.tagName || "" };
       }
     }
-    if (typeof target.focus === "function") {
-      target.focus({ preventScroll: true });
+    if (innerOptions.editableOnly) {
+      return { activated: false, method: "none", tag: el?.tagName || "" };
     }
-    if (!innerOptions.editableOnly && typeof target.click === "function") {
-      target.click();
-      return { activated: true, method: "dom-click", tag: target.tagName || "" };
+    if (typeof el.focus === "function") {
+      el.focus({ preventScroll: true });
+    }
+    if (typeof el.click === "function") {
+      el.click();
+      return { activated: true, method: "dom-click", tag: el.tagName || "" };
+    }
+    if (typeof el.dispatchEvent === "function") {
+      el.dispatchEvent(new MouseEvent("click", {
+        bubbles: true,
+        cancelable: true,
+        view: window
+      }));
+      return { activated: true, method: "dispatch-click", tag: el.tagName || "" };
     }
     return {
       activated: Boolean(editable),
       method: editable ? "focus" : "none",
-      tag: target?.tagName || ""
+      tag: el?.tagName || ""
     };
   }, {
-    innerPoint: point,
-    innerOptions: options || {},
-    interactiveSelector: INTERACTIVE_SELECTOR,
-    editableSelector: EDITABLE_SELECTOR
+    innerOptions: options || {}
   });
 };
 var getScrollableRect = async (element) => {
@@ -3854,6 +3876,47 @@ var scrollAwayFromObstruction = async (element, status) => {
     };
   }, status);
 };
+var getElementViewportSnapshot = async (element) => {
+  return element.evaluate((el) => {
+    const rect = el.getBoundingClientRect();
+    return {
+      top: rect.top,
+      bottom: rect.bottom,
+      left: rect.left,
+      right: rect.right,
+      width: rect.width,
+      height: rect.height,
+      scrollX: window.scrollX,
+      scrollY: window.scrollY
+    };
+  });
+};
+var isTargetImmobileAfterScroll = (before, after) => {
+  if (!before || !after) return false;
+  const rectDeltaY = Number(after.top || 0) - Number(before.top || 0);
+  const rectDeltaX = Number(after.left || 0) - Number(before.left || 0);
+  const scrollDeltaY = Number(after.scrollY || 0) - Number(before.scrollY || 0);
+  const scrollDeltaX = Number(after.scrollX || 0) - Number(before.scrollX || 0);
+  const rectMoved = Math.abs(rectDeltaY) > 3 || Math.abs(rectDeltaX) > 3;
+  const pageMoved = Math.abs(scrollDeltaY) > 3 || Math.abs(scrollDeltaX) > 3;
+  if (!rectMoved && !pageMoved) return true;
+  if (pageMoved && !rectMoved) return true;
+  if (Math.abs(scrollDeltaY) > 12 && Math.abs(rectDeltaY) < Math.min(12, Math.abs(scrollDeltaY) * 0.2)) {
+    return true;
+  }
+  return false;
+};
+var restoreWindowFromSnapshot = async (page, before, after) => {
+  if (!before || !after) return;
+  if (Math.abs(Number(after.scrollX || 0) - Number(before.scrollX || 0)) <= 2 && Math.abs(Number(after.scrollY || 0) - Number(before.scrollY || 0)) <= 2) {
+    return;
+  }
+  await page.evaluate(
+    (state) => window.scrollTo(state.x, state.y),
+    { x: Number(before.scrollX || 0), y: Number(before.scrollY || 0) }
+  ).catch(() => {
+  });
+};
 var dispatchTouchSwipe = async (page, deltaY, options = {}) => {
   const viewport = resolveViewport(page);
   const rawRect = options.rect || null;
@@ -4034,11 +4097,11 @@ var MobileHumanize = {
       const scrollRect = await getScrollableRect(element);
       if (!scrollRect && status.isFixed && status.code === "OUT_OF_VIEWPORT") {
         logger7.warn(`humanScroll | fixed/sticky \u76EE\u6807\u4E0D\u5728\u89C6\u53E3\u5185\uFF0C\u9875\u9762\u6EDA\u52A8\u65E0\u6CD5\u6539\u53D8\u5176\u4F4D\u7F6E (direction=${status.direction || "unknown"})`);
-        return { element, didScroll, restore: null };
+        return { element, didScroll, restore: null, unscrollable: true };
       }
       if (!scrollRect && status.isFixed && status.code === "OBSTRUCTED") {
         logger7.warn(`humanScroll | fixed/sticky \u76EE\u6807\u88AB\u906E\u6321\uFF0C\u6EDA\u52A8\u65E0\u6CD5\u89E3\u9664 (${status.obstruction?.tag || "unknown"})`);
-        return { element, didScroll, restore: null };
+        return { element, didScroll, restore: null, unscrollable: true };
       }
       if (scrollRect && status.code === "OBSTRUCTED" && status.obstruction?.isFixed) {
         const moved = await scrollAwayFromObstruction(element, status);
@@ -4069,6 +4132,7 @@ var MobileHumanize = {
         }
       }
       const beforeWindowState = scrollRect ? await page.evaluate(() => ({ x: window.scrollX, y: window.scrollY })) : null;
+      const beforeElementSnapshot = await getElementViewportSnapshot(element).catch(() => null);
       const beforeState = scrollRect ? await element.evaluate((el) => {
         const isScrollable = (node) => {
           const style = window.getComputedStyle(node);
@@ -4098,6 +4162,21 @@ var MobileHumanize = {
           logger7.debug(`humanScroll | \u7A97\u53E3\u6EDA\u52A8\u56DE\u6536 from=${Math.round(afterWindowState.y)} to=${Math.round(beforeWindowState.y)}`);
         }
       }
+      let afterElementSnapshot = null;
+      const readAfterElementSnapshot = async () => {
+        if (!afterElementSnapshot) {
+          afterElementSnapshot = await getElementViewportSnapshot(element).catch(() => null);
+        }
+        return afterElementSnapshot;
+      };
+      if (!scrollRect && beforeElementSnapshot) {
+        const afterSnapshot = await readAfterElementSnapshot();
+        if (isTargetImmobileAfterScroll(beforeElementSnapshot, afterSnapshot)) {
+          await restoreWindowFromSnapshot(page, beforeElementSnapshot, afterSnapshot);
+          logger7.warn(`humanScroll | \u76EE\u6807\u4E0D\u968F\u9875\u9762\u6EDA\u52A8\u79FB\u52A8\uFF0C\u9875\u9762\u6EDA\u52A8\u65E0\u6CD5\u6539\u53D8\u5176\u4F4D\u7F6E (status=${status.code}, direction=${status.direction || "unknown"})`);
+          return { element, didScroll, restore: null, unscrollable: true };
+        }
+      }
       if (scrollRect && beforeState) {
         const afterState = await element.evaluate((el) => {
           const isScrollable = (node) => {
@@ -4135,6 +4214,14 @@ var MobileHumanize = {
           }
         }
       }
+      if (scrollRect && beforeElementSnapshot) {
+        const afterSnapshot = await getElementViewportSnapshot(element).catch(() => null);
+        if (isTargetImmobileAfterScroll(beforeElementSnapshot, afterSnapshot)) {
+          await restoreWindowFromSnapshot(page, beforeElementSnapshot, afterSnapshot);
+          logger7.warn(`humanScroll | \u76EE\u6807\u4E0D\u968F\u6EDA\u52A8\u5BB9\u5668\u79FB\u52A8\uFF0C\u6EDA\u52A8\u65E0\u6CD5\u6539\u53D8\u5176\u4F4D\u7F6E (status=${status.code}, direction=${status.direction || "unknown"})`);
+          return { element, didScroll, restore: null, unscrollable: true };
+        }
+      }
       didScroll = true;
     }
     try {
@@ -4184,21 +4271,28 @@ var MobileHumanize = {
         logger7.warn(`humanClick: \u5143\u7D20\u4E0D\u5B58\u5728\uFF0C\u8DF3\u8FC7\u70B9\u51FB ${targetDesc}`);
         return false;
       }
-      if (scrollIfNeeded) {
-        await MobileHumanize.humanScroll(page, element, { throwOnMissing });
-      }
+      const scrollResult = scrollIfNeeded ? await MobileHumanize.humanScroll(page, element, { throwOnMissing }) : null;
       const status = await checkElementVisibility(element).catch(() => null);
       if (status && status.code !== "VISIBLE") {
-        if (fallbackDomClick && status.isFixed && status.code === "OUT_OF_VIEWPORT") {
-          const fallback = await withTimeout(
+        if (fallbackDomClick && (status.code === "OUT_OF_VIEWPORT" || status.code === "OBSTRUCTED") && (status.isFixed || scrollResult?.unscrollable)) {
+          let fallback = await withTimeout(
             () => activateElementFallback(element, null, {
               editableOnly: true
             }),
             activateFallbackTimeoutMs,
             "focus fallback"
           ).catch(() => null);
+          if (!fallback?.activated) {
+            fallback = await withTimeout(
+              () => activateElementFallback(element, null, {
+                editableOnly: false
+              }),
+              activateFallbackTimeoutMs,
+              "activation fallback"
+            ).catch(() => null);
+          }
           if (fallback?.activated) {
-            logger7.warn(`humanClick: fixed/sticky \u76EE\u6807\u4E0D\u5728\u89C6\u53E3\u5185\uFF0C\u5DF2\u7528 ${fallback.method} \u6FC0\u6D3B`);
+            logger7.warn(`humanClick: \u4E0D\u53EF\u6EDA\u52A8\u76EE\u6807\u4E0D\u53EF\u7269\u7406\u70B9\u51FB\uFF0C\u5DF2\u7528 ${fallback.method} \u6FC0\u6D3B`);
             return true;
           }
         }
@@ -4315,6 +4409,20 @@ var MobileHumanize = {
     const locator = page.locator(selector);
     await MobileHumanize.humanClick(page, locator, { scrollIfNeeded: true });
     await waitJitter(160, 0.4);
+    const readValue = async () => {
+      try {
+        return await locator.inputValue({ timeout: 600 });
+      } catch {
+        return await locator.evaluate((el) => "value" in el ? String(el.value || "") : String(el.textContent || "")).catch(() => "");
+      }
+    };
+    const currentValue = await readValue();
+    if (!currentValue) return;
+    await page.keyboard.press("ControlOrMeta+A");
+    await waitJitter(90, 0.35);
+    await page.keyboard.press("Backspace");
+    await waitJitter(120, 0.35);
+    if (!await readValue()) return;
     await locator.evaluate((el) => {
       if ("value" in el) {
         el.value = "";