phantomwright-driver-core 1.57.0 → 1.57.1

package/lib/client/browserContext.js

@@ -71,6 +71,7 @@ class BrowserContext extends import_channelOwner.ChannelOwner {
     this._harRecorders = /* @__PURE__ */ new Map();
     this._closingStatus = "none";
     this._harRouters = [];
+    this.routeInjecting = false;
     this._options = initializer.options;
     this._timeoutSettings = new import_timeoutSettings.TimeoutSettings(this._platform);
     this.tracing = import_tracing.Tracing.from(initializer.tracing);
@@ -308,14 +309,17 @@ class BrowserContext extends import_channelOwner.ChannelOwner {
     await this._channel.setHTTPCredentials({ httpCredentials: httpCredentials || void 0 });
   }
   async addInitScript(script, arg) {
+    await this.installInjectRoute();
     const source = await (0, import_clientHelper.evaluationScript)(this._platform, script, arg);
     await this._channel.addInitScript({ source });
   }
   async exposeBinding(name, callback, options = {}) {
+    await this.installInjectRoute();
     await this._channel.exposeBinding({ name, needsHandle: options.handle });
     this._bindings.set(name, callback);
   }
   async exposeFunction(name, callback) {
+    await this.installInjectRoute();
     await this._channel.exposeBinding({ name });
     const binding = (source, ...args) => callback(...args);
     this._bindings.set(name, binding);
@@ -474,6 +478,21 @@ class BrowserContext extends import_channelOwner.ChannelOwner {
     this._onRecorderEventSink = void 0;
     await this._channel.disableRecorder();
   }
+  async installInjectRoute() {
+    if (this.routeInjecting) return;
+    await this.route("**/*", async (route) => {
+      try {
+        if (route.request().resourceType() === "document" && route.request().url().startsWith("http")) {
+          const protocol = route.request().url().split(":")[0];
+          await route.fallback({ url: protocol + "://patchright-init-script-inject.internal/" });
+        } else {
+          await route.fallback();
+        }
+      } catch (error) {
+        await route.fallback();
+      }
+    });
+  }
 }
 async function prepareStorageState(platform, storageState) {
   if (typeof storageState !== "string")

package/lib/client/clientHelper.js

@@ -53,8 +53,7 @@ async function evaluationScript(platform, fun, arg, addSourceUrl = true) {
   throw new Error("Either path or content property must be present");
 }
 function addSourceUrlToScript(source, path) {
-  return `${source}
-//# sourceURL=${path.replace(/\n/g, "")}`;
+  return source;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/lib/client/clock.js

@@ -26,6 +26,7 @@ class Clock {
     this._browserContext = browserContext;
   }
   async install(options = {}) {
+    await this._browserContext.installInjectRoute();
     await this._browserContext._channel.clockInstall(options.time !== void 0 ? parseTime(options.time) : {});
   }
   async fastForward(ticks) {

package/lib/client/frame.js

@@ -166,14 +166,14 @@ class Frame extends import_channelOwner.ChannelOwner {
   async frameElement() {
     return import_elementHandle.ElementHandle.from((await this._channel.frameElement()).element);
   }
-  async evaluateHandle(pageFunction, arg) {
-    (0, import_jsHandle.assertMaxArguments)(arguments.length, 2);
-    const result = await this._channel.evaluateExpressionHandle({ expression: String(pageFunction), isFunction: typeof pageFunction === "function", arg: (0, import_jsHandle.serializeArgument)(arg) });
+  async evaluateHandle(pageFunction, arg, isolatedContext = true) {
+    (0, import_jsHandle.assertMaxArguments)(arguments.length, 3);
+    const result = await this._channel.evaluateExpressionHandle({ expression: String(pageFunction), isFunction: typeof pageFunction === "function", arg: (0, import_jsHandle.serializeArgument)(arg), isolatedContext });
     return import_jsHandle.JSHandle.from(result.handle);
   }
-  async evaluate(pageFunction, arg) {
-    (0, import_jsHandle.assertMaxArguments)(arguments.length, 2);
-    const result = await this._channel.evaluateExpression({ expression: String(pageFunction), isFunction: typeof pageFunction === "function", arg: (0, import_jsHandle.serializeArgument)(arg) });
+  async evaluate(pageFunction, arg, isolatedContext = true) {
+    (0, import_jsHandle.assertMaxArguments)(arguments.length, 3);
+    const result = await this._channel.evaluateExpression({ expression: String(pageFunction), isFunction: typeof pageFunction === "function", arg: (0, import_jsHandle.serializeArgument)(arg), isolatedContext });
     return (0, import_jsHandle.parseResult)(result.value);
   }
   async _evaluateFunction(functionDeclaration) {
@@ -205,9 +205,9 @@ class Frame extends import_channelOwner.ChannelOwner {
     const result = await this._channel.evalOnSelector({ selector, expression: String(pageFunction), isFunction: typeof pageFunction === "function", arg: (0, import_jsHandle.serializeArgument)(arg) });
     return (0, import_jsHandle.parseResult)(result.value);
   }
-  async $$eval(selector, pageFunction, arg) {
-    (0, import_jsHandle.assertMaxArguments)(arguments.length, 3);
-    const result = await this._channel.evalOnSelectorAll({ selector, expression: String(pageFunction), isFunction: typeof pageFunction === "function", arg: (0, import_jsHandle.serializeArgument)(arg) });
+  async $$eval(selector, pageFunction, arg, isolatedContext = true) {
+    (0, import_jsHandle.assertMaxArguments)(arguments.length, 4);
+    const result = await this._channel.evalOnSelectorAll({ selector, expression: String(pageFunction), isFunction: typeof pageFunction === "function", arg: (0, import_jsHandle.serializeArgument)(arg), isolatedContext });
     return (0, import_jsHandle.parseResult)(result.value);
   }
   async $$(selector) {

package/lib/client/jsHandle.js

@@ -36,16 +36,16 @@ class JSHandle extends import_channelOwner.ChannelOwner {
     this._preview = this._initializer.preview;
     this._channel.on("previewUpdated", ({ preview }) => this._preview = preview);
   }
-  async evaluate(pageFunction, arg) {
-    const result = await this._channel.evaluateExpression({ expression: String(pageFunction), isFunction: typeof pageFunction === "function", arg: serializeArgument(arg) });
+  async evaluate(pageFunction, arg, isolatedContext = true) {
+    const result = await this._channel.evaluateExpression({ expression: String(pageFunction), isFunction: typeof pageFunction === "function", arg: serializeArgument(arg), isolatedContext });
     return parseResult(result.value);
   }
   async _evaluateFunction(functionDeclaration) {
     const result = await this._channel.evaluateExpression({ expression: functionDeclaration, isFunction: true, arg: serializeArgument(void 0) });
     return parseResult(result.value);
   }
-  async evaluateHandle(pageFunction, arg) {
-    const result = await this._channel.evaluateExpressionHandle({ expression: String(pageFunction), isFunction: typeof pageFunction === "function", arg: serializeArgument(arg) });
+  async evaluateHandle(pageFunction, arg, isolatedContext = true) {
+    const result = await this._channel.evaluateExpressionHandle({ expression: String(pageFunction), isFunction: typeof pageFunction === "function", arg: serializeArgument(arg), isolatedContext });
     return JSHandle.from(result.handle);
   }
   async getProperty(propertyName) {

package/lib/client/locator.js

@@ -24,6 +24,7 @@ __export(locator_exports, {
   testIdAttributeName: () => testIdAttributeName
 });
 module.exports = __toCommonJS(locator_exports);
+var import_jsHandle = require("./jsHandle");
 var import_elementHandle = require("./elementHandle");
 var import_locatorGenerators = require("../utils/isomorphic/locatorGenerators");
 var import_locatorUtils = require("../utils/isomorphic/locatorUtils");
@@ -97,17 +98,37 @@ class Locator {
       ...options
     });
   }
-  async evaluate(pageFunction, arg, options) {
-    return await this._withElement((h) => h.evaluate(pageFunction, arg), { title: "Evaluate", timeout: options?.timeout });
+  async evaluate(pageFunction, arg, options, isolatedContext = true) {
+    return await this._withElement(
+      async (h) => (0, import_jsHandle.parseResult)(
+        (await h._channel.evaluateExpression({
+          expression: String(pageFunction),
+          isFunction: typeof pageFunction === "function",
+          arg: (0, import_jsHandle.serializeArgument)(arg),
+          isolatedContext
+        })).value
+      ),
+      { title: "Evaluate", timeout: options?.timeout }
+    );
   }
   async _evaluateFunction(functionDeclaration, options) {
     return await this._withElement((h) => h._evaluateFunction(functionDeclaration), { title: "Evaluate", timeout: options?.timeout });
   }
-  async evaluateAll(pageFunction, arg) {
-    return await this._frame.$$eval(this._selector, pageFunction, arg);
-  }
-  async evaluateHandle(pageFunction, arg, options) {
-    return await this._withElement((h) => h.evaluateHandle(pageFunction, arg), { title: "Evaluate", timeout: options?.timeout });
+  async evaluateAll(pageFunction, arg, isolatedContext = true) {
+    return await this._frame.$$eval(this._selector, pageFunction, arg, isolatedContext);
+  }
+  async evaluateHandle(pageFunction, arg, options, isolatedContext = true) {
+    return await this._withElement(
+      async (h) => import_jsHandle.JSHandle.from(
+        (await h._channel.evaluateExpressionHandle({
+          expression: String(pageFunction),
+          isFunction: typeof pageFunction === "function",
+          arg: (0, import_jsHandle.serializeArgument)(arg),
+          isolatedContext
+        })).handle
+      ),
+      { title: "Evaluate", timeout: options?.timeout }
+    );
   }
   async fill(value, options = {}) {
     return await this._frame.fill(this._selector, value, { strict: true, ...options });

package/lib/client/page.js

@@ -62,6 +62,7 @@ class Page extends import_channelOwner.ChannelOwner {
     this._closeWasCalled = false;
     this._harRouters = [];
     this._locatorHandlers = /* @__PURE__ */ new Map();
+    this.routeInjecting = false;
     this._browserContext = parent;
     this._timeoutSettings = new import_timeoutSettings.TimeoutSettings(this._platform, this._browserContext._timeoutSettings);
     this.keyboard = new import_input.Keyboard(this);
@@ -228,9 +229,9 @@ class Page extends import_channelOwner.ChannelOwner {
   async dispatchEvent(selector, type, eventInit, options) {
     return await this._mainFrame.dispatchEvent(selector, type, eventInit, options);
   }
-  async evaluateHandle(pageFunction, arg) {
-    (0, import_jsHandle.assertMaxArguments)(arguments.length, 2);
-    return await this._mainFrame.evaluateHandle(pageFunction, arg);
+  async evaluateHandle(pageFunction, arg, isolatedContext = true) {
+    (0, import_jsHandle.assertMaxArguments)(arguments.length, 3);
+    return await this._mainFrame.evaluateHandle(pageFunction, arg, isolatedContext);
   }
   async $eval(selector, pageFunction, arg) {
     (0, import_jsHandle.assertMaxArguments)(arguments.length, 3);
@@ -250,11 +251,13 @@ class Page extends import_channelOwner.ChannelOwner {
     return await this._mainFrame.addStyleTag(options);
   }
   async exposeFunction(name, callback) {
+    await this.installInjectRoute();
     await this._channel.exposeBinding({ name });
     const binding = (source, ...args) => callback(...args);
     this._bindings.set(name, binding);
   }
   async exposeBinding(name, callback, options = {}) {
+    await this.installInjectRoute();
     await this._channel.exposeBinding({ name, needsHandle: options.handle });
     this._bindings.set(name, callback);
   }
@@ -391,14 +394,15 @@ class Page extends import_channelOwner.ChannelOwner {
   viewportSize() {
     return this._viewportSize || null;
   }
-  async evaluate(pageFunction, arg) {
-    (0, import_jsHandle.assertMaxArguments)(arguments.length, 2);
-    return await this._mainFrame.evaluate(pageFunction, arg);
+  async evaluate(pageFunction, arg, isolatedContext = true) {
+    (0, import_jsHandle.assertMaxArguments)(arguments.length, 3);
+    return await this._mainFrame.evaluate(pageFunction, arg, isolatedContext);
   }
   async _evaluateFunction(functionDeclaration) {
     return this._mainFrame._evaluateFunction(functionDeclaration);
   }
   async addInitScript(script, arg) {
+    await this.installInjectRoute();
     const source = await (0, import_clientHelper.evaluationScript)(this._platform, script, arg);
     await this._channel.addInitScript({ source });
   }
@@ -676,6 +680,21 @@ class Page extends import_channelOwner.ChannelOwner {
   async _snapshotForAI(options = {}) {
     return await this._channel.snapshotForAI({ timeout: this._timeoutSettings.timeout(options), track: options.track });
   }
+  async installInjectRoute() {
+    if (this.routeInjecting || this.context().routeInjecting) return;
+    await this.route("**/*", async (route) => {
+      try {
+        if (route.request().resourceType() === "document" && route.request().url().startsWith("http")) {
+          const protocol = route.request().url().split(":")[0];
+          await route.fallback({ url: protocol + "://patchright-init-script-inject.internal/" });
+        } else {
+          await route.fallback();
+        }
+      } catch (error) {
+        await route.fallback();
+      }
+    });
+  }
 }
 class BindingCall extends import_channelOwner.ChannelOwner {
   static from(channel) {

package/lib/client/tracing.js

@@ -34,6 +34,7 @@ class Tracing extends import_channelOwner.ChannelOwner {
     return channel._object;
   }
   async start(options = {}) {
+    await this._parent.installInjectRoute();
     await this._wrapApiCall(async () => {
       this._includeSources = !!options.sources;
       this._isLive = !!options._live;

package/lib/client/worker.js

@@ -54,14 +54,14 @@ class Worker extends import_channelOwner.ChannelOwner {
   url() {
     return this._initializer.url;
   }
-  async evaluate(pageFunction, arg) {
-    (0, import_jsHandle.assertMaxArguments)(arguments.length, 2);
-    const result = await this._channel.evaluateExpression({ expression: String(pageFunction), isFunction: typeof pageFunction === "function", arg: (0, import_jsHandle.serializeArgument)(arg) });
+  async evaluate(pageFunction, arg, isolatedContext = true) {
+    (0, import_jsHandle.assertMaxArguments)(arguments.length, 3);
+    const result = await this._channel.evaluateExpression({ expression: String(pageFunction), isFunction: typeof pageFunction === "function", arg: (0, import_jsHandle.serializeArgument)(arg), isolatedContext });
     return (0, import_jsHandle.parseResult)(result.value);
   }
-  async evaluateHandle(pageFunction, arg) {
-    (0, import_jsHandle.assertMaxArguments)(arguments.length, 2);
-    const result = await this._channel.evaluateExpressionHandle({ expression: String(pageFunction), isFunction: typeof pageFunction === "function", arg: (0, import_jsHandle.serializeArgument)(arg) });
+  async evaluateHandle(pageFunction, arg, isolatedContext = true) {
+    (0, import_jsHandle.assertMaxArguments)(arguments.length, 3);
+    const result = await this._channel.evaluateExpressionHandle({ expression: String(pageFunction), isFunction: typeof pageFunction === "function", arg: (0, import_jsHandle.serializeArgument)(arg), isolatedContext });
     return import_jsHandle.JSHandle.from(result.handle);
   }
   async waitForEvent(event, optionsOrPredicate = {}) {