@tocha688/browser 1.0.2 → 1.0.4

package/src/actions/auto/index.ts

@@ -1,236 +0,0 @@
-import type { Locator, Page, Request } from "patchright-core";
-import HumanMouse, { type ClickOptions } from "../../human/mouse";
-import type { AutoPage, AutoLocator, MonitorOptions, WaitForIframeCompleteOptions } from "./types";
-import { isLocator, isElementFocused, splitTextIntoChunks } from "./utils";
-import * as clickActions from "./click";
-import * as inputActions from "./input";
-import * as selectActions from "./select";
-import * as waitActions from "./wait";
-import * as pollActions from "./poll";
-import * as scrollActions from "./scroll";
-
-// Re-export types
-export * from "./types";
-export * from "./utils";
-
-const prefix = "_ah_";
-
-export class AutoHelper {
-  private page: Page;
-  public mouse: HumanMouse;
-
-  constructor(page: Page) {
-    this.page = page;
-    this.mouse = new HumanMouse(page);
-    // this.mouse.showCursor()
-  }
-
-  static create(page: Page): AutoPage {
-    const helper = new AutoHelper(page);
-
-    // 创建增强的 page 对象
-    const autoPage = Object.create(page);
-    Object.assign(autoPage, page);
-    Object.assign(autoPage, helper);
-
-    const hooks: string[] = [
-      "locator",
-      "getByRole",
-      "getByTestId",
-      "getByLabel",
-      "getByPlaceholder",
-      "getByText",
-      "getByAltText",
-      "getByTitle",
-    ];
-    hooks.forEach((hook) => {
-      if (!(page as any)[hook]) return;
-      const page2 = page as any;
-      const oldFn = page2[hook].bind(page);
-      const oldName = prefix + hook;
-      autoPage[oldName] = oldFn;
-      autoPage[hook] = function (...args: any[]) {
-        const loc = autoPage[oldName](...args);
-        if (loc) {
-          return helper.enhanceLocator(loc);
-        }
-        return loc;
-      };
-    });
-    return autoPage;
-  }
-
-  //增强locator
-  private enhanceLocator(locator: Locator): AutoLocator {
-    const autoLoc = Object.create(locator) as AutoLocator;
-    Object.assign(autoLoc, locator);
-    autoLoc._loc = locator;
-    autoLoc.click = this.click.bind(this, locator);
-    autoLoc.input = autoLoc.fill = this.input.bind(this, locator);
-    (autoLoc as any).selectOption = autoLoc.select = this.select.bind(
-      this,
-      locator
-    );
-    autoLoc.check = this.check.bind(this, locator);
-    autoLoc.uncheck = this.uncheck.bind(this, locator);
-    return autoLoc;
-  }
-
-  /** 点击元素 */
-  async click(
-    locator: Locator | string,
-    options?: Parameters<Locator["waitFor"]>[0] &
-      Parameters<Locator["click"]>[0] & {
-        /** 滚动超时时间 */
-        scrollTimeout?: number;
-        /** 是否跳过滚动检查 */
-        skipScroll?: boolean;
-      }
-  ) {
-    return clickActions.click(this.page, this.mouse, locator, options);
-  }
-
-  /** 点击指定坐标 */
-  async clickPoint(x: number, y: number, options?: ClickOptions) {
-    return clickActions.clickPoint(this.mouse, x, y, options);
-  }
-
-  isLocator(obj: any): obj is Locator {
-    return isLocator(obj);
-  }
-
-  /**
-   * 模拟真人输入文本到指定元素
-   */
-  async input(
-    locator: Locator | string,
-    text: string,
-    options?: Parameters<Locator["waitFor"]>[0] & {
-      clear?: boolean;
-      delay?: { min: number; max: number };
-      retries?: number;
-    }
-  ): Promise<void> {
-    return inputActions.input(this.page, this.mouse, locator, text, options);
-  }
-
-  /**
-   * 模拟真人输入文本到指定元素 (Force)
-   */
-  async inputFofce(
-    locator: Locator | string,
-    text: string,
-    options?: Parameters<Locator["waitFor"]>[0] & {
-      clear?: boolean;
-      delay?: { min: number; max: number };
-      retries?: number;
-    }
-  ): Promise<void> {
-    return inputActions.inputFofce(this.page, this.mouse, locator, text, options);
-  }
-
-  /**
-   * 选择下拉框选项
-   */
-  async select(
-    locator: Locator | string,
-    value: Parameters<Locator["selectOption"]>[0],
-    options?: Parameters<Locator["waitFor"]>[0] &
-      Parameters<Locator["selectOption"]>[1] & {
-        retries?: number;
-        verify?: boolean;
-      }
-  ): Promise<void> {
-    return selectActions.select(this.page, this.mouse, locator, value, options);
-  }
-
-  /**
-   * 勾选复选框或单选框
-   */
-  async check(
-    locator: Locator | string,
-    options?: Parameters<Locator["waitFor"]>[0] & {
-      force?: boolean;
-      retries?: number;
-      verify?: boolean;
-    }
-  ): Promise<void> {
-    return selectActions.check(this.page, this.mouse, locator, options);
-  }
-
-  /**
-   * 取消勾选复选框或单选框
-   */
-  async uncheck(
-    locator: Locator | string,
-    options?: Parameters<Locator["waitFor"]>[0] & {
-      force?: boolean;
-      retries?: number;
-      verify?: boolean;
-    }
-  ): Promise<void> {
-    return selectActions.uncheck(this.page, this.mouse, locator, options);
-  }
-
-  /** 随机等待 */
-  async rWait(minMs = 200, maxMs = 800) {
-    return waitActions.rWait(minMs, maxMs);
-  }
-
-  /**
-   * 通用且安全的等待页面加载状态完成
-   */
-  async safeWaitForLoadState(
-    state: "load" | "domcontentloaded" | "networkidle" | undefined = "load",
-    timeoutMs: number = 30000
-  ): Promise<boolean> {
-    return waitActions.safeWaitForLoadState(this.page, state, timeoutMs);
-  }
-
-  /**
-   * 等待指定 iframe 完全加载并等待指定目标元素可见
-   */
-  waitForIframeComplete(
-    frameLocator: string | number | symbol,
-    frameInLocator: string | Locator,
-    options: WaitForIframeCompleteOptions = {}
-  ) {
-    return waitActions.waitForIframeComplete(this.page, frameLocator, frameInLocator, options);
-  }
-
-  /**
-   * 开启后台请求轮询监听
-   */
-  startRequestPolling(
-    urlRule: string | RegExp,
-    callback?: (request: Request) => void,
-    options: MonitorOptions = {}
-  ) {
-    return pollActions.startRequestPolling(this.page, urlRule, callback, options);
-  }
-
-  /**
-   * 开启后台元素轮询监听
-   */
-  startElementPolling(
-    page: Page,
-    selector: string,
-    callback?: (locator: Locator) => Promise<void> | void,
-    options: MonitorOptions = {}
-  ) {
-    return pollActions.startElementPolling(page, selector, callback, options);
-  }
-
-  /** 可取消等待出现函数 */
-  waitForAbort(el: Locator, options: Parameters<Locator["waitFor"]>[0] = {}) {
-    return waitActions.waitForAbort(el, options);
-  }
-
-
-  /**
-   * 模拟人类滚动
-   */
-  async humanScroll(distance: number, targetLocator?: Locator) {
-    return scrollActions.humanScroll(this.page, distance, targetLocator);
-  }
-}

