@skrillex1224/playwright-toolkit 2.1.281 → 2.1.282

package/dist/index.js

@@ -4707,53 +4707,8 @@ var resolveDeviceFromPage3 = (page) => normalizeDevice(page?.[PageRuntimeStateKe
 var isMobilePage = (page) => resolveDeviceFromPage3(page) === Device.Mobile;
 var isPageLike2 = (value) => value && typeof value === "object" && typeof value.evaluate === "function";
 var isPoint2 = (value) => value && typeof value === "object" && Number.isFinite(Number(value.x)) && Number.isFinite(Number(value.y));
-var resolveNativeTarget2 = (page, target) => typeof target === "string" ? page.locator(target).first() : target;
-var getViewportCenter = (page) => {
-  const viewport = page?.viewportSize?.() || { width: 1365, height: 900 };
-  return {
-    x: Math.round(viewport.width / 2),
-    y: Math.round(viewport.height / 2)
-  };
-};
-var readViewportScroll = async (page) => await page.evaluate(() => ({ x: window.scrollX, y: window.scrollY })).catch(() => ({ x: 0, y: 0 }));
-var getTargetBox = async (target) => {
-  if (!target || typeof target.boundingBox !== "function") {
-    return null;
-  }
-  return await target.boundingBox().catch(() => null);
-};
-var clickOptionsFrom = (options = {}) => {
-  const nextOptions = {
-    force: true
-  };
-  if (options.timeout != null) {
-    nextOptions.timeout = options.timeout;
-  }
-  return nextOptions;
-};
-var typeOptionsFrom = (options = {}) => {
-  const nextOptions = {};
-  if (options.timeout != null) {
-    nextOptions.timeout = options.timeout;
-  }
-  if (options.baseDelay != null) {
-    nextOptions.delay = Math.max(0, Number(options.baseDelay) || 0);
-  }
-  return nextOptions;
-};
-var pressOptionsFrom = (options = {}) => {
-  const nextOptions = {};
-  if (options.timeout != null) {
-    nextOptions.timeout = options.timeout;
-  }
-  if (options.holdDelay != null) {
-    nextOptions.delay = Math.max(0, Number(options.holdDelay) || 0);
-  }
-  return nextOptions;
-};
-var waitDesktopJitter = async (baseMs, jitterPercent = 0.3) => {
-  await delay4(jitterMs(baseMs, jitterPercent));
-};
+var resolveTarget = (page, target) => typeof target === "string" ? page.locator(target).first() : target;
+var sleep = (base, jitter = 0.3) => delay4(jitterMs(base, jitter));
 var DesktopCloakHumanize = {
   jitterMs(base, jitterPercent = 0.3) {
     return jitterMs(base, jitterPercent);
@@ -4762,43 +4717,23 @@ var DesktopCloakHumanize = {
     return Boolean(page);
   },
   async humanMove(page, target) {
-    if (target == null) {
-      return false;
-    }
+    if (target == null) return false;
     if (isPoint2(target)) {
       await page.mouse.move(Number(target.x), Number(target.y));
       return true;
     }
-    const resolvedTarget = resolveNativeTarget2(page, target);
-    if (typeof resolvedTarget?.hover === "function") {
-      await resolvedTarget.hover(clickOptionsFrom());
-      return true;
-    }
-    const box = await getTargetBox(resolvedTarget);
-    if (!box) {
-      return false;
-    }
-    await page.mouse.move(box.x + box.width / 2, box.y + box.height / 2);
+    await resolveTarget(page, target).hover();
     return true;
   },
   async humanScroll(page, target) {
-    const resolvedTarget = resolveNativeTarget2(page, target);
-    if (!resolvedTarget) {
-      return { element: null, didScroll: false, restore: null };
-    }
-    const before = await readViewportScroll(page);
-    await resolvedTarget.scrollIntoViewIfNeeded?.();
-    const after = await readViewportScroll(page);
-    return {
-      element: resolvedTarget,
-      didScroll: before.x !== after.x || before.y !== after.y,
-      restore: null
-    };
+    const element = resolveTarget(page, target);
+    if (!element) return { element: null, didScroll: false, restore: null };
+    await element.scrollIntoViewIfNeeded?.();
+    return { element, didScroll: true, restore: null };
   },
-  async humanClick(page, target, options = {}) {
+  async humanClick(page, target) {
     if (target == null) {
-      const center = getViewportCenter(page);
-      await page.mouse.click(center.x, center.y);
+      await page.mouse.click(0, 0);
       return true;
     }
     if (isPoint2(target)) {
@@ -4806,22 +4741,14 @@ var DesktopCloakHumanize = {
       return true;
     }
     if (typeof target === "string") {
-      await page.click(target, clickOptionsFrom(options));
-      return true;
-    }
-    if (typeof target?.click === "function") {
-      await target.click(clickOptionsFrom(options));
+      await page.click(target);
       return true;
     }
-    const box = await getTargetBox(target);
-    if (!box) {
-      return false;
-    }
-    await page.mouse.click(box.x + box.width / 2, box.y + box.height / 2);
+    await target.click();
     return true;
   },
   async randomSleep(baseMs, jitterPercent = 0.3) {
-    await waitDesktopJitter(baseMs, jitterPercent);
+    await sleep(baseMs, jitterPercent);
   },
   async simulateGaze(page, baseDurationMs = 2500) {
     const durationMs = jitterMs(baseDurationMs, 0.4);
@@ -4832,77 +4759,49 @@ var DesktopCloakHumanize = {
         100 + Math.random() * Math.max(120, viewport.width - 200),
         100 + Math.random() * Math.max(120, viewport.height - 200)
       );
-      await waitDesktopJitter(600, 0.5);
+      await sleep(300, 0.5);
     }
   },
-  async humanType(page, selector, text, options = {}) {
+  async humanType(page, selector, text) {
     if (typeof selector === "string") {
-      await page.type(selector, text, typeOptionsFrom(options));
+      await page.type(selector, text);
       return;
     }
-    await selector.type(text, typeOptionsFrom(options));
+    await selector.type(text);
   },
-  async humanPress(page, targetOrKey, maybeKey, options = {}) {
-    const hasTarget = typeof maybeKey === "string";
-    const key = hasTarget ? maybeKey : targetOrKey;
-    const pressOptions = hasTarget ? options : maybeKey || options;
-    if (!hasTarget) {
-      await page.keyboard.press(key, pressOptionsFrom(pressOptions));
+  async humanPress(page, targetOrKey, maybeKey) {
+    if (typeof maybeKey !== "string") {
+      await page.keyboard.press(targetOrKey);
       return true;
     }
     if (typeof targetOrKey === "string") {
-      await page.press(targetOrKey, key, pressOptionsFrom(pressOptions));
+      await page.press(targetOrKey, maybeKey);
       return true;
     }
-    if (typeof targetOrKey?.press === "function") {
-      await targetOrKey.press(key, pressOptionsFrom(pressOptions));
-      return true;
-    }
-    await page.keyboard.press(key, pressOptionsFrom(pressOptions));
+    await targetOrKey.press(maybeKey);
     return true;
   },
   async humanClear(page, selector) {
     if (typeof selector === "string") {
-      if (typeof page.clear === "function") {
-        await page.clear(selector, clickOptionsFrom());
-        return;
-      }
-      await page.fill(selector, "", clickOptionsFrom());
-      return;
-    }
-    if (typeof selector?.clear === "function") {
-      await selector.clear(clickOptionsFrom());
-      return;
-    }
-    if (typeof selector?.fill === "function") {
-      await selector.fill("", clickOptionsFrom());
+      await page.fill(selector, "");
       return;
     }
+    await selector.fill("");
   },
   async warmUpBrowsing(page, baseDuration = 3500) {
-    const durationMs = jitterMs(baseDuration, 0.4);
-    const startedAt = Date.now();
-    while (Date.now() - startedAt < durationMs) {
-      await this.simulateGaze(page, 240);
-      await this.naturalScroll(page, Math.random() > 0.4 ? "down" : "up", 160, 3);
-      await waitDesktopJitter(250, 0.35);
-    }
+    await this.simulateGaze(page, Math.min(baseDuration, 900));
   },
   async naturalScroll(page, direction = "down", distance = 300, baseSteps = 5) {
     const steps = Math.max(1, Number(baseSteps) || 1);
-    const stepDistance = (Number(distance) || 0) / steps;
-    const sign = direction === "down" ? 1 : -1;
+    const delta = (Number(distance) || 0) / steps * (direction === "down" ? 1 : -1);
     for (let index = 0; index < steps; index += 1) {
-      await page.mouse.wheel(0, stepDistance * sign);
-      await waitDesktopJitter(60 + index * 20, 0.3);
+      await page.mouse.wheel(0, delta);
+      await sleep(60 + index * 20, 0.3);
     }
   }
 };
 var resolveDelegate2 = (page) => isMobilePage(page) ? MobileHumanize : DesktopCloakHumanize;
-var callDelegate2 = (method, page, args) => {
-  const delegate = resolveDelegate2(page);
-  return delegate[method](page, ...args);
-};
+var callDelegate2 = (method, page, args) => resolveDelegate2(page)[method](page, ...args);
 var CloakBrowserHumanize = {
   jitterMs(base, jitterPercent = 0.3) {
     return jitterMs(base, jitterPercent);
@@ -4921,8 +4820,7 @@ var CloakBrowserHumanize = {
   },
   randomSleep(pageOrBaseMs, maybeBaseMs, maybeJitterPercent) {
     if (isPageLike2(pageOrBaseMs)) {
-      const delegate = resolveDelegate2(pageOrBaseMs);
-      return delegate.randomSleep(maybeBaseMs, maybeJitterPercent);
+      return resolveDelegate2(pageOrBaseMs).randomSleep(maybeBaseMs, maybeJitterPercent);
     }
     return DesktopCloakHumanize.randomSleep(pageOrBaseMs, maybeBaseMs);
   },
@@ -6748,7 +6646,7 @@ var Mutation = {
     const overallTimeout = options.timeout ?? 180 * 1e3;
     const onMutation = options.onMutation;
     const pollInterval = 500;
-    const sleep = (ms) => new Promise((resolve) => {
+    const sleep2 = (ms) => new Promise((resolve) => {
       setTimeout(resolve, ms);
     });
     const truncate = (value, max = 800) => {
@@ -6940,7 +6838,7 @@ var Mutation = {
     const deadline = Date.now() + overallTimeout;
     let lastState = state2;
     while (Date.now() < deadline) {
-      await sleep(pollInterval);
+      await sleep2(pollInterval);
       lastState = await buildState();
       if (!lastState?.hasMatched) {
         continue;