@skrillex1224/playwright-toolkit 2.1.262 → 2.1.265

package/dist/index.cjs

@@ -205,7 +205,7 @@ var ActorInfo = {
     name: "\u8C46\u5305",
     domain: "www.doubao.com",
     path: "/",
-    device: Device.Mobile,
+    device: Device.Desktop,
     share: {
       mode: "response",
       prefix: "https://www.doubao.com/thread/",
@@ -2927,6 +2927,180 @@ var DeviceInput = {
   }
 };
 
+// src/device-view.js
+var import_playwright = require("playwright");
+var DEFAULT_MOBILE_DESCRIPTOR = "Pixel 7";
+var clonePlain = (value) => {
+  if (!value || typeof value !== "object") return value;
+  try {
+    return JSON.parse(JSON.stringify(value));
+  } catch {
+    return { ...value };
+  }
+};
+var resolveDescriptor = (descriptor, device) => {
+  if (descriptor && typeof descriptor === "object") {
+    return descriptor;
+  }
+  const name = String(descriptor || (device === Device.Mobile ? DEFAULT_MOBILE_DESCRIPTOR : "")).trim();
+  if (!name) return null;
+  const resolved = import_playwright.devices[name];
+  if (!resolved) {
+    throw new Error(`DeviceView.withPageDevice unknown Playwright device descriptor: ${name}`);
+  }
+  return resolved;
+};
+var attachRuntimeState = (page, state) => {
+  Object.defineProperty(page, PageRuntimeStateKey, {
+    configurable: true,
+    enumerable: false,
+    writable: true,
+    value: state
+  });
+};
+var restoreRuntimeState = (page, snapshot) => {
+  if (snapshot.hadRuntimeState) {
+    attachRuntimeState(page, snapshot.runtimeState);
+    return;
+  }
+  delete page[PageRuntimeStateKey];
+};
+var waitFor2 = (page, timeout) => {
+  if (!timeout) return Promise.resolve();
+  if (page && typeof page.waitForTimeout === "function") {
+    return page.waitForTimeout(timeout);
+  }
+  return new Promise((resolve) => setTimeout(resolve, timeout));
+};
+var dispatchTouchTap = async (client, page, x, y) => {
+  await client.send("Input.dispatchTouchEvent", {
+    type: "touchStart",
+    touchPoints: [{ x, y, id: 1 }]
+  });
+  await waitFor2(page, 30);
+  await client.send("Input.dispatchTouchEvent", {
+    type: "touchEnd",
+    touchPoints: []
+  });
+};
+var installScopedTouchscreenTap = (page, client, enabled) => {
+  if (!enabled || !page?.touchscreen || typeof page.touchscreen.tap !== "function") {
+    return () => {
+    };
+  }
+  const originalTap = page.touchscreen.tap;
+  page.touchscreen.tap = async (x, y) => {
+    try {
+      return await originalTap.call(page.touchscreen, x, y);
+    } catch (error) {
+      if (!String(error?.message || error).includes("hasTouch must be enabled")) {
+        throw error;
+      }
+      return await dispatchTouchTap(client, page, x, y);
+    }
+  };
+  return () => {
+    page.touchscreen.tap = originalTap;
+  };
+};
+var buildScopedRuntimeState = (page, runtimeState, device) => ({
+  ...clonePlain(runtimeState || page?.[PageRuntimeStateKey] || {}) || {},
+  device
+});
+var applyDeviceEmulation = async (page, descriptor, device, options = {}) => {
+  if (!descriptor) return { client: null, restoreTouchscreenTap: () => {
+  } };
+  const client = await page.context().newCDPSession(page);
+  const viewport = descriptor.viewport || null;
+  const isMobile = device === Device.Mobile || descriptor.isMobile === true;
+  const hasTouch = device === Device.Mobile || descriptor.hasTouch === true;
+  const deviceScaleFactor = Number(descriptor.deviceScaleFactor || 1);
+  if (descriptor.userAgent) {
+    await client.send("Emulation.setUserAgentOverride", {
+      userAgent: descriptor.userAgent,
+      platform: options.platform || (isMobile ? "Android" : void 0)
+    });
+  }
+  if (viewport?.width > 0 && viewport?.height > 0) {
+    await page.setViewportSize({
+      width: viewport.width,
+      height: viewport.height
+    });
+    await client.send("Emulation.setDeviceMetricsOverride", {
+      width: viewport.width,
+      height: viewport.height,
+      deviceScaleFactor,
+      mobile: isMobile,
+      screenWidth: descriptor.screen?.width || viewport.width,
+      screenHeight: descriptor.screen?.height || viewport.height
+    });
+  }
+  await client.send("Emulation.setTouchEmulationEnabled", {
+    enabled: hasTouch,
+    maxTouchPoints: hasTouch ? Number(options.maxTouchPoints || 5) : 0
+  });
+  return {
+    client,
+    restoreTouchscreenTap: installScopedTouchscreenTap(page, client, hasTouch)
+  };
+};
+var restoreDeviceEmulation = async (page, emulation, snapshot) => {
+  const client = emulation?.client;
+  emulation?.restoreTouchscreenTap?.();
+  if (!client) return;
+  await client.send("Emulation.setTouchEmulationEnabled", { enabled: false }).catch(() => {
+  });
+  await client.send("Emulation.clearDeviceMetricsOverride").catch(() => {
+  });
+  if (snapshot.userAgent) {
+    await client.send("Emulation.setUserAgentOverride", {
+      userAgent: snapshot.userAgent,
+      platform: snapshot.platform || void 0
+    }).catch(() => {
+    });
+  }
+  if (snapshot.viewport) {
+    await page.setViewportSize(snapshot.viewport).catch(() => {
+    });
+  }
+  await client.detach().catch(() => {
+  });
+};
+var DeviceView = {
+  async withPageDevice(page, options = {}, callback) {
+    if (!page || typeof page !== "object") {
+      throw new Error("DeviceView.withPageDevice requires a Playwright page");
+    }
+    if (typeof callback !== "function") {
+      throw new Error("DeviceView.withPageDevice requires a callback");
+    }
+    const device = normalizeDevice(options.device);
+    const descriptor = resolveDescriptor(options.descriptor, device);
+    const snapshot = {
+      hadRuntimeState: Object.prototype.hasOwnProperty.call(page, PageRuntimeStateKey),
+      runtimeState: clonePlain(page[PageRuntimeStateKey]),
+      viewport: page.viewportSize?.() || null,
+      userAgent: await page.evaluate(() => navigator.userAgent).catch(() => ""),
+      platform: await page.evaluate(() => navigator.platform).catch(() => "")
+    };
+    const runtimeState = buildScopedRuntimeState(page, options.runtimeState, device);
+    let emulation = null;
+    attachRuntimeState(page, runtimeState);
+    try {
+      emulation = await applyDeviceEmulation(page, descriptor, device, options);
+      return await callback({
+        page,
+        device,
+        descriptor,
+        runtimeState
+      });
+    } finally {
+      restoreRuntimeState(page, snapshot);
+      await restoreDeviceEmulation(page, emulation, snapshot);
+    }
+  }
+};
+
 // src/internals/humanize/desktop.js
 var import_delay2 = __toESM(require("delay"), 1);
 var import_ghost_cursor_playwright = require("ghost-cursor-playwright");
@@ -9364,6 +9538,7 @@ var usePlaywrightToolKit = () => {
     ApifyKit,
     AntiCheat,
     DeviceInput,
+    DeviceView,
     Humanize: Humanize2,
     Launch,
     LiveView,