package/src/actions/auto/input.ts

@@ -1,157 +0,0 @@
-import type { Locator, Page } from "patchright-core";
-import HumanMouse from "../../human/mouse";
-import { splitTextIntoChunks, isElementFocused, isLocator } from "./utils";
-import { rWait } from "./wait";
-import { click } from "./click";
-import { rInt } from "@tocha688/utils";
-
-export async function input(
-  page: Page,
-  mouse: HumanMouse,
-  locator: Locator | string,
-  text: string,
-  options?: Parameters<Locator["waitFor"]>[0] & {
-    clear?: boolean;
-    delay?: { min: number; max: number };
-    retries?: number;
-  }
-): Promise<void> {
-  // 标准化locator
-  if (typeof locator === "string") {
-    locator = page.locator(locator);
-  }
-  if (!isLocator(locator)) {
-    throw new Error("locator 类型错误");
-  }
-
-  const {
-    clear = true,
-    delay = { min: 50, max: 150 },
-    retries = 3,
-    ...waitOptions
-  } = options || {};
-
-  // 等待元素可见和可用
-  await locator.waitFor({ state: "visible", ...waitOptions });
-  await locator.waitFor({ state: "attached", ...waitOptions });
-
-  // 点击元素确保聚焦
-  await click(page, mouse, locator, waitOptions);
-  await rWait(50, 100);
-
-  // 清空现有内容
-  if (clear) {
-    const currentValue = await locator.inputValue().catch(() => "");
-    if (currentValue && currentValue.length > 0) {
-      // 使用三击选中全部内容，然后删除
-      await locator.click({ clickCount: 3 });
-      await rWait(20, 50);
-      await page.keyboard.press("Delete");
-      await rWait(20, 50);
-    }
-  }
-
-  // 分批输入文本，避免长文本一次性输入
-  const chunks = splitTextIntoChunks(text, 5); // 每5个字符一组
-
-  for (let i = 0; i < chunks.length; i++) {
-    const chunk = chunks[i];
-    // 检查元素是否仍然聚焦
-    const isFocused = await isElementFocused(locator);
-    if (!isFocused) {
-      await click(page, mouse, locator, waitOptions);
-      // 如果光标没有在最后面，将光标移动到最后
-      const currentValue = await locator.inputValue().catch(() => "");
-      if (currentValue && currentValue.length > 0) {
-        await page.keyboard.press("End");
-      }
-      await rWait(30, 60);
-    }
-
-    // 使用pressSequentially进行更自然的输入
-    if (chunk) {
-      await locator.pressSequentially(chunk, {
-        delay: rInt(delay.min, delay.max),
-      });
-    }
-
-    // 随机等待，模拟真人输入节奏
-    if (i < chunks.length - 1) {
-      await rWait(50, 150);
-    }
-  }
-  // 验证输入结果
-  await rWait(100, 200);
-  // 失焦
-  await locator.blur();
-}
-
-export async function inputFofce(
-  page: Page,
-  mouse: HumanMouse,
-  locator: Locator | string,
-  text: string,
-  options?: Parameters<Locator["waitFor"]>[0] & {
-    clear?: boolean;
-    delay?: { min: number; max: number };
-    retries?: number;
-  }
-): Promise<void> {
-  // 标准化locator
-  if (typeof locator === "string") {
-    locator = page.locator(locator);
-  }
-  if (!isLocator(locator)) {
-    throw new Error("locator 类型错误");
-  }
-
-  const {
-    clear = true,
-    delay = { min: 50, max: 150 },
-    retries = 3,
-    ...waitOptions
-  } = options || {};
-
-  // 等待元素可见和可用
-  await locator.waitFor({ state: "visible", ...waitOptions });
-  await locator.waitFor({ state: "attached", ...waitOptions });
-
-  // 点击元素确保聚焦
-  await click(page, mouse, locator, waitOptions);
-  await rWait(50, 100);
-
-  // 清空现有内容
-  if (clear) {
-    const currentValue = await locator.inputValue().catch(() => "");
-    if (currentValue && currentValue.length > 0) {
-      // 使用三击选中全部内容，然后删除
-      await locator.click({ clickCount: 3 });
-      await rWait(20, 50);
-      await page.keyboard.press("Delete");
-      await rWait(20, 50);
-    }
-  }
-
-  // 分批输入文本，避免长文本一次性输入
-  const chunks = splitTextIntoChunks(text, 5); // 每5个字符一组
-
-  for (let i = 0; i < chunks.length; i++) {
-    const chunk = chunks[i];
-
-    // 使用pressSequentially进行更自然的输入
-    if (chunk) {
-      await locator.pressSequentially(chunk, {
-        delay: rInt(delay.min, delay.max),
-      });
-    }
-
-    // 随机等待，模拟真人输入节奏
-    if (i < chunks.length - 1) {
-      await rWait(50, 150);
-    }
-  }
-  // 验证输入结果
-  await rWait(100, 200);
-  // 失焦
-  await locator.blur();
-}

