phantomwright-driver-core 1.57.0 → 1.57.1

package/lib/server/javascript.js

@@ -113,14 +113,30 @@ class JSHandle extends import_instrumentation.SdkObject {
   async evaluateHandle(pageFunction, arg) {
     return evaluate(this._context, false, pageFunction, this, arg);
   }
-  async evaluateExpression(expression, options, arg) {
-    const value = await evaluateExpression(this._context, expression, { ...options, returnByValue: true }, this, arg);
-    await this._context.doSlowMo();
+  async evaluateExpression(expression, options, arg, isolatedContext) {
+    let context = this._context;
+    if (context.constructor.name === "FrameExecutionContext") {
+      const frame = context.frame;
+      if (frame) {
+        if (isolatedContext === true) context = await frame._utilityContext();
+        else if (isolatedContext === false) context = await frame._mainContext();
+      }
+    }
+    const value = await evaluateExpression(context, expression, { ...options, returnByValue: true }, this, arg);
+    await context.doSlowMo();
     return value;
   }
-  async evaluateExpressionHandle(expression, options, arg) {
-    const value = await evaluateExpression(this._context, expression, { ...options, returnByValue: false }, this, arg);
-    await this._context.doSlowMo();
+  async evaluateExpressionHandle(expression, options, arg, isolatedContext) {
+    let context = this._context;
+    if (context.constructor.name === "FrameExecutionContext") {
+      const frame = this._context.frame;
+      if (frame) {
+        if (isolatedContext === true) context = await frame._utilityContext();
+        else if (isolatedContext === false) context = await frame._mainContext();
+      }
+    }
+    const value = await evaluateExpression(context, expression, { ...options, returnByValue: false }, this, arg);
+    await context.doSlowMo();
     return value;
   }
   async getProperty(propertyName) {

package/lib/server/page.js

@@ -34,6 +34,7 @@ __export(page_exports, {
   Worker: () => Worker
 });
 module.exports = __toCommonJS(page_exports);
+var import_pageBinding = require("./pageBinding");
 var import_browserContext = require("./browserContext");
 var import_console = require("./console");
 var import_errors = require("./errors");
@@ -52,7 +53,6 @@ var import_selectorParser = require("../utils/isomorphic/selectorParser");
 var import_manualPromise = require("../utils/isomorphic/manualPromise");
 var import_utilityScriptSerializers = require("../utils/isomorphic/utilityScriptSerializers");
 var import_callLog = require("./callLog");
-var rawBindingsControllerSource = __toESM(require("../generated/bindingsControllerSource"));
 class Page extends import_instrumentation.SdkObject {
   constructor(delegate, browserContext) {
     super(browserContext, "page");
@@ -202,26 +202,16 @@ class Page extends import_instrumentation.SdkObject {
       throw new Error(`Function "${name}" has been already registered`);
     if (this.browserContext._pageBindings.has(name))
       throw new Error(`Function "${name}" has been already registered in the browser context`);
-    await progress.race(this.browserContext.exposePlaywrightBindingIfNeeded());
     const binding = new PageBinding(name, playwrightBinding, needsHandle);
     this._pageBindings.set(name, binding);
-    try {
-      await progress.race(this.delegate.addInitScript(binding.initScript));
-      await progress.race(this.safeNonStallingEvaluateInAllFrames(binding.initScript.source, "main"));
-      return binding;
-    } catch (error) {
-      this._pageBindings.delete(name);
-      throw error;
-    }
+    await this.delegate.exposeBinding(binding);
   }
   async removeExposedBindings(bindings) {
-    bindings = bindings.filter((binding) => this._pageBindings.get(binding.name) === binding);
-    for (const binding of bindings)
-      this._pageBindings.delete(binding.name);
-    await this.delegate.removeInitScripts(bindings.map((binding) => binding.initScript));
-    const cleanup = bindings.map((binding) => `{ ${binding.cleanupScript} };
-`).join("");
-    await this.safeNonStallingEvaluateInAllFrames(cleanup, "main");
+    for (const key of this._pageBindings.keys()) {
+      if (!key.startsWith("__pw"))
+        this._pageBindings.delete(key);
+    }
+    await this.delegate.removeExposedBindings();
   }
   async setExtraHTTPHeaders(progress, headers) {
     const oldHeaders = this._extraHTTPHeaders;
@@ -462,9 +452,8 @@ class Page extends import_instrumentation.SdkObject {
     return initScript;
   }
   async removeInitScripts(initScripts) {
-    const set = new Set(initScripts);
-    this.initScripts = this.initScripts.filter((script) => !set.has(script));
-    await this.delegate.removeInitScripts(initScripts);
+    this.initScripts.splice(0, this.initScripts.length);
+    await this.delegate.removeInitScripts();
   }
   needsRequestInterception() {
     return this.requestInterceptors.length > 0 || this.browserContext.requestInterceptors.length > 0;
@@ -632,12 +621,6 @@ class Page extends import_instrumentation.SdkObject {
     if (origin)
       this.browserContext.addVisitedOrigin(origin);
   }
-  allInitScripts() {
-    const bindings = [...this.browserContext._pageBindings.values(), ...this._pageBindings.values()].map((binding) => binding.initScript);
-    if (this.browserContext.bindingsInitScript)
-      bindings.unshift(this.browserContext.bindingsInitScript);
-    return [...bindings, ...this.browserContext.initScripts, ...this.initScripts];
-  }
   getBinding(name) {
     return this._pageBindings.get(name) || this.browserContext._pageBindings.get(name);
   }
@@ -669,6 +652,9 @@ class Page extends import_instrumentation.SdkObject {
     const snapshot = await snapshotFrameForAI(progress, this.mainFrame(), options);
     return { full: snapshot.full.join("\n"), incremental: snapshot.incremental?.join("\n") };
   }
+  allBindings() {
+    return [...this.browserContext._pageBindings.values(), ...this._pageBindings.values()];
+  }
 }
 class Worker extends import_instrumentation.SdkObject {
   constructor(parent, url) {
@@ -701,37 +687,35 @@ class Worker extends import_instrumentation.SdkObject {
     this.emit(Worker.Events.Close, this);
     this.openScope.close(new Error("Worker closed"));
   }
-  async evaluateExpression(expression, isFunction, arg) {
-    return js.evaluateExpression(await this._executionContextPromise, expression, { returnByValue: true, isFunction }, arg);
-  }
-  async evaluateExpressionHandle(expression, isFunction, arg) {
-    return js.evaluateExpression(await this._executionContextPromise, expression, { returnByValue: false, isFunction }, arg);
+  async evaluateExpression(expression, isFunction, arg, isolatedContext) {
+    let context = await this._executionContextPromise;
+    if (context.constructor.name === "FrameExecutionContext") {
+      const frame = context.frame;
+      if (frame) {
+        if (isolatedContext) context = await frame._utilityContext();
+        else if (!isolatedContext) context = await frame._mainContext();
+      }
+    }
+    return js.evaluateExpression(context, expression, { returnByValue: true, isFunction }, arg);
+  }
+  async evaluateExpressionHandle(expression, isFunction, arg, isolatedContext) {
+    let context = await this._executionContextPromise;
+    if (context.constructor.name === "FrameExecutionContext") {
+      const frame = this._context.frame;
+      if (frame) {
+        if (isolatedContext) context = await frame._utilityContext();
+        else if (!isolatedContext) context = await frame._mainContext();
+      }
+    }
+    return js.evaluateExpression(context, expression, { returnByValue: false, isFunction }, arg);
   }
 }
 class PageBinding {
-  static {
-    this.kController = "__playwright__binding__controller__";
-  }
-  static {
-    this.kBindingName = "__playwright__binding__";
-  }
-  static createInitScript() {
-    return new InitScript(`
-      (() => {
-        const module = {};
-        ${rawBindingsControllerSource.source}
-        const property = '${PageBinding.kController}';
-        if (!globalThis[property])
-          globalThis[property] = new (module.exports.BindingsController())(globalThis, '${PageBinding.kBindingName}');
-      })();
-    `);
-  }
   constructor(name, playwrightFunction, needsHandle) {
     this.name = name;
     this.playwrightFunction = playwrightFunction;
-    this.initScript = new InitScript(`globalThis['${PageBinding.kController}'].addBinding(${JSON.stringify(name)}, ${needsHandle})`);
+    this.source = (0, import_pageBinding.createPageBindingScript)(name, needsHandle);
     this.needsHandle = needsHandle;
-    this.cleanupScript = `globalThis['${PageBinding.kController}'].removeBinding(${JSON.stringify(name)})`;
   }
   static async dispatch(page, payload, context) {
     const { name, seq, serializedArgs } = JSON.parse(payload);
@@ -742,25 +726,23 @@ class PageBinding {
         throw new Error(`Function "${name}" is not exposed`);
       let result;
       if (binding.needsHandle) {
-        const handle = await context.evaluateExpressionHandle(`arg => globalThis['${PageBinding.kController}'].takeBindingHandle(arg)`, { isFunction: true }, { name, seq }).catch((e) => null);
-        result = await binding.playwrightFunction({ frame: context.frame, page, context: page.browserContext }, handle);
+        const handle = await context.evaluateHandle(import_pageBinding.takeBindingHandle, { name, seq }).catch((e) => null);
+        result = await binding.playwrightFunction({ frame: context.frame, page, context: page._browserContext }, handle);
       } else {
         if (!Array.isArray(serializedArgs))
           throw new Error(`serializedArgs is not an array. This can happen when Array.prototype.toJSON is defined incorrectly`);
         const args = serializedArgs.map((a) => (0, import_utilityScriptSerializers.parseEvaluationResultValue)(a));
-        result = await binding.playwrightFunction({ frame: context.frame, page, context: page.browserContext }, ...args);
+        result = await binding.playwrightFunction({ frame: context.frame, page, context: page._browserContext }, ...args);
       }
-      context.evaluateExpressionHandle(`arg => globalThis['${PageBinding.kController}'].deliverBindingResult(arg)`, { isFunction: true }, { name, seq, result }).catch((e) => import_debugLogger.debugLogger.log("error", e));
+      context.evaluate(import_pageBinding.deliverBindingResult, { name, seq, result }).catch((e) => import_debugLogger.debugLogger.log("error", e));
     } catch (error) {
-      context.evaluateExpressionHandle(`arg => globalThis['${PageBinding.kController}'].deliverBindingResult(arg)`, { isFunction: true }, { name, seq, error }).catch((e) => import_debugLogger.debugLogger.log("error", e));
+      context.evaluate(import_pageBinding.deliverBindingResult, { name, seq, error }).catch((e) => import_debugLogger.debugLogger.log("error", e));
     }
   }
 }
 class InitScript {
   constructor(source) {
-    this.source = `(() => {
-      ${source}
-    })();`;
+    this.source = `(() => { ${source} })();`;
   }
 }
 class FrameThrottler {

package/lib/server/pageBinding.js

@@ -0,0 +1,87 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var pageBinding_exports = {};
+__export(pageBinding_exports, {
+  createPageBindingScript: () => createPageBindingScript,
+  deliverBindingResult: () => deliverBindingResult,
+  takeBindingHandle: () => takeBindingHandle
+});
+module.exports = __toCommonJS(pageBinding_exports);
+var import_oldUtilityScriptSerializers = require("../utils/isomorphic/oldUtilityScriptSerializers");
+function addPageBinding(bindingName, needsHandle, utilityScriptSerializersFactory) {
+  const { serializeAsCallArgument } = utilityScriptSerializersFactory;
+  const binding = globalThis[bindingName];
+  if (!binding || binding.toString().startsWith("(...args) => {")) return;
+  globalThis[bindingName] = (...args) => {
+    const me = globalThis[bindingName];
+    if (needsHandle && args.slice(1).some((arg) => arg !== void 0))
+      throw new Error(`exposeBindingHandle supports a single argument, ${args.length} received`);
+    let callbacks = me["callbacks"];
+    if (!callbacks) {
+      callbacks = /* @__PURE__ */ new Map();
+      me["callbacks"] = callbacks;
+    }
+    const seq = (me["lastSeq"] || 0) + 1;
+    me["lastSeq"] = seq;
+    let handles = me["handles"];
+    if (!handles) {
+      handles = /* @__PURE__ */ new Map();
+      me["handles"] = handles;
+    }
+    const promise = new Promise((resolve, reject) => callbacks.set(seq, { resolve, reject }));
+    let payload;
+    if (needsHandle) {
+      handles.set(seq, args[0]);
+      payload = { name: bindingName, seq };
+    } else {
+      const serializedArgs = [];
+      for (let i = 0; i < args.length; i++) {
+        serializedArgs[i] = serializeAsCallArgument(args[i], (v) => {
+          return { fallThrough: v };
+        });
+      }
+      payload = { name: bindingName, seq, serializedArgs };
+    }
+    binding(JSON.stringify(payload));
+    return promise;
+  };
+}
+function takeBindingHandle(arg) {
+  const handles = globalThis[arg.name]["handles"];
+  const handle = handles.get(arg.seq);
+  handles.delete(arg.seq);
+  return handle;
+}
+function deliverBindingResult(arg) {
+  const callbacks = globalThis[arg.name]["callbacks"];
+  if ("error" in arg)
+    callbacks.get(arg.seq).reject(arg.error);
+  else
+    callbacks.get(arg.seq).resolve(arg.result);
+  callbacks.delete(arg.seq);
+}
+function createPageBindingScript(name, needsHandle) {
+  return `(${addPageBinding.toString()})(${JSON.stringify(name)}, ${needsHandle}, (${import_oldUtilityScriptSerializers.source})())`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createPageBindingScript,
+  deliverBindingResult,
+  takeBindingHandle
+});

package/lib/server/registry/index.js

@@ -1331,7 +1331,7 @@ function buildPlaywrightCLICommand(sdkLanguage, parameters) {
       return `pwsh bin/Debug/netX/playwright.ps1 ${parameters}`;
     default: {
       const packageManagerCommand = (0, import_utils.getPackageManagerExecCommand)();
-      return `${packageManagerCommand} playwright ${parameters}`;
+      return `${packageManagerCommand} patchright ${parameters}`;
     }
   }
 }

package/lib/utils/isomorphic/oldUtilityScriptSerializers.js

@@ -0,0 +1,248 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var oldUtilityScriptSerializers_exports = {};
+__export(oldUtilityScriptSerializers_exports, {
+  source: () => source
+});
+module.exports = __toCommonJS(oldUtilityScriptSerializers_exports);
+function source() {
+  function isRegExp(obj) {
+    try {
+      return obj instanceof RegExp || Object.prototype.toString.call(obj) === "[object RegExp]";
+    } catch (error) {
+      return false;
+    }
+  }
+  function isDate(obj) {
+    try {
+      return obj instanceof Date || Object.prototype.toString.call(obj) === "[object Date]";
+    } catch (error) {
+      return false;
+    }
+  }
+  function isURL(obj) {
+    try {
+      return obj instanceof URL || Object.prototype.toString.call(obj) === "[object URL]";
+    } catch (error) {
+      return false;
+    }
+  }
+  function isError(obj) {
+    try {
+      return obj instanceof Error || obj && Object.getPrototypeOf(obj)?.name === "Error";
+    } catch (error) {
+      return false;
+    }
+  }
+  function isTypedArray(obj, constructor) {
+    try {
+      return obj instanceof constructor || Object.prototype.toString.call(obj) === `[object ${constructor.name}]`;
+    } catch (error) {
+      return false;
+    }
+  }
+  const typedArrayConstructors = {
+    i8: Int8Array,
+    ui8: Uint8Array,
+    ui8c: Uint8ClampedArray,
+    i16: Int16Array,
+    ui16: Uint16Array,
+    i32: Int32Array,
+    ui32: Uint32Array,
+    // TODO: add Float16Array once it's in baseline
+    f32: Float32Array,
+    f64: Float64Array,
+    bi64: BigInt64Array,
+    bui64: BigUint64Array
+  };
+  function typedArrayToBase64(array) {
+    if ("toBase64" in array)
+      return array.toBase64();
+    const binary = Array.from(new Uint8Array(array.buffer, array.byteOffset, array.byteLength)).map((b) => String.fromCharCode(b)).join("");
+    return btoa(binary);
+  }
+  function base64ToTypedArray(base64, TypedArrayConstructor) {
+    const binary = atob(base64);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++)
+      bytes[i] = binary.charCodeAt(i);
+    return new TypedArrayConstructor(bytes.buffer);
+  }
+  function parseEvaluationResultValue(value, handles = [], refs = /* @__PURE__ */ new Map()) {
+    if (Object.is(value, void 0))
+      return void 0;
+    if (typeof value === "object" && value) {
+      if ("ref" in value)
+        return refs.get(value.ref);
+      if ("v" in value) {
+        if (value.v === "undefined")
+          return void 0;
+        if (value.v === "null")
+          return null;
+        if (value.v === "NaN")
+          return NaN;
+        if (value.v === "Infinity")
+          return Infinity;
+        if (value.v === "-Infinity")
+          return -Infinity;
+        if (value.v === "-0")
+          return -0;
+        return void 0;
+      }
+      if ("d" in value)
+        return new Date(value.d);
+      if ("u" in value)
+        return new URL(value.u);
+      if ("bi" in value)
+        return BigInt(value.bi);
+      if ("e" in value) {
+        const error = new Error(value.e.m);
+        error.name = value.e.n;
+        error.stack = value.e.s;
+        return error;
+      }
+      if ("r" in value)
+        return new RegExp(value.r.p, value.r.f);
+      if ("a" in value) {
+        const result = [];
+        refs.set(value.id, result);
+        for (const a of value.a)
+          result.push(parseEvaluationResultValue(a, handles, refs));
+        return result;
+      }
+      if ("o" in value) {
+        const result = {};
+        refs.set(value.id, result);
+        for (const { k, v } of value.o)
+          result[k] = parseEvaluationResultValue(v, handles, refs);
+        return result;
+      }
+      if ("h" in value)
+        return handles[value.h];
+      if ("ta" in value)
+        return base64ToTypedArray(value.ta.b, typedArrayConstructors[value.ta.k]);
+    }
+    return value;
+  }
+  function serializeAsCallArgument(value, handleSerializer) {
+    return serialize(value, handleSerializer, { visited: /* @__PURE__ */ new Map(), lastId: 0 });
+  }
+  function serialize(value, handleSerializer, visitorInfo) {
+    if (value && typeof value === "object") {
+      if (typeof globalThis.Window === "function" && value instanceof globalThis.Window)
+        return "ref: <Window>";
+      if (typeof globalThis.Document === "function" && value instanceof globalThis.Document)
+        return "ref: <Document>";
+      if (typeof globalThis.Node === "function" && value instanceof globalThis.Node)
+        return "ref: <Node>";
+    }
+    return innerSerialize(value, handleSerializer, visitorInfo);
+  }
+  function innerSerialize(value, handleSerializer, visitorInfo) {
+    const result = handleSerializer(value);
+    if ("fallThrough" in result)
+      value = result.fallThrough;
+    else
+      return result;
+    if (typeof value === "symbol")
+      return { v: "undefined" };
+    if (Object.is(value, void 0))
+      return { v: "undefined" };
+    if (Object.is(value, null))
+      return { v: "null" };
+    if (Object.is(value, NaN))
+      return { v: "NaN" };
+    if (Object.is(value, Infinity))
+      return { v: "Infinity" };
+    if (Object.is(value, -Infinity))
+      return { v: "-Infinity" };
+    if (Object.is(value, -0))
+      return { v: "-0" };
+    if (typeof value === "boolean")
+      return value;
+    if (typeof value === "number")
+      return value;
+    if (typeof value === "string")
+      return value;
+    if (typeof value === "bigint")
+      return { bi: value.toString() };
+    if (isError(value)) {
+      let stack;
+      if (value.stack?.startsWith(value.name + ": " + value.message)) {
+        stack = value.stack;
+      } else {
+        stack = `${value.name}: ${value.message}
+${value.stack}`;
+      }
+      return { e: { n: value.name, m: value.message, s: stack } };
+    }
+    if (isDate(value))
+      return { d: value.toJSON() };
+    if (isURL(value))
+      return { u: value.toJSON() };
+    if (isRegExp(value))
+      return { r: { p: value.source, f: value.flags } };
+    for (const [k, ctor] of Object.entries(typedArrayConstructors)) {
+      if (isTypedArray(value, ctor))
+        return { ta: { b: typedArrayToBase64(value), k } };
+    }
+    const id = visitorInfo.visited.get(value);
+    if (id)
+      return { ref: id };
+    if (Array.isArray(value)) {
+      const a = [];
+      const id2 = ++visitorInfo.lastId;
+      visitorInfo.visited.set(value, id2);
+      for (let i = 0; i < value.length; ++i)
+        a.push(serialize(value[i], handleSerializer, visitorInfo));
+      return { a, id: id2 };
+    }
+    if (typeof value === "object") {
+      const o = [];
+      const id2 = ++visitorInfo.lastId;
+      visitorInfo.visited.set(value, id2);
+      for (const name of Object.keys(value)) {
+        let item;
+        try {
+          item = value[name];
+        } catch (e) {
+          continue;
+        }
+        if (name === "toJSON" && typeof item === "function")
+          o.push({ k: name, v: { o: [], id: 0 } });
+        else
+          o.push({ k: name, v: serialize(item, handleSerializer, visitorInfo) });
+      }
+      let jsonWrapper;
+      try {
+        if (o.length === 0 && value.toJSON && typeof value.toJSON === "function")
+          jsonWrapper = { value: value.toJSON() };
+      } catch (e) {
+      }
+      if (jsonWrapper)
+        return innerSerialize(jsonWrapper.value, handleSerializer, visitorInfo);
+      return { o, id: id2 };
+    }
+  }
+  return { parseEvaluationResultValue, serializeAsCallArgument };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  source
+});