package/src/actions/auto/poll.ts

@@ -1,145 +0,0 @@
-import type { Page, Request, Locator } from "patchright-core";
-import type { MonitorOptions } from "./types";
-
-export function startRequestPolling(
-  page: Page,
-  urlRule: string | RegExp,
-  callback?: (request: Request) => void,
-  options: MonitorOptions = {}
-) {
-  const { interval = 1000, debug = false } = options;
-  const matchedQueue: Request[] = [];
-  let isRunning = true;
-
-  // 1. 实时收集请求放入队列 (不阻塞主流程)
-  const requestListener = (request: Request) => {
-    const url = request.url();
-    // 判断 URL 是否匹配
-    const isMatch =
-      urlRule instanceof RegExp ? urlRule.test(url) : url.includes(urlRule);
-
-    if (isMatch) {
-      if (debug) console.log(`[Collector] 捕获到目标请求: ${url}`);
-      matchedQueue.push(request);
-    }
-  };
-
-  // 注册监听器
-  page.on("request", requestListener);
-
-  // 2. 开启定时轮询 (setInterval) 处理队列
-  const timer = setInterval(async () => {
-    if (!isRunning) return;
-
-    if (debug)
-      console.log(
-        `[Poller] 轮询检查中... 当前队列积压: ${matchedQueue.length}`
-      );
-
-    // 处理队列中所有新发现的请求
-    while (matchedQueue.length > 0) {
-      const req = matchedQueue.shift(); // 取出最早的一个
-      if (!req) continue;
-
-      if (callback) {
-        // --- 情况 A: 传入了回调函数 ---
-        // try {
-        await callback(req);
-        // } catch (e) {
-        //   console.error('[Callback Error] 回调函数执行出错:', e);
-        // }
-      } else {
-        // --- 情况 B: 未传入回调 -> 默认行为 (打印 + Throw) ---
-        const msg = `[Error] 致命错误: 检测到被禁止的请求/未处理的请求发送! URL: ${req.url()}`;
-        console.error(msg);
-
-        cleanup(); // 抛错前先清理
-      }
-    }
-  }, interval);
-
-  // 清理函数
-  const cleanup = () => {
-    if (!isRunning) return;
-    isRunning = false;
-    clearInterval(timer);
-    page.off("request", requestListener); // 移除监听，防止内存泄漏
-    if (debug) console.log("[Poller] 监听已停止");
-  };
-
-  // 返回控制器，以便在测试结束时手动停止
-  return { stop: cleanup };
-}
-
-export function startElementPolling(
-  page: Page,
-  selector: string,
-  callback?: (locator: Locator) => Promise<void> | void,
-  options: MonitorOptions = {}
-) {
-  const { interval = 1000, debug = false } = options;
-  let isRunning = true;
-  let isProcessing = false; // 防止上一轮回调还没跑完，下一轮轮询就开始了
-
-  if (debug) console.log(`[ElementMonitor] 开始监听元素: "${selector}"`);
-
-  const timer = setInterval(async () => {
-    // 1. 如果停止了，或者上一轮正在处理中，跳过
-    if (!isRunning || isProcessing) return;
-
-    try {
-      // 2. 检查页面是否已关闭 (防止报错)
-      if (page.isClosed()) {
-        cleanup();
-        return;
-      }
-
-      // 3. 检查元素是否可见 (isVisible 不会报错，只会返回 true/false)
-      // 使用 isVisible 而不是 $，因为我们通常关心的是“用户是否看到了”
-      const isVisible = await page.isVisible(selector);
-
-      if (isVisible) {
-        if (debug)
-          console.log(`[ElementMonitor] 发现目标元素: "${selector}"`);
-
-        // 标记正在处理，暂停下一轮轮询
-        isProcessing = true;
-
-        if (callback) {
-          // --- 情况 A: 有回调 -> 执行逻辑 (如点击关闭、输入内容) ---
-          try {
-            await callback(page.locator(selector));
-          } catch (err) {
-            console.error(
-              `[Callback Error] 处理元素 "${selector}" 回调失败:`,
-              err
-            );
-          } finally {
-            // 处理完后，释放锁，允许下一轮检测 (如果元素还在，会再次触发)
-            isProcessing = false;
-          }
-        } else {
-          // --- 情况 B: 无回调 -> 默认行为 (报错) ---
-          const msg = `[Error] 致命错误: 页面出现了不该出现的元素! Selector: "${selector}"`;
-          console.error(msg);
-
-          // 停止监听并抛出错误
-          cleanup();
-        }
-      }
-    } catch (error) {
-      // 捕获轮询过程中的意外错误（如 context 崩溃），防止中断主进程
-      if (debug) console.warn("[ElementMonitor] 轮询检查异常:", error);
-    }
-  }, interval);
-
-  // 清理函数
-  const cleanup = () => {
-    if (!isRunning) return;
-    isRunning = false;
-    clearInterval(timer);
-    if (debug) console.log(`[ElementMonitor] 停止监听元素: "${selector}"`);
-  };
-
-  return { stop: cleanup };
-}

package/src/actions/auto/scroll.ts

@@ -1,81 +0,0 @@
-import { rInt, sleep } from "@tocha688/utils";
-import type { Page, Locator } from "patchright-core";
-
-export async function humanScroll(
-  page: Page,
-  distance: number,
-  targetLocator?: Locator
-) {
-  let scrolledAmount = 0;
-  // 增加或减少随机距离，模拟人类目标的不精确性
-  const finalDistance = distance + rInt(-100, 100);
-  console.log(`开始模拟滚动，目标距离: ${finalDistance}px`);
-
-  if (targetLocator) {
-    // 确保元素可见并获取位置
-    // 注意：如果元素在 iframe 里，boundingBox 返回的是相对于主页面的坐标，直接 move 是没问题的
-    const box = await targetLocator.boundingBox();
-    if (box) {
-      // 移动到元素中心稍微偏随机一点的位置
-      const x = box.x + box.width / 2 + rInt(-10, 10);
-      const y = box.y + box.height / 2 + rInt(-10, 10);
-      await page.mouse.move(x, y);
-    } else {
-      console.warn(
-        "Target locator provided but element is not visible/present. Falling back to global scroll."
-      );
-    }
-  } else {
-    // 如果没有指定元素，也可以先移动鼠标到屏幕中间，防止鼠标停留在某个不相干的侧边栏上
-    // 视情况可选
-    // await this.page.mouse.move(300, 300);
-  }
-
-  // --- 滚动执行函数 ---
-  const scrollExecutor = async (step: number) => {
-    // if (targetLocator) {
-    //   await targetLocator.evaluate(
-    //     `(el, stepValue) => {
-    //     if (el) {
-    //       el.scrollBy(0, stepValue);
-    //     }
-    //   }`,
-    //     step
-    //   );
-    // } else {
-    // 在整个页面上执行滚动
-    await page.mouse.wheel(0, step);
-    // await this.page.mouse.move(this.random(100, 500), this.random(100, 500));
-    // 偶尔微调鼠标位置，模拟人的手不稳 (可选，增加真实感)
-    if (!targetLocator && Math.random() < 0.3) {
-      await page.mouse.move(rInt(100, 500), rInt(100, 500));
-    }
-    // }
-  };
-
-  // --- 滚动循环 ---
-  while (scrolledAmount < finalDistance) {
-    // 1. 随机步长：模拟手指拨动滚轮的力度 (50px - 150px)
-    let step = rInt(50, 150);
-
-    // 防止最后一步滚过头
-    if (scrolledAmount + step > finalDistance) {
-      step = finalDistance - scrolledAmount;
-    }
-
-    // 2. 执行滚动
-    await scrollExecutor(step);
-    scrolledAmount += step;
-
-    // 3. 随机停顿：模拟人眼的反应时间和手指的动作间隙
-    if (Math.random() < 0.1) {
-      // 10% 的概率停顿久一点 (500ms - 800ms) 模拟“阅读”
-      await sleep(rInt(500, 800));
-    } else {
-      // 正常滚动间隙 (30ms - 100ms)
-      await sleep(rInt(30, 100));
-    }
-  }
-
-  console.log("滚动完成");
-}