Playwright is a framework for Web Testing and Automation. It allows testing Chromium, Firefox and WebKit with a single API.
TypeScript automationchromechromiume2e-testingelectronend-to-end-testingfirefoxjavascriptplaywrighttesttest-automationtestingtesting-toolswebwebkit
feat(evaluate): opt in to Map and Set serialization (#42709)
Yury Semikhatsky118ee4407c4e
diff --git a/docs/src/api/class-frame.md b/docs/src/api/class-frame.mdindex e5ec33f0c1..791640f1b8 100644--- a/docs/src/api/class-frame.md+++ b/docs/src/api/class-frame.md@@ -754,6 +754,9 @@ Optional argument to pass to [`param: expression`].### option: Frame.evaluate.exposeFunctions = %%-js-evaluate-expose-functions-%%* since: v1.62+### option: Frame.evaluate.serialize = %%-js-evaluate-serialize-%%+* since: v1.64+### option: Frame.evaluate.world = %%-js-evaluate-world-%%* since: v1.64@@ -872,6 +875,9 @@ Optional argument to pass to [`param: expression`].### option: Frame.evaluateHandle.exposeFunctions = %%-js-evaluate-expose-functions-%%* since: v1.62+### option: Frame.evaluateHandle.serialize = %%-js-evaluate-serialize-%%+* since: v1.64+## async method: Frame.fill* since: v1.8* discouraged: Use locator-based [`method: Locator.fill`] instead. Read more about [locators](../locators.md).diff --git a/docs/src/api/class-jshandle.md b/docs/src/api/class-jshandle.mdindex 5a883bf889..9910841d11 100644--- a/docs/src/api/class-jshandle.md+++ b/docs/src/api/class-jshandle.md@@ -99,6 +99,9 @@ Optional argument to pass to [`param: expression`].### option: JSHandle.evaluate.exposeFunctions = %%-js-evaluate-expose-functions-%%* since: v1.62+### option: JSHandle.evaluate.serialize = %%-js-evaluate-serialize-%%+* since: v1.64+## async method: JSHandle.evaluateHandle* since: v1.8- returns: <[JSHandle]>@@ -129,6 +132,9 @@ Optional argument to pass to [`param: expression`].### option: JSHandle.evaluateHandle.exposeFunctions = %%-js-evaluate-expose-functions-%%* since: v1.62+### option: JSHandle.evaluateHandle.serialize = %%-js-evaluate-serialize-%%+* since: v1.64+## async method: JSHandle.getProperties* since: v1.8- returns: <[Map]<[string], [JSHandle]>>diff --git a/docs/src/api/class-locator.md b/docs/src/api/class-locator.mdindex 945cc8884c..cf6ac55c65 100644--- a/docs/src/api/class-locator.md+++ b/docs/src/api/class-locator.md@@ -1181,6 +1181,9 @@ Optional argument to pass to [`param: expression`].### option: Locator.evaluate.exposeFunctions = %%-js-evaluate-expose-functions-%%* since: v1.62+### option: Locator.evaluate.serialize = %%-js-evaluate-serialize-%%+* since: v1.64+### option: Locator.evaluate.world = %%-js-evaluate-world-%%* since: v1.64@@ -1289,6 +1292,9 @@ Optional argument to pass to [`param: expression`].### option: Locator.evaluateHandle.exposeFunctions = %%-js-evaluate-expose-functions-%%* since: v1.62+### option: Locator.evaluateHandle.serialize = %%-js-evaluate-serialize-%%+* since: v1.64+### option: Locator.evaluateHandle.timeout* since: v1.14* langs: python, java, csharpdiff --git a/docs/src/api/class-page.md b/docs/src/api/class-page.mdindex 5466537a8c..750f8efc87 100644--- a/docs/src/api/class-page.md+++ b/docs/src/api/class-page.md@@ -1605,6 +1605,9 @@ Optional argument to pass to [`param: expression`].### option: Page.evaluate.exposeFunctions = %%-js-evaluate-expose-functions-%%* since: v1.62+### option: Page.evaluate.serialize = %%-js-evaluate-serialize-%%+* since: v1.64+### option: Page.evaluate.world = %%-js-evaluate-world-%%* since: v1.64@@ -1720,6 +1723,9 @@ Optional argument to pass to [`param: expression`].### option: Page.evaluateHandle.exposeFunctions = %%-js-evaluate-expose-functions-%%* since: v1.62+### option: Page.evaluateHandle.serialize = %%-js-evaluate-serialize-%%+* since: v1.64+## async method: Page.exposeBinding* since: v1.8- returns: <[Disposable]>diff --git a/docs/src/api/params.md b/docs/src/api/params.mdindex e5f02b313a..8cb88d79eb 100644--- a/docs/src/api/params.md+++ b/docs/src/api/params.md@@ -584,6 +584,12 @@ to a function, the function is automatically invoked.Function to be evaluated in the page context.+## js-evaluate-serialize+* langs: js+- `serialize` <[Array]<[SerializationType]<"Map"|"Set">>>++Additional built-in types to preserve in the evaluation argument and return value, including nested collections and circular references. Supports `"Map"` and `"Set"`. For example, `serialize: ['Map', 'Set']` preserves both [Map] and [Set] instances. Defaults to an empty array, in which case these types are serialized as plain objects.+## js-evaluate-expose-functions* langs: js- `exposeFunctions` <[boolean]>diff --git a/packages/injected/src/storageScript.ts b/packages/injected/src/storageScript.tsindex efb3054cef..6f917aa268 100644--- a/packages/injected/src/storageScript.ts+++ b/packages/injected/src/storageScript.ts@@ -78,7 +78,7 @@ export class StorageScript {trivial = false;return { fallThrough: v };- }, { extendedSerialization: true });+ }, { serialize: ['Map', 'Set'] });if (trivial)return { trivial: value };return { encoded };diff --git a/packages/injected/src/utilityScript.ts b/packages/injected/src/utilityScript.tsindex 5c54d9ed98..e4cfe21b7b 100644--- a/packages/injected/src/utilityScript.ts+++ b/packages/injected/src/utilityScript.ts@@ -63,7 +63,7 @@ export class UtilityScript {(global as any).builtins = this.builtins;}- evaluate(isFunction: boolean | undefined, returnByValue: boolean, expression: string, argCount: number, ...argsAndHandles: any[]) {+ evaluate(isFunction: boolean | undefined, returnByValue: boolean, serialize: ('Map' | 'Set')[] | undefined, expression: string, argCount: number, ...argsAndHandles: any[]) {const args = argsAndHandles.slice(0, argCount);const handles = argsAndHandles.slice(argCount);const parameters = [];@@ -80,20 +80,20 @@ export class UtilityScript {if (typeof result === 'function')result = result(...parameters);}- return returnByValue ? this._promiseAwareJsonValueNoThrow(result) : result;+ return returnByValue ? this._promiseAwareJsonValueNoThrow(result, serialize) : result;}- jsonValue(returnByValue: true, value: any) {+ jsonValue(returnByValue: true, value: any, serialize?: ('Map' | 'Set')[]) {// Special handling of undefined to work-around multi-step returnByValue handling in WebKit.if (value === undefined)return undefined;- return serializeAsCallArgument(value, (value: any) => ({ fallThrough: value }));+ return serializeAsCallArgument(value, (value: any) => ({ fallThrough: value }), { serialize });}- private _promiseAwareJsonValueNoThrow(value: any) {+ private _promiseAwareJsonValueNoThrow(value: any, serialize?: ('Map' | 'Set')[]) {const safeJson = (value: any) => {try {- return this.jsonValue(true, value);+ return this.jsonValue(true, value, serialize);} catch (e) {return undefined;}diff --git a/packages/isomorphic/utilityScriptSerializers.ts b/packages/isomorphic/utilityScriptSerializers.tsindex 7132bc8626..6027e77e1f 100644--- a/packages/isomorphic/utilityScriptSerializers.ts+++ b/packages/isomorphic/utilityScriptSerializers.ts@@ -46,7 +46,7 @@ type HandleOrValue = { h: number } | { fn: string } | { fallThrough: any };type VisitorInfo = {visited: Map<object, number>;lastId: number;- extendedSerialization?: boolean;+ serialize?: ('Map' | 'Set')[];};function isRegExp(obj: any): obj is RegExp {@@ -231,8 +231,8 @@ export function parseEvaluationResultValue(value: SerializedValue, handles: any[return value;}-export function serializeAsCallArgument(value: any, handleSerializer: (value: any) => HandleOrValue, options: { extendedSerialization?: boolean } = {}): SerializedValue {- return serialize(value, handleSerializer, { visited: new Map(), lastId: 0, extendedSerialization: options.extendedSerialization });+export function serializeAsCallArgument(value: any, handleSerializer: (value: any) => HandleOrValue, options: { serialize?: ('Map' | 'Set')[] } = {}): SerializedValue {+ return serialize(value, handleSerializer, { visited: new Map(), lastId: 0, serialize: options.serialize });}function serialize(value: any, handleSerializer: (value: any) => HandleOrValue, visitorInfo: VisitorInfo): SerializedValue {@@ -308,35 +308,33 @@ function innerSerialize(value: any, handleSerializer: (value: any) => HandleOrVaif (id)return { ref: id };- if (visitorInfo.extendedSerialization) {- if (isMap(value)) {- const m: { k: SerializedValue, v: SerializedValue }[] = [];- const id = ++visitorInfo.lastId;- visitorInfo.visited.set(value, id);- const iterator = value.entries();- const next = new Map().entries().next;- while (true) {- const entry = next.call(iterator);- if (entry.done)- break;- m.push({ k: serialize(entry.value[0], handleSerializer, visitorInfo), v: serialize(entry.value[1], handleSerializer, visitorInfo) });- }- return { m, id };+ if (visitorInfo.serialize?.includes('Map') && isMap(value)) {+ const m: { k: SerializedValue, v: SerializedValue }[] = [];+ const id = ++visitorInfo.lastId;+ visitorInfo.visited.set(value, id);+ const iterator = value.entries();+ const next = new Map().entries().next;+ while (true) {+ const entry = next.call(iterator);+ if (entry.done)+ break;+ m.push({ k: serialize(entry.value[0], handleSerializer, visitorInfo), v: serialize(entry.value[1], handleSerializer, visitorInfo) });}- if (isSet(value)) {- const s: SerializedValue[] = [];- const id = ++visitorInfo.lastId;- visitorInfo.visited.set(value, id);- const iterator = value.values();- const next = new Set().values().next;- while (true) {- const entry = next.call(iterator);- if (entry.done)- break;- s.push(serialize(entry.value, handleSerializer, visitorInfo));- }- return { s, id };+ return { m, id };+ }+ if (visitorInfo.serialize?.includes('Set') && isSet(value)) {+ const s: SerializedValue[] = [];+ const id = ++visitorInfo.lastId;+ visitorInfo.visited.set(value, id);+ const iterator = value.values();+ const next = new Set().values().next;+ while (true) {+ const entry = next.call(iterator);+ if (entry.done)+ break;+ s.push(serialize(entry.value, handleSerializer, visitorInfo));}+ return { s, id };}if (Array.isArray(value)) {diff --git a/packages/playwright-client/types/types.d.ts b/packages/playwright-client/types/types.d.tsindex 5fcd6b1c96..16a448b39f 100644--- a/packages/playwright-client/types/types.d.ts+++ b/packages/playwright-client/types/types.d.ts@@ -134,7 +134,7 @@ export interface Page {* [`pageFunction`](https://playwright.dev/docs/api/class-page#page-evaluate-option-expression).* @param options*/- evaluate<R, Arg>(pageFunction: PageFunction<Arg, R>, arg: Arg, options?: { exposeFunctions?: boolean, world?: 'main'|'utility' }): Promise<R>;+ evaluate<R, Arg>(pageFunction: PageFunction<Arg, R>, arg: Arg, options?: { exposeFunctions?: boolean, serialize?: ('Map'|'Set')[], world?: 'main'|'utility' }): Promise<R>;/*** Returns the value of the* [`pageFunction`](https://playwright.dev/docs/api/class-page#page-evaluate-option-expression) invocation.@@ -187,7 +187,7 @@ export interface Page {* [`pageFunction`](https://playwright.dev/docs/api/class-page#page-evaluate-option-expression).* @param options*/- evaluate<R>(pageFunction: PageFunction<void, R>, arg?: any, options?: { exposeFunctions?: boolean, world?: 'main'|'utility' }): Promise<R>;+ evaluate<R>(pageFunction: PageFunction<void, R>, arg?: any, options?: { exposeFunctions?: boolean, serialize?: ('Map'|'Set')[], world?: 'main'|'utility' }): Promise<R>;/*** Returns the value of the@@ -235,7 +235,7 @@ export interface Page {* [`pageFunction`](https://playwright.dev/docs/api/class-page#page-evaluate-handle-option-expression).* @param options*/- evaluateHandle<R, Arg>(pageFunction: PageFunction<Arg, R>, arg: Arg, options?: { exposeFunctions?: boolean }): Promise<SmartHandle<R>>;+ evaluateHandle<R, Arg>(pageFunction: PageFunction<Arg, R>, arg: Arg, options?: { exposeFunctions?: boolean, serialize?: ('Map'|'Set')[] }): Promise<SmartHandle<R>>;/*** Returns the value of the* [`pageFunction`](https://playwright.dev/docs/api/class-page#page-evaluate-handle-option-expression) invocation as a@@ -282,7 +282,7 @@ export interface Page {* [`pageFunction`](https://playwright.dev/docs/api/class-page#page-evaluate-handle-option-expression).* @param options*/- evaluateHandle<R>(pageFunction: PageFunction<void, R>, arg?: any, options?: { exposeFunctions?: boolean }): Promise<SmartHandle<R>>;+ evaluateHandle<R>(pageFunction: PageFunction<void, R>, arg?: any, options?: { exposeFunctions?: boolean, serialize?: ('Map'|'Set')[] }): Promise<SmartHandle<R>>;/*** Adds a script which would be evaluated in one of the following scenarios:@@ -5963,7 +5963,7 @@ export interface Frame {* [`pageFunction`](https://playwright.dev/docs/api/class-frame#frame-evaluate-option-expression).* @param options*/- evaluate<R, Arg>(pageFunction: PageFunction<Arg, R>, arg: Arg, options?: { exposeFunctions?: boolean, world?: 'main'|'utility' }): Promise<R>;+ evaluate<R, Arg>(pageFunction: PageFunction<Arg, R>, arg: Arg, options?: { exposeFunctions?: boolean, serialize?: ('Map'|'Set')[], world?: 'main'|'utility' }): Promise<R>;/*** Returns the return value of* [`pageFunction`](https://playwright.dev/docs/api/class-frame#frame-evaluate-option-expression).@@ -6012,7 +6012,7 @@ export interface Frame {* [`pageFunction`](https://playwright.dev/docs/api/class-frame#frame-evaluate-option-expression).* @param options*/- evaluate<R>(pageFunction: PageFunction<void, R>, arg?: any, options?: { exposeFunctions?: boolean, world?: 'main'|'utility' }): Promise<R>;+ evaluate<R>(pageFunction: PageFunction<void, R>, arg?: any, options?: { exposeFunctions?: boolean, serialize?: ('Map'|'Set')[], world?: 'main'|'utility' }): Promise<R>;/*** Returns the return value of@@ -6062,7 +6062,7 @@ export interface Frame {* [`pageFunction`](https://playwright.dev/docs/api/class-frame#frame-evaluate-handle-option-expression).* @param options*/- evaluateHandle<R, Arg>(pageFunction: PageFunction<Arg, R>, arg: Arg, options?: { exposeFunctions?: boolean }): Promise<SmartHandle<R>>;+ evaluateHandle<R, Arg>(pageFunction: PageFunction<Arg, R>, arg: Arg, options?: { exposeFunctions?: boolean, serialize?: ('Map'|'Set')[] }): Promise<SmartHandle<R>>;/*** Returns the return value of* [`pageFunction`](https://playwright.dev/docs/api/class-frame#frame-evaluate-handle-option-expression) as a@@ -6111,7 +6111,7 @@ export interface Frame {* [`pageFunction`](https://playwright.dev/docs/api/class-frame#frame-evaluate-handle-option-expression).* @param options*/- evaluateHandle<R>(pageFunction: PageFunction<void, R>, arg?: any, options?: { exposeFunctions?: boolean }): Promise<SmartHandle<R>>;+ evaluateHandle<R>(pageFunction: PageFunction<void, R>, arg?: any, options?: { exposeFunctions?: boolean, serialize?: ('Map'|'Set')[] }): Promise<SmartHandle<R>>;/*** **NOTE** Use locator-based [frame.locator(selector[, options])](https://playwright.dev/docs/api/class-frame#frame-locator)@@ -12035,7 +12035,7 @@ export interface JSHandle<T = any> {* [`pageFunction`](https://playwright.dev/docs/api/class-elementhandle#element-handle-evaluate-option-expression).* @param options*/- evaluate<R, Arg, O extends T = T>(pageFunction: PageFunctionOn<O, Arg, R>, arg: Arg, options?: { exposeFunctions?: boolean }): Promise<R>;+ evaluate<R, Arg, O extends T = T>(pageFunction: PageFunctionOn<O, Arg, R>, arg: Arg, options?: { exposeFunctions?: boolean, serialize?: ('Map'|'Set')[] }): Promise<R>;/*** Returns the return value of* [`pageFunction`](https://playwright.dev/docs/api/class-elementhandle#element-handle-evaluate-option-expression).@@ -12058,7 +12058,7 @@ export interface JSHandle<T = any> {* [`pageFunction`](https://playwright.dev/docs/api/class-elementhandle#element-handle-evaluate-option-expression).* @param options*/- evaluate<R, O extends T = T>(pageFunction: PageFunctionOn<O, void, R>, arg?: any, options?: { exposeFunctions?: boolean }): Promise<R>;+ evaluate<R, O extends T = T>(pageFunction: PageFunctionOn<O, void, R>, arg?: any, options?: { exposeFunctions?: boolean, serialize?: ('Map'|'Set')[] }): Promise<R>;/*** Returns the return value of@@ -12082,7 +12082,7 @@ export interface JSHandle<T = any> {* [`pageFunction`](https://playwright.dev/docs/api/class-elementhandle#element-handle-evaluate-handle-option-expression).* @param options*/- evaluateHandle<R, Arg, O extends T = T>(pageFunction: PageFunctionOn<O, Arg, R>, arg: Arg, options?: { exposeFunctions?: boolean }): Promise<SmartHandle<R>>;+ evaluateHandle<R, Arg, O extends T = T>(pageFunction: PageFunctionOn<O, Arg, R>, arg: Arg, options?: { exposeFunctions?: boolean, serialize?: ('Map'|'Set')[] }): Promise<SmartHandle<R>>;/*** Returns the return value of* [`pageFunction`](https://playwright.dev/docs/api/class-elementhandle#element-handle-evaluate-handle-option-expression)@@ -12105,7 +12105,7 @@ export interface JSHandle<T = any> {* [`pageFunction`](https://playwright.dev/docs/api/class-elementhandle#element-handle-evaluate-handle-option-expression).* @param options*/- evaluateHandle<R, O extends T = T>(pageFunction: PageFunctionOn<O, void, R>, arg?: any, options?: { exposeFunctions?: boolean }): Promise<SmartHandle<R>>;+ evaluateHandle<R, O extends T = T>(pageFunction: PageFunctionOn<O, void, R>, arg?: any, options?: { exposeFunctions?: boolean, serialize?: ('Map'|'Set')[] }): Promise<SmartHandle<R>>;/*** Returns a JSON representation of the object. If the object has a `toJSON` function, it **will not be called**.@@ -14300,7 +14300,7 @@ export interface Locator {* [`pageFunction`](https://playwright.dev/docs/api/class-locator#locator-evaluate-option-expression).* @param options*/- evaluate<R, Arg, E extends SVGElement | HTMLElement = SVGElement | HTMLElement>(pageFunction: PageFunctionOn<E, Arg, R>, arg?: Arg, options?: { timeout?: number, signal?: AbortSignal, exposeFunctions?: boolean, world?: 'main'|'utility' }): Promise<R>;+ evaluate<R, Arg, E extends SVGElement | HTMLElement = SVGElement | HTMLElement>(pageFunction: PageFunctionOn<E, Arg, R>, arg?: Arg, options?: { timeout?: number, signal?: AbortSignal, exposeFunctions?: boolean, serialize?: ('Map'|'Set')[], world?: 'main'|'utility' }): Promise<R>;/*** Execute JavaScript code in the page, taking the matching element as an argument, and return a* [JSHandle](https://playwright.dev/docs/api/class-jshandle) with the result.@@ -14334,7 +14334,7 @@ export interface Locator {* [`pageFunction`](https://playwright.dev/docs/api/class-locator#locator-evaluate-handle-option-expression).* @param options*/- evaluateHandle<R, Arg, E extends SVGElement | HTMLElement = SVGElement | HTMLElement>(pageFunction: PageFunctionOn<E, Arg, R>, arg?: Arg, options?: { timeout?: number, signal?: AbortSignal, exposeFunctions?: boolean }): Promise<SmartHandle<R>>;+ evaluateHandle<R, Arg, E extends SVGElement | HTMLElement = SVGElement | HTMLElement>(pageFunction: PageFunctionOn<E, Arg, R>, arg?: Arg, options?: { timeout?: number, signal?: AbortSignal, exposeFunctions?: boolean, serialize?: ('Map'|'Set')[] }): Promise<SmartHandle<R>>;/*** Execute JavaScript code in the page, taking all matching elements as an argument.*diff --git a/packages/playwright-core/src/client/channels.d.ts b/packages/playwright-core/src/client/channels.d.tsindex 6eee244b3a..f523e61c04 100644--- a/packages/playwright-core/src/client/channels.d.ts+++ b/packages/playwright-core/src/client/channels.d.ts@@ -2479,10 +2479,12 @@ export type FrameEvaluateExpressionParams = {expression: string,isFunction?: boolean,arg: SerializedArgument,+ serialize?: ('Map' | 'Set')[],world?: 'main' | 'utility',};export type FrameEvaluateExpressionOptions = {isFunction?: boolean,+ serialize?: ('Map' | 'Set')[],world?: 'main' | 'utility',};export type FrameEvaluateExpressionResult = {@@ -2492,9 +2494,11 @@ export type FrameEvaluateExpressionHandleParams = {expression: string,isFunction?: boolean,arg: SerializedArgument,+ serialize?: ('Map' | 'Set')[],};export type FrameEvaluateExpressionHandleOptions = {isFunction?: boolean,+ serialize?: ('Map' | 'Set')[],};export type FrameEvaluateExpressionHandleResult = {handle: JSHandleChannel,@@ -2938,10 +2942,12 @@ export type JSHandleEvaluateExpressionParams = {expression: string,isFunction?: boolean,arg: SerializedArgument,+ serialize?: ('Map' | 'Set')[],world?: 'main' | 'utility',};export type JSHandleEvaluateExpressionOptions = {isFunction?: boolean,+ serialize?: ('Map' | 'Set')[],world?: 'main' | 'utility',};export type JSHandleEvaluateExpressionResult = {@@ -2951,9 +2957,11 @@ export type JSHandleEvaluateExpressionHandleParams = {expression: string,isFunction?: boolean,arg: SerializedArgument,+ serialize?: ('Map' | 'Set')[],};export type JSHandleEvaluateExpressionHandleOptions = {isFunction?: boolean,+ serialize?: ('Map' | 'Set')[],};export type JSHandleEvaluateExpressionHandleResult = {handle: JSHandleChannel,diff --git a/packages/playwright-core/src/client/frame.ts b/packages/playwright-core/src/client/frame.tsindex b0b6f1d998..bcaef87659 100644--- a/packages/playwright-core/src/client/frame.ts+++ b/packages/playwright-core/src/client/frame.ts@@ -35,7 +35,7 @@ import { kLifecycleEvents } from './types';import { Waiter } from './waiter';import { TimeoutSettings, kNoTimeout } from './timeoutSettings';-import type { EvaluateOptions, ExposeFunctionsOptions, WorldOptions } from './jsHandle';+import type { EvaluateOptions, EvaluateHandleOptions, WorldOptions } from './jsHandle';import type { LocatorOptions } from './locator';import type { Page } from './page';import type { DropPayload, FilePayload, LifecycleEvent, SelectOption, SelectOptionOptions, StrictOptions, TimeoutOptions, WaitForFunctionOptions } from './types';@@ -207,19 +207,19 @@ export class Frame extends ChannelOwner<channels.FrameChannel> implements api.Frreturn ElementHandle.from((await this._channel.frameElement({}, kNoTimeout)).element);}- async evaluateHandle<R, Arg>(pageFunction: structs.PageFunction<Arg, R>, arg?: Arg, options?: ExposeFunctionsOptions): Promise<structs.SmartHandle<R>> {+ async evaluateHandle<R, Arg>(pageFunction: structs.PageFunction<Arg, R>, arg?: Arg, options?: EvaluateHandleOptions): Promise<structs.SmartHandle<R>> {assertMaxArguments(arguments.length, 3);assertEvaluateOptions(options);- const serializedArg = options?.exposeFunctions ? await serializeArgumentWithCallbacks(this, this._page, arg) : serializeArgument(arg);- const result = await this._channel.evaluateExpressionHandle({ expression: String(pageFunction), isFunction: typeof pageFunction === 'function', arg: serializedArg }, kNoTimeout);+ const serializedArg = options?.exposeFunctions ? await serializeArgumentWithCallbacks(this, this._page, arg, options) : serializeArgument(arg, undefined, options);+ const result = await this._channel.evaluateExpressionHandle({ expression: String(pageFunction), isFunction: typeof pageFunction === 'function', arg: serializedArg, serialize: options?.serialize }, kNoTimeout);return JSHandle.from(result.handle) as any as structs.SmartHandle<R>;}async evaluate<R, Arg>(pageFunction: structs.PageFunction<Arg, R>, arg?: Arg, options?: EvaluateOptions): Promise<R> {assertMaxArguments(arguments.length, 3);assertEvaluateOptions(options);- const serializedArg = options?.exposeFunctions ? await serializeArgumentWithCallbacks(this, this._page, arg) : serializeArgument(arg);- const result = await this._channel.evaluateExpression({ expression: String(pageFunction), isFunction: typeof pageFunction === 'function', arg: serializedArg, world: options?.world }, kNoTimeout);+ const serializedArg = options?.exposeFunctions ? await serializeArgumentWithCallbacks(this, this._page, arg, options) : serializeArgument(arg, undefined, options);+ const result = await this._channel.evaluateExpression({ expression: String(pageFunction), isFunction: typeof pageFunction === 'function', arg: serializedArg, world: options?.world, serialize: options?.serialize }, kNoTimeout);return parseResult(result.value);}diff --git a/packages/playwright-core/src/client/jsHandle.ts b/packages/playwright-core/src/client/jsHandle.tsindex 2415cfefab..362652d908 100644--- a/packages/playwright-core/src/client/jsHandle.ts+++ b/packages/playwright-core/src/client/jsHandle.ts@@ -40,22 +40,22 @@ export class JSHandle<T = any> extends ChannelOwner<channels.JSHandleChannel> imthis._channel.on('previewUpdated', ({ preview }) => this._preview = preview);}- async evaluate<R, Arg>(pageFunction: structs.PageFunctionOn<T, Arg, R>, arg?: Arg, options?: ExposeFunctionsOptions): Promise<R> {+ async evaluate<R, Arg>(pageFunction: structs.PageFunctionOn<T, Arg, R>, arg?: Arg, options?: EvaluateHandleOptions): Promise<R> {assertEvaluateOptions(options);- return await this._evaluate(pageFunction, arg, { exposeFunctions: options?.exposeFunctions });+ return await this._evaluate(pageFunction, arg, { exposeFunctions: options?.exposeFunctions, serialize: options?.serialize });}async _evaluate<R, Arg>(pageFunction: structs.PageFunctionOn<T, Arg, R>, arg?: Arg, options?: EvaluateOptions): Promise<R> {assertEvaluateOptions(options);- const serializedArg = options?.exposeFunctions ? await serializeArgumentWithCallbacks(this, this._parentOfType('Page') as Page | undefined, arg) : serializeArgument(arg);- const result = await this._channel.evaluateExpression({ expression: String(pageFunction), isFunction: typeof pageFunction === 'function', arg: serializedArg, world: options?.world }, kNoTimeout);+ const serializedArg = options?.exposeFunctions ? await serializeArgumentWithCallbacks(this, this._parentOfType('Page') as Page | undefined, arg, options) : serializeArgument(arg, undefined, options);+ const result = await this._channel.evaluateExpression({ expression: String(pageFunction), isFunction: typeof pageFunction === 'function', arg: serializedArg, world: options?.world, serialize: options?.serialize }, kNoTimeout);return parseResult(result.value);}- async evaluateHandle<R, Arg>(pageFunction: structs.PageFunctionOn<T, Arg, R>, arg?: Arg, options?: ExposeFunctionsOptions): Promise<structs.SmartHandle<R>> {+ async evaluateHandle<R, Arg>(pageFunction: structs.PageFunctionOn<T, Arg, R>, arg?: Arg, options?: EvaluateHandleOptions): Promise<structs.SmartHandle<R>> {assertEvaluateOptions(options);- const serializedArg = options?.exposeFunctions ? await serializeArgumentWithCallbacks(this, this._parentOfType('Page') as Page | undefined, arg) : serializeArgument(arg);- const result = await this._channel.evaluateExpressionHandle({ expression: String(pageFunction), isFunction: typeof pageFunction === 'function', arg: serializedArg }, kNoTimeout);+ const serializedArg = options?.exposeFunctions ? await serializeArgumentWithCallbacks(this, this._parentOfType('Page') as Page | undefined, arg, options) : serializeArgument(arg, undefined, options);+ const result = await this._channel.evaluateExpressionHandle({ expression: String(pageFunction), isFunction: typeof pageFunction === 'function', arg: serializedArg, serialize: options?.serialize }, kNoTimeout);return JSHandle.from(result.handle) as any as structs.SmartHandle<R>;}@@ -100,7 +100,7 @@ export class JSHandle<T = any> extends ChannelOwner<channels.JSHandleChannel> im// This function takes care of converting all JSHandles to their channels,// so that generic channel serializer converts them to guids.-export function serializeArgument(arg: any, registerCallback?: (callback: Function) => string): channels.SerializedArgument {+export function serializeArgument(arg: any, registerCallback?: (callback: Function) => string, options?: SerializationOptions): channels.SerializedArgument {const handles: channels.Channel[] = [];const pushHandle = (channel: channels.Channel): number => {handles.push(channel);@@ -112,15 +112,17 @@ export function serializeArgument(arg: any, registerCallback?: (callback: Functiif (typeof value === 'function' && registerCallback)return { fn: registerCallback(value as Function) };return { fallThrough: value };- });+ }, options);return { value, handles };}export type WorldOptions = { world?: 'main' | 'utility' };export type ExposeFunctionsOptions = { exposeFunctions?: boolean };-export type EvaluateOptions = ExposeFunctionsOptions & WorldOptions;+export type SerializationOptions = { serialize?: ('Map' | 'Set')[] };+export type EvaluateHandleOptions = ExposeFunctionsOptions & SerializationOptions;+export type EvaluateOptions = EvaluateHandleOptions & WorldOptions;-export async function serializeArgumentWithCallbacks(owner: ChannelOwner<any>, page: Page | undefined, arg: any): Promise<channels.SerializedArgument> {+export async function serializeArgumentWithCallbacks(owner: ChannelOwner<any>, page: Page | undefined, arg: any, options?: SerializationOptions): Promise<channels.SerializedArgument> {return await owner._wrapApiCall(async () => {const exposePromises: Promise<void>[] = [];const serialized = serializeArgument(arg, callback => {@@ -129,7 +131,7 @@ export async function serializeArgumentWithCallbacks(owner: ChannelOwner<any>, pconst name = kFunctionBindingPrefix + createGuid();exposePromises.push(page._exposeEvaluateCallback(name, callback));return name;- });+ }, options);await Promise.all(exposePromises);return serialized;}, { internal: true });@@ -147,4 +149,6 @@ export function assertMaxArguments(count: number, max: number): asserts count {export function assertEvaluateOptions(options: any) {if (options !== undefined && (typeof options !== 'object' || options === null || Array.isArray(options)))throw new Error('Too many arguments. If you need to pass more than 1 argument to the function wrap them in an object.');+ if (options?.serialize !== undefined && (!Array.isArray(options.serialize) || options.serialize.some((type: unknown) => type !== 'Map' && type !== 'Set')))+ throw new Error('serialize: expected an array of (Map|Set)');}diff --git a/packages/playwright-core/src/client/locator.ts b/packages/playwright-core/src/client/locator.tsindex d9c4bb2119..6ff220960e 100644--- a/packages/playwright-core/src/client/locator.ts+++ b/packages/playwright-core/src/client/locator.ts@@ -28,7 +28,7 @@ import { DisposableStub } from './disposable';import { kNoTimeout } from './timeoutSettings';import type { ExpectResult, Frame } from './frame';-import type { EvaluateOptions, ExposeFunctionsOptions, WorldOptions } from './jsHandle';+import type { EvaluateOptions, EvaluateHandleOptions, WorldOptions } from './jsHandle';import type { DropPayload, FilePayload, FrameExpectParams, Rect, SelectOption, SelectOptionOptions, TimeoutOptions } from './types';import type * as structs from '../../types/structs';import type * as api from '../../types/types';@@ -145,7 +145,7 @@ export class Locator implements api.Locator {return await this._frame.$$eval(this._selector, pageFunction, arg, options);}- async evaluateHandle<R, Arg>(pageFunction: structs.PageFunctionOn<any, Arg, R>, arg?: Arg, options?: TimeoutOptions & ExposeFunctionsOptions): Promise<structs.SmartHandle<R>> {+ async evaluateHandle<R, Arg>(pageFunction: structs.PageFunctionOn<any, Arg, R>, arg?: Arg, options?: TimeoutOptions & EvaluateHandleOptions): Promise<structs.SmartHandle<R>> {return await this._withElement(h => h.evaluateHandle(pageFunction, arg, options), { title: 'Evaluate', timeout: options?.timeout, signal: options?.signal });}diff --git a/packages/playwright-core/src/client/page.ts b/packages/playwright-core/src/client/page.tsindex 381b833de3..0c6451de1a 100644--- a/packages/playwright-core/src/client/page.ts+++ b/packages/playwright-core/src/client/page.ts@@ -50,7 +50,7 @@ import { TimeoutSettings, kNoTimeout } from './timeoutSettings';import { mkdirIfNeeded } from './fileUtils';import { ConsoleMessage } from './consoleMessage';import type { BrowserContext } from './browserContext';-import type { EvaluateOptions, ExposeFunctionsOptions, WorldOptions } from './jsHandle';+import type { EvaluateOptions, EvaluateHandleOptions, ExposeFunctionsOptions, WorldOptions } from './jsHandle';import type { Clock } from './clock';import type { APIRequestContext } from './fetch';import type { WaitForNavigationOptions } from './frame';@@ -339,7 +339,7 @@ export class Page extends ChannelOwner<channels.PageChannel> implements api.Pagereturn await this._mainFrame.dispatchEvent(selector, type, eventInit, options);}- async evaluateHandle<R, Arg>(pageFunction: structs.PageFunction<Arg, R>, arg?: Arg, options?: ExposeFunctionsOptions): Promise<structs.SmartHandle<R>> {+ async evaluateHandle<R, Arg>(pageFunction: structs.PageFunction<Arg, R>, arg?: Arg, options?: EvaluateHandleOptions): Promise<structs.SmartHandle<R>> {assertMaxArguments(arguments.length, 3);return await this._mainFrame.evaluateHandle(pageFunction, arg, options);}diff --git a/packages/playwright-core/src/server/channels.d.ts b/packages/playwright-core/src/server/channels.d.tsindex 7edbe1ba7f..907ed6fd9f 100644--- a/packages/playwright-core/src/server/channels.d.ts+++ b/packages/playwright-core/src/server/channels.d.ts@@ -2480,10 +2480,12 @@ export type FrameEvaluateExpressionParams = {expression: string,isFunction?: boolean,arg: SerializedArgument,+ serialize?: ('Map' | 'Set')[],world?: 'main' | 'utility',};export type FrameEvaluateExpressionOptions = {isFunction?: boolean,+ serialize?: ('Map' | 'Set')[],world?: 'main' | 'utility',};export type FrameEvaluateExpressionResult = {@@ -2493,9 +2495,11 @@ export type FrameEvaluateExpressionHandleParams = {expression: string,isFunction?: boolean,arg: SerializedArgument,+ serialize?: ('Map' | 'Set')[],};export type FrameEvaluateExpressionHandleOptions = {isFunction?: boolean,+ serialize?: ('Map' | 'Set')[],};export type FrameEvaluateExpressionHandleResult = {handle: JSHandleChannel,@@ -2939,10 +2943,12 @@ export type JSHandleEvaluateExpressionParams = {expression: string,isFunction?: boolean,arg: SerializedArgument,+ serialize?: ('Map' | 'Set')[],world?: 'main' | 'utility',};export type JSHandleEvaluateExpressionOptions = {isFunction?: boolean,+ serialize?: ('Map' | 'Set')[],world?: 'main' | 'utility',};export type JSHandleEvaluateExpressionResult = {@@ -2952,9 +2958,11 @@ export type JSHandleEvaluateExpressionHandleParams = {expression: string,isFunction?: boolean,arg: SerializedArgument,+ serialize?: ('Map' | 'Set')[],};export type JSHandleEvaluateExpressionHandleOptions = {isFunction?: boolean,+ serialize?: ('Map' | 'Set')[],};export type JSHandleEvaluateExpressionHandleResult = {handle: JSHandleChannel,diff --git a/packages/playwright-core/src/server/dispatchers/elementHandlerDispatcher.ts b/packages/playwright-core/src/server/dispatchers/elementHandlerDispatcher.tsindex 1522e049a4..a410f90e77 100644--- a/packages/playwright-core/src/server/dispatchers/elementHandlerDispatcher.ts+++ b/packages/playwright-core/src/server/dispatchers/elementHandlerDispatcher.ts@@ -56,8 +56,8 @@ export class ElementHandleDispatcher extends JSHandleDispatcher<FrameDispatcher>}override async evaluateExpression(params: channels.JSHandleEvaluateExpressionParams, progress: Progress): Promise<channels.JSHandleEvaluateExpressionResult> {- const value = await this._elementHandle.evaluateExpression(progress, params.expression, { isFunction: params.isFunction, world: params.world }, parseArgument(params.arg));- return { value: serializeResult(value) };+ const value = await this._elementHandle.evaluateExpression(progress, params.expression, { isFunction: params.isFunction, world: params.world, serialize: params.serialize }, parseArgument(params.arg));+ return { value: serializeResult(value, params) };}async ownerFrame(params: channels.ElementHandleOwnerFrameParams, progress: Progress): Promise<channels.ElementHandleOwnerFrameResult> {diff --git a/packages/playwright-core/src/server/dispatchers/frameDispatcher.ts b/packages/playwright-core/src/server/dispatchers/frameDispatcher.tsindex 412d23c39f..7733df73fb 100644--- a/packages/playwright-core/src/server/dispatchers/frameDispatcher.ts+++ b/packages/playwright-core/src/server/dispatchers/frameDispatcher.ts@@ -82,11 +82,11 @@ export class FrameDispatcher extends Dispatcher<Frame, channels.FrameChannel, Br}async evaluateExpression(params: channels.FrameEvaluateExpressionParams, progress: Progress): Promise<channels.FrameEvaluateExpressionResult> {- return { value: serializeResult(await this._frame.evaluateExpression(progress, params.expression, { isFunction: params.isFunction, world: params.world }, parseArgument(params.arg))) };+ return { value: serializeResult(await this._frame.evaluateExpression(progress, params.expression, { isFunction: params.isFunction, world: params.world, serialize: params.serialize }, parseArgument(params.arg)), params) };}async evaluateExpressionHandle(params: channels.FrameEvaluateExpressionHandleParams, progress: Progress): Promise<channels.FrameEvaluateExpressionHandleResult> {- return { handle: ElementHandleDispatcher.fromJSOrElementHandle(this, await this._frame.evaluateExpressionHandle(progress, params.expression, { isFunction: params.isFunction }, parseArgument(params.arg))) };+ return { handle: ElementHandleDispatcher.fromJSOrElementHandle(this, await this._frame.evaluateExpressionHandle(progress, params.expression, { isFunction: params.isFunction, serialize: params.serialize }, parseArgument(params.arg))) };}async waitForSelector(params: channels.FrameWaitForSelectorParams, progress: Progress): Promise<channels.FrameWaitForSelectorResult> {diff --git a/packages/playwright-core/src/server/dispatchers/jsHandleDispatcher.ts b/packages/playwright-core/src/server/dispatchers/jsHandleDispatcher.tsindex c2aa99a892..6c489f8790 100644--- a/packages/playwright-core/src/server/dispatchers/jsHandleDispatcher.ts+++ b/packages/playwright-core/src/server/dispatchers/jsHandleDispatcher.ts@@ -45,12 +45,12 @@ export class JSHandleDispatcher<ParentScope extends JSHandleDispatcherParentScopasync evaluateExpression(params: channels.JSHandleEvaluateExpressionParams, progress: Progress): Promise<channels.JSHandleEvaluateExpressionResult> {if (params.world)throw new Error(`Only element handles can be evaluated in the "${params.world}" world`);- const jsHandle = await this._object.evaluateExpression(progress, params.expression, { isFunction: params.isFunction }, parseArgument(params.arg));- return { value: serializeResult(jsHandle) };+ const jsHandle = await this._object.evaluateExpression(progress, params.expression, { isFunction: params.isFunction, serialize: params.serialize }, parseArgument(params.arg));+ return { value: serializeResult(jsHandle, params) };}async evaluateExpressionHandle(params: channels.JSHandleEvaluateExpressionHandleParams, progress: Progress): Promise<channels.JSHandleEvaluateExpressionHandleResult> {- const jsHandle = await this._object.evaluateExpressionHandle(progress, params.expression, { isFunction: params.isFunction }, parseArgument(params.arg));+ const jsHandle = await this._object.evaluateExpressionHandle(progress, params.expression, { isFunction: params.isFunction, serialize: params.serialize }, parseArgument(params.arg));// If "jsHandle" is an ElementHandle, it belongs to the same frame as "this".return { handle: ElementHandleDispatcher.fromJSOrElementHandle(this.parentScope() as FrameDispatcher, jsHandle) };}@@ -91,6 +91,6 @@ export function parseValue(v: channels.SerializedValue): any {return parseSerializedValue(v, []);}-export function serializeResult(arg: any): channels.SerializedValue {- return serializeValue(arg, value => ({ fallThrough: value }));+export function serializeResult(arg: any, options?: { serialize?: ('Map' | 'Set')[] }): channels.SerializedValue {+ return serializeValue(arg, value => ({ fallThrough: value }), options);}diff --git a/packages/playwright-core/src/server/dispatchers/pageDispatcher.ts b/packages/playwright-core/src/server/dispatchers/pageDispatcher.tsindex 4b351777a8..9066ef864f 100644--- a/packages/playwright-core/src/server/dispatchers/pageDispatcher.ts+++ b/packages/playwright-core/src/server/dispatchers/pageDispatcher.ts@@ -598,7 +598,7 @@ export class BindingCallDispatcher extends Dispatcher<SdkObject, channels.Bindinsuper(scope, new SdkObject(scope._object, 'bindingCall'), 'BindingCall', {frame: frameDispatcher,name,- args: args.map(serializeResult),+ args: args.map(arg => serializeResult(arg)),});this._promise = new Promise((resolve, reject) => {this._resolve = resolve;diff --git a/packages/playwright-core/src/server/dom.ts b/packages/playwright-core/src/server/dom.tsindex 39f725084b..c90aa05331 100644--- a/packages/playwright-core/src/server/dom.ts+++ b/packages/playwright-core/src/server/dom.ts@@ -73,11 +73,11 @@ export class FrameExecutionContext extends js.ExecutionContext {return js.evaluate(this, false /* returnByValue */, pageFunction, arg);}- async evaluateExpression(expression: string, options: { isFunction?: boolean }, arg?: any): Promise<any> {+ async evaluateExpression(expression: string, options: { isFunction?: boolean, serialize?: ('Map' | 'Set')[] }, arg?: any): Promise<any> {return js.evaluateExpression(this, expression, { ...options, returnByValue: true }, arg);}- async evaluateExpressionHandle(expression: string, options: { isFunction?: boolean }, arg?: any): Promise<js.JSHandle<any>> {+ async evaluateExpressionHandle(expression: string, options: { isFunction?: boolean, serialize?: ('Map' | 'Set')[] }, arg?: any): Promise<js.JSHandle<any>> {return js.evaluateExpression(this, expression, { ...options, returnByValue: false }, arg);}@@ -869,13 +869,13 @@ export class ElementHandle<T extends Node = Node> extends js.JSHandle<T> {return this._frame.selectors.queryAll(selector, this);}- override async evaluateExpression(progress: Progress, expression: string, options: { isFunction?: boolean, world?: types.World }, arg: any): Promise<any> {+ override async evaluateExpression(progress: Progress, expression: string, options: { isFunction?: boolean, world?: types.World, serialize?: ('Map' | 'Set')[] }, arg: any): Promise<any> {return await progress.race(this.internalEvaluateExpression(expression, options, arg));}- override async internalEvaluateExpression(expression: string, options: { isFunction?: boolean, world?: types.World }, arg: any): Promise<any> {+ override async internalEvaluateExpression(expression: string, options: { isFunction?: boolean, world?: types.World, serialize?: ('Map' | 'Set')[] }, arg: any): Promise<any> {const context = options.world ? await this._frame.context(options.world) : this._context;- return await js.evaluateExpression(context, expression, { isFunction: options.isFunction, returnByValue: true }, this, arg);+ return await js.evaluateExpression(context, expression, { isFunction: options.isFunction, serialize: options.serialize, returnByValue: true }, this, arg);}async evalOnSelector(progress: Progress, selector: string, strict: boolean, expression: string, options: { isFunction?: boolean, world?: types.World }, arg: any): Promise<any> {diff --git a/packages/playwright-core/src/server/frames.ts b/packages/playwright-core/src/server/frames.tsindex 2c20749b71..fb2d901d3b 100644--- a/packages/playwright-core/src/server/frames.ts+++ b/packages/playwright-core/src/server/frames.ts@@ -808,21 +808,21 @@ export class Frame extends SdkObject<FrameEventMap> {return this.context('utility');}- async evaluateExpression(progress: Progress, expression: string, options: { isFunction?: boolean, world?: types.World } = {}, arg?: any): Promise<any> {+ async evaluateExpression(progress: Progress, expression: string, options: { isFunction?: boolean, world?: types.World, serialize?: ('Map' | 'Set')[] } = {}, arg?: any): Promise<any> {return await progress.race(this._evaluateExpression(expression, options, arg));}- private async _evaluateExpression(expression: string, options: { isFunction?: boolean, world?: types.World } = {}, arg?: any): Promise<any> {+ private async _evaluateExpression(expression: string, options: { isFunction?: boolean, world?: types.World, serialize?: ('Map' | 'Set')[] } = {}, arg?: any): Promise<any> {const context = await this.context(options.world ?? 'main');const value = await context.evaluateExpression(expression, options, arg);return value;}- async evaluateExpressionHandle(progress: Progress, expression: string, options: { isFunction?: boolean, world?: types.World } = {}, arg?: any): Promise<js.JSHandle<any>> {+ async evaluateExpressionHandle(progress: Progress, expression: string, options: { isFunction?: boolean, world?: types.World, serialize?: ('Map' | 'Set')[] } = {}, arg?: any): Promise<js.JSHandle<any>> {return await progress.race(this._evaluateExpressionHandle(expression, options, arg));}- private async _evaluateExpressionHandle(expression: string, options: { isFunction?: boolean, world?: types.World } = {}, arg?: any): Promise<js.JSHandle<any>> {+ private async _evaluateExpressionHandle(expression: string, options: { isFunction?: boolean, world?: types.World, serialize?: ('Map' | 'Set')[] } = {}, arg?: any): Promise<js.JSHandle<any>> {const context = await this.context(options.world ?? 'main');const value = await context.evaluateExpressionHandle(expression, options, arg);return value;diff --git a/packages/playwright-core/src/server/javascript.ts b/packages/playwright-core/src/server/javascript.tsindex adaae310f1..420d4ec669 100644--- a/packages/playwright-core/src/server/javascript.ts+++ b/packages/playwright-core/src/server/javascript.ts@@ -143,11 +143,11 @@ export class JSHandle<T = any> extends SdkObject {(globalThis as any).leakedJSHandles.set(this, new Error('Leaked JSHandle'));}- async evaluateExpression(progress: Progress, expression: string, options: { isFunction?: boolean }, arg: any) {+ async evaluateExpression(progress: Progress, expression: string, options: { isFunction?: boolean, serialize?: ('Map' | 'Set')[] }, arg: any) {return await progress.race(this.internalEvaluateExpression(expression, options, arg));}- async evaluateExpressionHandle(progress: Progress, expression: string, options: { isFunction?: boolean }, arg: any): Promise<JSHandle<any>> {+ async evaluateExpressionHandle(progress: Progress, expression: string, options: { isFunction?: boolean, serialize?: ('Map' | 'Set')[] }, arg: any): Promise<JSHandle<any>> {return await progress.race(this._evaluateExpressionHandle(expression, options, arg));}@@ -171,11 +171,11 @@ export class JSHandle<T = any> extends SdkObject {return evaluate(this._context, false /* returnByValue */, pageFunction, this, arg);}- async internalEvaluateExpression(expression: string, options: { isFunction?: boolean }, arg: any) {+ async internalEvaluateExpression(expression: string, options: { isFunction?: boolean, serialize?: ('Map' | 'Set')[] }, arg: any) {return await evaluateExpression(this._context, expression, { ...options, returnByValue: true }, this, arg);}- private async _evaluateExpressionHandle(expression: string, options: { isFunction?: boolean }, arg: any): Promise<JSHandle<any>> {+ private async _evaluateExpressionHandle(expression: string, options: { isFunction?: boolean, serialize?: ('Map' | 'Set')[] }, arg: any): Promise<JSHandle<any>> {return await evaluateExpression(this._context, expression, { ...options, returnByValue: false }, this, arg);}@@ -254,7 +254,7 @@ export async function evaluate(context: ExecutionContext, returnByValue: booleanreturn evaluateExpression(context, String(pageFunction), { returnByValue, isFunction: typeof pageFunction === 'function' }, ...args);}-export async function evaluateExpression(context: ExecutionContext, expression: string, options: { returnByValue?: boolean, isFunction?: boolean }, ...args: any[]): Promise<any> {+export async function evaluateExpression(context: ExecutionContext, expression: string, options: { returnByValue?: boolean, isFunction?: boolean, serialize?: ('Map' | 'Set')[] }, ...args: any[]): Promise<any> {expression = normalizeEvaluationExpression(expression, options.isFunction);const handles: (Promise<JSHandle>)[] = [];const toDispose: Promise<JSHandle>[] = [];@@ -276,7 +276,7 @@ export async function evaluateExpression(context: ExecutionContext, expression:return { h: pushHandle(adopted) };}return { fallThrough: handle };- }));+ }, options));const utilityScriptObjects: JSHandle[] = [];for (const handle of await Promise.all(handles)) {@@ -286,7 +286,7 @@ export async function evaluateExpression(context: ExecutionContext, expression:}// See UtilityScript for arguments.- const utilityScriptValues = [options.isFunction, options.returnByValue, expression, args.length, ...args];+ const utilityScriptValues = [options.isFunction, options.returnByValue, options.serialize, expression, args.length, ...args];const script = `(utilityScript, ...args) => utilityScript.evaluate(...args)`;try {diff --git a/packages/playwright-core/types/structs.d.ts b/packages/playwright-core/types/structs.d.tsindex 3b671e99ac..a5b6c922a7 100644--- a/packages/playwright-core/types/structs.d.ts+++ b/packages/playwright-core/types/structs.d.ts@@ -27,6 +27,8 @@ export type EvaluationArgument = {};export type NoHandles<Arg> =Arg extends JSHandle ? never :+ Arg extends Map<infer K, infer V> ? Map<NoHandles<K>, NoHandles<V>> :+ Arg extends Set<infer T> ? Set<NoHandles<T>> :Arg extends (...args: infer T) => PromiseLike<infer U> ? (...args: T) => Promise<NoHandles<U>> :Arg extends (...args: infer T) => infer R ? (...args: T) => NoHandles<R> :Arg extends object ? { [Key in keyof Arg]: NoHandles<Arg[Key]> } :@@ -34,6 +36,8 @@ export type NoHandles<Arg> =export type Unboxed<Arg> =Arg extends ElementHandle<infer T> ? T :Arg extends JSHandle<infer T> ? T :+ Arg extends Map<infer K, infer V> ? Map<Unboxed<K>, Unboxed<V>> :+ Arg extends Set<infer T> ? Set<Unboxed<T>> :Arg extends (...args: infer T) => PromiseLike<infer U> ? (...args: T) => Promise<Unboxed<U>> :Arg extends (...args: infer T) => infer R ? (...args: T) => Unboxed<R> :Arg extends NoHandles<Arg> ? Arg :diff --git a/packages/playwright-core/types/types.d.ts b/packages/playwright-core/types/types.d.tsindex 5fcd6b1c96..16a448b39f 100644--- a/packages/playwright-core/types/types.d.ts+++ b/packages/playwright-core/types/types.d.ts@@ -134,7 +134,7 @@ export interface Page {* [`pageFunction`](https://playwright.dev/docs/api/class-page#page-evaluate-option-expression).* @param options*/- evaluate<R, Arg>(pageFunction: PageFunction<Arg, R>, arg: Arg, options?: { exposeFunctions?: boolean, world?: 'main'|'utility' }): Promise<R>;+ evaluate<R, Arg>(pageFunction: PageFunction<Arg, R>, arg: Arg, options?: { exposeFunctions?: boolean, serialize?: ('Map'|'Set')[], world?: 'main'|'utility' }): Promise<R>;/*** Returns the value of the* [`pageFunction`](https://playwright.dev/docs/api/class-page#page-evaluate-option-expression) invocation.@@ -187,7 +187,7 @@ export interface Page {* [`pageFunction`](https://playwright.dev/docs/api/class-page#page-evaluate-option-expression).* @param options*/- evaluate<R>(pageFunction: PageFunction<void, R>, arg?: any, options?: { exposeFunctions?: boolean, world?: 'main'|'utility' }): Promise<R>;+ evaluate<R>(pageFunction: PageFunction<void, R>, arg?: any, options?: { exposeFunctions?: boolean, serialize?: ('Map'|'Set')[], world?: 'main'|'utility' }): Promise<R>;/*** Returns the value of the@@ -235,7 +235,7 @@ export interface Page {* [`pageFunction`](https://playwright.dev/docs/api/class-page#page-evaluate-handle-option-expression).* @param options*/- evaluateHandle<R, Arg>(pageFunction: PageFunction<Arg, R>, arg: Arg, options?: { exposeFunctions?: boolean }): Promise<SmartHandle<R>>;+ evaluateHandle<R, Arg>(pageFunction: PageFunction<Arg, R>, arg: Arg, options?: { exposeFunctions?: boolean, serialize?: ('Map'|'Set')[] }): Promise<SmartHandle<R>>;/*** Returns the value of the* [`pageFunction`](https://playwright.dev/docs/api/class-page#page-evaluate-handle-option-expression) invocation as a@@ -282,7 +282,7 @@ export interface Page {* [`pageFunction`](https://playwright.dev/docs/api/class-page#page-evaluate-handle-option-expression).* @param options*/- evaluateHandle<R>(pageFunction: PageFunction<void, R>, arg?: any, options?: { exposeFunctions?: boolean }): Promise<SmartHandle<R>>;+ evaluateHandle<R>(pageFunction: PageFunction<void, R>, arg?: any, options?: { exposeFunctions?: boolean, serialize?: ('Map'|'Set')[] }): Promise<SmartHandle<R>>;/*** Adds a script which would be evaluated in one of the following scenarios:@@ -5963,7 +5963,7 @@ export interface Frame {* [`pageFunction`](https://playwright.dev/docs/api/class-frame#frame-evaluate-option-expression).* @param options*/- evaluate<R, Arg>(pageFunction: PageFunction<Arg, R>, arg: Arg, options?: { exposeFunctions?: boolean, world?: 'main'|'utility' }): Promise<R>;+ evaluate<R, Arg>(pageFunction: PageFunction<Arg, R>, arg: Arg, options?: { exposeFunctions?: boolean, serialize?: ('Map'|'Set')[], world?: 'main'|'utility' }): Promise<R>;/*** Returns the return value of* [`pageFunction`](https://playwright.dev/docs/api/class-frame#frame-evaluate-option-expression).@@ -6012,7 +6012,7 @@ export interface Frame {* [`pageFunction`](https://playwright.dev/docs/api/class-frame#frame-evaluate-option-expression).* @param options*/- evaluate<R>(pageFunction: PageFunction<void, R>, arg?: any, options?: { exposeFunctions?: boolean, world?: 'main'|'utility' }): Promise<R>;+ evaluate<R>(pageFunction: PageFunction<void, R>, arg?: any, options?: { exposeFunctions?: boolean, serialize?: ('Map'|'Set')[], world?: 'main'|'utility' }): Promise<R>;/*** Returns the return value of@@ -6062,7 +6062,7 @@ export interface Frame {* [`pageFunction`](https://playwright.dev/docs/api/class-frame#frame-evaluate-handle-option-expression).* @param options*/- evaluateHandle<R, Arg>(pageFunction: PageFunction<Arg, R>, arg: Arg, options?: { exposeFunctions?: boolean }): Promise<SmartHandle<R>>;+ evaluateHandle<R, Arg>(pageFunction: PageFunction<Arg, R>, arg: Arg, options?: { exposeFunctions?: boolean, serialize?: ('Map'|'Set')[] }): Promise<SmartHandle<R>>;/*** Returns the return value of* [`pageFunction`](https://playwright.dev/docs/api/class-frame#frame-evaluate-handle-option-expression) as a@@ -6111,7 +6111,7 @@ export interface Frame {* [`pageFunction`](https://playwright.dev/docs/api/class-frame#frame-evaluate-handle-option-expression).* @param options*/- evaluateHandle<R>(pageFunction: PageFunction<void, R>, arg?: any, options?: { exposeFunctions?: boolean }): Promise<SmartHandle<R>>;+ evaluateHandle<R>(pageFunction: PageFunction<void, R>, arg?: any, options?: { exposeFunctions?: boolean, serialize?: ('Map'|'Set')[] }): Promise<SmartHandle<R>>;/*** **NOTE** Use locator-based [frame.locator(selector[, options])](https://playwright.dev/docs/api/class-frame#frame-locator)@@ -12035,7 +12035,7 @@ export interface JSHandle<T = any> {* [`pageFunction`](https://playwright.dev/docs/api/class-elementhandle#element-handle-evaluate-option-expression).* @param options*/- evaluate<R, Arg, O extends T = T>(pageFunction: PageFunctionOn<O, Arg, R>, arg: Arg, options?: { exposeFunctions?: boolean }): Promise<R>;+ evaluate<R, Arg, O extends T = T>(pageFunction: PageFunctionOn<O, Arg, R>, arg: Arg, options?: { exposeFunctions?: boolean, serialize?: ('Map'|'Set')[] }): Promise<R>;/*** Returns the return value of* [`pageFunction`](https://playwright.dev/docs/api/class-elementhandle#element-handle-evaluate-option-expression).@@ -12058,7 +12058,7 @@ export interface JSHandle<T = any> {* [`pageFunction`](https://playwright.dev/docs/api/class-elementhandle#element-handle-evaluate-option-expression).* @param options*/- evaluate<R, O extends T = T>(pageFunction: PageFunctionOn<O, void, R>, arg?: any, options?: { exposeFunctions?: boolean }): Promise<R>;+ evaluate<R, O extends T = T>(pageFunction: PageFunctionOn<O, void, R>, arg?: any, options?: { exposeFunctions?: boolean, serialize?: ('Map'|'Set')[] }): Promise<R>;/*** Returns the return value of@@ -12082,7 +12082,7 @@ export interface JSHandle<T = any> {* [`pageFunction`](https://playwright.dev/docs/api/class-elementhandle#element-handle-evaluate-handle-option-expression).* @param options*/- evaluateHandle<R, Arg, O extends T = T>(pageFunction: PageFunctionOn<O, Arg, R>, arg: Arg, options?: { exposeFunctions?: boolean }): Promise<SmartHandle<R>>;+ evaluateHandle<R, Arg, O extends T = T>(pageFunction: PageFunctionOn<O, Arg, R>, arg: Arg, options?: { exposeFunctions?: boolean, serialize?: ('Map'|'Set')[] }): Promise<SmartHandle<R>>;/*** Returns the return value of* [`pageFunction`](https://playwright.dev/docs/api/class-elementhandle#element-handle-evaluate-handle-option-expression)@@ -12105,7 +12105,7 @@ export interface JSHandle<T = any> {* [`pageFunction`](https://playwright.dev/docs/api/class-elementhandle#element-handle-evaluate-handle-option-expression).* @param options*/- evaluateHandle<R, O extends T = T>(pageFunction: PageFunctionOn<O, void, R>, arg?: any, options?: { exposeFunctions?: boolean }): Promise<SmartHandle<R>>;+ evaluateHandle<R, O extends T = T>(pageFunction: PageFunctionOn<O, void, R>, arg?: any, options?: { exposeFunctions?: boolean, serialize?: ('Map'|'Set')[] }): Promise<SmartHandle<R>>;/*** Returns a JSON representation of the object. If the object has a `toJSON` function, it **will not be called**.@@ -14300,7 +14300,7 @@ export interface Locator {* [`pageFunction`](https://playwright.dev/docs/api/class-locator#locator-evaluate-option-expression).* @param options*/- evaluate<R, Arg, E extends SVGElement | HTMLElement = SVGElement | HTMLElement>(pageFunction: PageFunctionOn<E, Arg, R>, arg?: Arg, options?: { timeout?: number, signal?: AbortSignal, exposeFunctions?: boolean, world?: 'main'|'utility' }): Promise<R>;+ evaluate<R, Arg, E extends SVGElement | HTMLElement = SVGElement | HTMLElement>(pageFunction: PageFunctionOn<E, Arg, R>, arg?: Arg, options?: { timeout?: number, signal?: AbortSignal, exposeFunctions?: boolean, serialize?: ('Map'|'Set')[], world?: 'main'|'utility' }): Promise<R>;/*** Execute JavaScript code in the page, taking the matching element as an argument, and return a* [JSHandle](https://playwright.dev/docs/api/class-jshandle) with the result.@@ -14334,7 +14334,7 @@ export interface Locator {* [`pageFunction`](https://playwright.dev/docs/api/class-locator#locator-evaluate-handle-option-expression).* @param options*/- evaluateHandle<R, Arg, E extends SVGElement | HTMLElement = SVGElement | HTMLElement>(pageFunction: PageFunctionOn<E, Arg, R>, arg?: Arg, options?: { timeout?: number, signal?: AbortSignal, exposeFunctions?: boolean }): Promise<SmartHandle<R>>;+ evaluateHandle<R, Arg, E extends SVGElement | HTMLElement = SVGElement | HTMLElement>(pageFunction: PageFunctionOn<E, Arg, R>, arg?: Arg, options?: { timeout?: number, signal?: AbortSignal, exposeFunctions?: boolean, serialize?: ('Map'|'Set')[] }): Promise<SmartHandle<R>>;/*** Execute JavaScript code in the page, taking all matching elements as an argument.*diff --git a/packages/playwright/src/index.ts b/packages/playwright/src/index.tsindex 778a39cc98..9eb21ca724 100644--- a/packages/playwright/src/index.ts+++ b/packages/playwright/src/index.ts@@ -508,7 +508,7 @@ const playwrightFixtures: Fixtures<TestFixtures, WorkerFixtures, UtilityTestFixtif (typeof w.mount !== 'function')throw new Error('The gallery page does not define window.mount().');await w.mount(p);- }, params, { exposeFunctions: true });+ }, params, { exposeFunctions: true, serialize: ['Map', 'Set'] });await use(async (storyId: string, props?: any) => {if (!baseURL)throw new Error('mount() requires `baseURL` to point at the component gallery. Set it in your Playwright config.');diff --git a/packages/protocol/spec/frame.yml b/packages/protocol/spec/frame.ymlindex 439ebfd99a..3b34d5207e 100644--- a/packages/protocol/spec/frame.yml+++ b/packages/protocol/spec/frame.yml@@ -337,6 +337,13 @@ Frame:expression: stringisFunction: boolean?arg: SerializedArgument+ serialize:+ type: array?+ items:+ type: enum+ literals:+ - Map+ - Setworld:type: enum?literals:@@ -354,6 +361,13 @@ Frame:expression: stringisFunction: boolean?arg: SerializedArgument+ serialize:+ type: array?+ items:+ type: enum+ literals:+ - Map+ - Setreturns:handle: JSHandleflags:diff --git a/packages/protocol/spec/handles.yml b/packages/protocol/spec/handles.ymlindex 00e581fe65..15e17c3ecf 100644--- a/packages/protocol/spec/handles.yml+++ b/packages/protocol/spec/handles.yml@@ -29,6 +29,13 @@ JSHandle:expression: stringisFunction: boolean?arg: SerializedArgument+ serialize:+ type: array?+ items:+ type: enum+ literals:+ - Map+ - Setworld:type: enum?literals:@@ -46,6 +53,13 @@ JSHandle:expression: stringisFunction: boolean?arg: SerializedArgument+ serialize:+ type: array?+ items:+ type: enum+ literals:+ - Map+ - Setreturns:handle: JSHandleflags:diff --git a/packages/protocol/spec/serialized.yml b/packages/protocol/spec/serialized.ymlindex e40ee4803c..0b82544a8d 100644--- a/packages/protocol/spec/serialized.yml+++ b/packages/protocol/spec/serialized.yml@@ -77,6 +77,18 @@ SerializedValue:properties:k: stringv: SerializedValue+ # Map entries.+ me:+ type: array?+ items:+ type: object+ properties:+ k: SerializedValue+ v: SerializedValue+ # Set entries.+ se:+ type: array?+ items: SerializedValue# An index in the handles array from SerializedArgument.h: int?# Name of a page-side callback that routes back to a client-side function.diff --git a/packages/protocol/src/serializers.ts b/packages/protocol/src/serializers.tsindex 0b245c1b8f..ef59330e6e 100644--- a/packages/protocol/src/serializers.ts+++ b/packages/protocol/src/serializers.ts@@ -111,6 +111,20 @@ function innerParseSerializedValue(value: SerializedValue, handles: any[] | underesult[k] = innerParseSerializedValue(v, handles, refs, [...accessChain, k]);return result;}+ if (value.me !== undefined) {+ const result = new Map();+ refs.set(value.id!, result);+ for (const { k, v } of value.me)+ result.set(innerParseSerializedValue(k, handles, refs, accessChain), innerParseSerializedValue(v, handles, refs, accessChain));+ return result;+ }+ if (value.se !== undefined) {+ const result = new Set();+ refs.set(value.id!, result);+ for (const item of value.se)+ result.add(innerParseSerializedValue(item, handles, refs, accessChain));+ return result;+ }if (value.h !== undefined) {if (handles === undefined)throw new Error('Unexpected handle');@@ -128,10 +142,11 @@ export type HandleOrValue = { h: number } | { fn: string } | { fallThrough: anytype VisitorInfo = {visited: Map<object, number>;lastId: number;+ serialize?: ('Map' | 'Set')[];};-export function serializeValue(value: any, handleSerializer: (value: any) => HandleOrValue): SerializedValue {- return innerSerializeValue(value, handleSerializer, { lastId: 0, visited: new Map() }, []);+export function serializeValue(value: any, handleSerializer: (value: any) => HandleOrValue, options: { serialize?: ('Map' | 'Set')[] } = {}): SerializedValue {+ return innerSerializeValue(value, handleSerializer, { lastId: 0, visited: new Map(), serialize: options.serialize }, []);}export function serializePlainValue(arg: any): SerializedValue {@@ -184,6 +199,23 @@ function innerSerializeValue(value: any, handleSerializer: (value: any) => Handlif (id)return { ref: id };+ if (visitorInfo.serialize?.includes('Map') && value instanceof Map) {+ const me: { k: SerializedValue, v: SerializedValue }[] = [];+ const id = ++visitorInfo.lastId;+ visitorInfo.visited.set(value, id);+ for (const [k, v] of value)+ me.push({ k: innerSerializeValue(k, handleSerializer, visitorInfo, accessChain), v: innerSerializeValue(v, handleSerializer, visitorInfo, accessChain) });+ return { me, id };+ }+ if (visitorInfo.serialize?.includes('Set') && value instanceof Set) {+ const se: SerializedValue[] = [];+ const id = ++visitorInfo.lastId;+ visitorInfo.visited.set(value, id);+ for (const item of value)+ se.push(innerSerializeValue(item, handleSerializer, visitorInfo, accessChain));+ return { se, id };+ }+if (Array.isArray(value)) {const a = [];const id = ++visitorInfo.lastId;diff --git a/packages/protocol/src/structs.d.ts b/packages/protocol/src/structs.d.tsindex 084e3c13e7..1d230fda89 100644--- a/packages/protocol/src/structs.d.ts+++ b/packages/protocol/src/structs.d.ts@@ -297,6 +297,11 @@ export type SerializedValue = {k: string,v: SerializedValue,}[],+ me?: {+ k: SerializedValue,+ v: SerializedValue,+ }[],+ se?: SerializedValue[],h?: number,fn?: string,id?: number,diff --git a/packages/protocol/src/validator.ts b/packages/protocol/src/validator.tsindex 86f1e91255..c9155c5511 100644--- a/packages/protocol/src/validator.ts+++ b/packages/protocol/src/validator.ts@@ -1349,6 +1349,7 @@ scheme.FrameEvaluateExpressionParams = tObject({expression: tString,isFunction: tOptional(tBoolean),arg: tType('SerializedArgument'),+ serialize: tOptional(tArray(tEnum(['Map', 'Set']))),world: tOptional(tEnum(['main', 'utility'])),});scheme.FrameEvaluateExpressionResult = tObject({@@ -1358,6 +1359,7 @@ scheme.FrameEvaluateExpressionHandleParams = tObject({expression: tString,isFunction: tOptional(tBoolean),arg: tType('SerializedArgument'),+ serialize: tOptional(tArray(tEnum(['Map', 'Set']))),});scheme.FrameEvaluateExpressionHandleResult = tObject({handle: tChannel(['ElementHandle', 'JSHandle']),@@ -1639,6 +1641,7 @@ scheme.JSHandleEvaluateExpressionParams = tObject({expression: tString,isFunction: tOptional(tBoolean),arg: tType('SerializedArgument'),+ serialize: tOptional(tArray(tEnum(['Map', 'Set']))),world: tOptional(tEnum(['main', 'utility'])),});scheme.ElementHandleEvaluateExpressionParams = tType('JSHandleEvaluateExpressionParams');@@ -1650,6 +1653,7 @@ scheme.JSHandleEvaluateExpressionHandleParams = tObject({expression: tString,isFunction: tOptional(tBoolean),arg: tType('SerializedArgument'),+ serialize: tOptional(tArray(tEnum(['Map', 'Set']))),});scheme.ElementHandleEvaluateExpressionHandleParams = tType('JSHandleEvaluateExpressionHandleParams');scheme.JSHandleEvaluateExpressionHandleResult = tObject({@@ -2998,6 +3002,11 @@ scheme.SerializedValue = tObject({k: tString,v: tType('SerializedValue'),}))),+ me: tOptional(tArray(tObject({+ k: tType('SerializedValue'),+ v: tType('SerializedValue'),+ }))),+ se: tOptional(tArray(tType('SerializedValue'))),h: tOptional(tInt),fn: tOptional(tString),id: tOptional(tInt),diff --git a/tests/page/page-evaluate-serialization.spec.ts b/tests/page/page-evaluate-serialization.spec.tsnew file mode 100644index 0000000000..1c1f7e63b9--- /dev/null+++ b/tests/page/page-evaluate-serialization.spec.ts@@ -0,0 +1,63 @@+/**+ * Copyright (c) Microsoft Corporation.+ *+ * Licensed under the Apache License, Version 2.0 (the "License");+ * you may not use this file except in compliance with the License.+ * You may obtain a copy of the License at+ *+ * http://www.apache.org/licenses/LICENSE-2.0+ *+ * Unless required by applicable law or agreed to in writing, software+ * distributed under the License is distributed on an "AS IS" BASIS,+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+ * See the License for the specific language governing permissions and+ * limitations under the License.+ */++import { test, expect } from './pageTest';++test('should serialize selected types in evaluate', async ({ page }) => {+ const value = new Map([['key', new Set([1, 2])]]);+ const result = await page.evaluate(value => {+ if (!(value instanceof Map) || !(value.get('key') instanceof Set))+ throw new Error('Expected Map and Set arguments');+ value.get('key')!.add(3);+ return value;+ }, value, { serialize: ['Map', 'Set'] });+ expect(result).toEqual(new Map([['key', new Set([1, 2, 3])]]));+ expect(await page.evaluate(value => value, value, { serialize: [] })).toEqual({});+ const collections = { map: new Map([['key', 1]]), set: new Set([2]) };+ for (const type of ['Map', 'Set'] as const) {+ const result = await page.evaluate(value => ({+ map: value.map instanceof Map,+ set: value.set instanceof Set,+ value,+ created: { map: new Map([['key', 1]]), set: new Set([2]) },+ }), collections, { serialize: [type] });+ const expected = { map: type === 'Map' ? collections.map : {}, set: type === 'Set' ? collections.set : {} };+ expect(result).toEqual({ map: type === 'Map', set: type === 'Set', value: expected, created: expected });+ }+});++test('should serialize Map and Set with handles', async ({ page }) => {+ const value = new Map([['key', new Set([1, 2])]]);+ const handle = await page.evaluateHandle(value => value, value, { serialize: ['Map', 'Set'] });+ expect(await handle.evaluate(value => value instanceof Map && value.get('key') instanceof Set)).toBe(true);+ expect(await handle.evaluate((value, set) => ({ value, set }), new Set([3]), { serialize: ['Map', 'Set'] })).toEqual({ value, set: new Set([3]) });+ expect(await handle.evaluate(value => value)).toEqual({});+ await handle.dispose();+});++test('should serialize Map and Set with locators', async ({ page }) => {+ await page.setContent('<div>hello</div>');+ const value = new Map([['key', new Set([1, 2])]]);+ const result = await page.locator('div').evaluate((element, value) => ({ text: element.textContent, value }), value, { serialize: ['Map', 'Set'] });+ expect(result).toEqual({ text: 'hello', value });+});++test('should reject invalid serialization types', async ({ page }) => {+ // @ts-expect-error Invalid serialization type.+ await expect(page.evaluate(() => 42, undefined, { serialize: ['Blob'] })).rejects.toThrow('serialize: expected an array of (Map|Set)');+ // @ts-expect-error Serialization types must be an array.+ await expect(page.evaluate(() => 42, undefined, { serialize: 'Map' })).rejects.toThrow('serialize: expected an array of (Map|Set)');+});diff --git a/tests/playwright-test/playwright.mount.spec.ts b/tests/playwright-test/playwright.mount.spec.tsnew file mode 100644index 0000000000..0927f92bad--- /dev/null+++ b/tests/playwright-test/playwright.mount.spec.ts@@ -0,0 +1,68 @@+/**+ * Copyright Microsoft Corporation. All rights reserved.+ *+ * Licensed under the Apache License, Version 2.0 (the "License");+ * you may not use this file except in compliance with the License.+ * You may obtain a copy of the License at+ *+ * http://www.apache.org/licenses/LICENSE-2.0+ *+ * Unless required by applicable law or agreed to in writing, software+ * distributed under the License is distributed on an "AS IS" BASIS,+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+ * See the License for the specific language governing permissions and+ * limitations under the License.+ */++import { test, expect } from './playwright-test-fixtures';++test('mount and update should preserve Map and Set props with callbacks', async ({ runInlineTest, server }) => {+ server.setRoute('/gallery.html', (req, res) => {+ res.setHeader('Content-Type', 'text/html');+ res.end(`+ <div id="root"></div>+ <script>+ window.mount = async ({ story, props }) => {+ if (!(props.values instanceof Map) || !(props.callbacks instanceof Map))+ throw new Error('Expected Map props');+ const numbers = props.values.get('numbers');+ const callbacks = props.callbacks.get('change');+ if (!(numbers instanceof Set) || !(callbacks instanceof Set))+ throw new Error('Expected nested Set props');+ const text = story + ': ' + [...numbers].join(', ');+ document.querySelector('#root').textContent = text;+ for (const callback of callbacks)+ await callback(text);+ };+ </script>+ `);+ });+ const result = await runInlineTest({+ 'playwright.config.ts': `+ module.exports = { use: { baseURL: '${server.PREFIX}/gallery.html' } };+ `,+ 'mount.spec.ts': `+ import { test, expect } from '@playwright/test';++ test('collections', async ({ mount }) => {+ const received: string[] = [];+ const callback = async (text: string) => { received.push(text); };+ const component = await mount('collections', {+ values: new Map([['numbers', new Set([1, 2, 2])]]),+ callbacks: new Map([['change', new Set([callback])]]),+ });+ await expect(component).toHaveText('collections: 1, 2');+ expect(received).toEqual(['collections: 1, 2']);++ await component.update({+ values: new Map([['numbers', new Set([3, 4])]]),+ callbacks: new Map([['change', new Set([callback])]]),+ });+ await expect(component).toHaveText('collections: 3, 4');+ expect(received).toEqual(['collections: 1, 2', 'collections: 3, 4']);+ });+ `,+ });+ expect(result.exitCode).toBe(0);+ expect(result.passed).toBe(1);+});diff --git a/utils/generate_types/overrides.d.ts b/utils/generate_types/overrides.d.tsindex 001d1785a4..dd853e7c3f 100644--- a/utils/generate_types/overrides.d.ts+++ b/utils/generate_types/overrides.d.ts@@ -38,11 +38,11 @@ type ZodSchema = ZodTypeAny | z3.ZodTypeAny;type InferZodSchema<T extends ZodSchema> = T extends z3.ZodTypeAny ? z3.infer<T> : T extends ZodTypeAny ? z.infer<T> : never;export interface Page {- evaluate<R, Arg>(pageFunction: PageFunction<Arg, R>, arg: Arg, options?: { exposeFunctions?: boolean, world?: 'main'|'utility' }): Promise<R>;- evaluate<R>(pageFunction: PageFunction<void, R>, arg?: any, options?: { exposeFunctions?: boolean, world?: 'main'|'utility' }): Promise<R>;+ evaluate<R, Arg>(pageFunction: PageFunction<Arg, R>, arg: Arg, options?: { exposeFunctions?: boolean, serialize?: ('Map'|'Set')[], world?: 'main'|'utility' }): Promise<R>;+ evaluate<R>(pageFunction: PageFunction<void, R>, arg?: any, options?: { exposeFunctions?: boolean, serialize?: ('Map'|'Set')[], world?: 'main'|'utility' }): Promise<R>;- evaluateHandle<R, Arg>(pageFunction: PageFunction<Arg, R>, arg: Arg, options?: { exposeFunctions?: boolean }): Promise<SmartHandle<R>>;- evaluateHandle<R>(pageFunction: PageFunction<void, R>, arg?: any, options?: { exposeFunctions?: boolean }): Promise<SmartHandle<R>>;+ evaluateHandle<R, Arg>(pageFunction: PageFunction<Arg, R>, arg: Arg, options?: { exposeFunctions?: boolean, serialize?: ('Map'|'Set')[] }): Promise<SmartHandle<R>>;+ evaluateHandle<R>(pageFunction: PageFunction<void, R>, arg?: any, options?: { exposeFunctions?: boolean, serialize?: ('Map'|'Set')[] }): Promise<SmartHandle<R>>;addInitScript<Arg>(script: PageFunction<Arg, any> | { path?: string, content?: string }, arg?: Arg, options?: { exposeFunctions?: boolean }): Promise<Disposable>;@@ -85,11 +85,11 @@ export interface Page {}export interface Frame {- evaluate<R, Arg>(pageFunction: PageFunction<Arg, R>, arg: Arg, options?: { exposeFunctions?: boolean, world?: 'main'|'utility' }): Promise<R>;- evaluate<R>(pageFunction: PageFunction<void, R>, arg?: any, options?: { exposeFunctions?: boolean, world?: 'main'|'utility' }): Promise<R>;+ evaluate<R, Arg>(pageFunction: PageFunction<Arg, R>, arg: Arg, options?: { exposeFunctions?: boolean, serialize?: ('Map'|'Set')[], world?: 'main'|'utility' }): Promise<R>;+ evaluate<R>(pageFunction: PageFunction<void, R>, arg?: any, options?: { exposeFunctions?: boolean, serialize?: ('Map'|'Set')[], world?: 'main'|'utility' }): Promise<R>;- evaluateHandle<R, Arg>(pageFunction: PageFunction<Arg, R>, arg: Arg, options?: { exposeFunctions?: boolean }): Promise<SmartHandle<R>>;- evaluateHandle<R>(pageFunction: PageFunction<void, R>, arg?: any, options?: { exposeFunctions?: boolean }): Promise<SmartHandle<R>>;+ evaluateHandle<R, Arg>(pageFunction: PageFunction<Arg, R>, arg: Arg, options?: { exposeFunctions?: boolean, serialize?: ('Map'|'Set')[] }): Promise<SmartHandle<R>>;+ evaluateHandle<R>(pageFunction: PageFunction<void, R>, arg?: any, options?: { exposeFunctions?: boolean, serialize?: ('Map'|'Set')[] }): Promise<SmartHandle<R>>;$<K extends keyof HTMLElementTagNameMap>(selector: K, options?: { strict: boolean }): Promise<ElementHandleForTag<K> | null>;$(selector: string, options?: { strict: boolean }): Promise<ElementHandle<SVGElement | HTMLElement> | null>;@@ -156,11 +156,11 @@ export interface Worker {}export interface JSHandle<T = any> {- evaluate<R, Arg, O extends T = T>(pageFunction: PageFunctionOn<O, Arg, R>, arg: Arg, options?: { exposeFunctions?: boolean }): Promise<R>;- evaluate<R, O extends T = T>(pageFunction: PageFunctionOn<O, void, R>, arg?: any, options?: { exposeFunctions?: boolean }): Promise<R>;+ evaluate<R, Arg, O extends T = T>(pageFunction: PageFunctionOn<O, Arg, R>, arg: Arg, options?: { exposeFunctions?: boolean, serialize?: ('Map'|'Set')[] }): Promise<R>;+ evaluate<R, O extends T = T>(pageFunction: PageFunctionOn<O, void, R>, arg?: any, options?: { exposeFunctions?: boolean, serialize?: ('Map'|'Set')[] }): Promise<R>;- evaluateHandle<R, Arg, O extends T = T>(pageFunction: PageFunctionOn<O, Arg, R>, arg: Arg, options?: { exposeFunctions?: boolean }): Promise<SmartHandle<R>>;- evaluateHandle<R, O extends T = T>(pageFunction: PageFunctionOn<O, void, R>, arg?: any, options?: { exposeFunctions?: boolean }): Promise<SmartHandle<R>>;+ evaluateHandle<R, Arg, O extends T = T>(pageFunction: PageFunctionOn<O, Arg, R>, arg: Arg, options?: { exposeFunctions?: boolean, serialize?: ('Map'|'Set')[] }): Promise<SmartHandle<R>>;+ evaluateHandle<R, O extends T = T>(pageFunction: PageFunctionOn<O, void, R>, arg?: any, options?: { exposeFunctions?: boolean, serialize?: ('Map'|'Set')[] }): Promise<SmartHandle<R>>;jsonValue(): Promise<T>;asElement(): T extends Node ? ElementHandle<T> : null;@@ -194,8 +194,8 @@ export interface ElementHandle<T=Node> extends JSHandle<T> {}export interface Locator {- evaluate<R, Arg, E extends SVGElement | HTMLElement = SVGElement | HTMLElement>(pageFunction: PageFunctionOn<E, Arg, R>, arg?: Arg, options?: { timeout?: number, signal?: AbortSignal, exposeFunctions?: boolean, world?: 'main'|'utility' }): Promise<R>;- evaluateHandle<R, Arg, E extends SVGElement | HTMLElement = SVGElement | HTMLElement>(pageFunction: PageFunctionOn<E, Arg, R>, arg?: Arg, options?: { timeout?: number, signal?: AbortSignal, exposeFunctions?: boolean }): Promise<SmartHandle<R>>;+ evaluate<R, Arg, E extends SVGElement | HTMLElement = SVGElement | HTMLElement>(pageFunction: PageFunctionOn<E, Arg, R>, arg?: Arg, options?: { timeout?: number, signal?: AbortSignal, exposeFunctions?: boolean, serialize?: ('Map'|'Set')[], world?: 'main'|'utility' }): Promise<R>;+ evaluateHandle<R, Arg, E extends SVGElement | HTMLElement = SVGElement | HTMLElement>(pageFunction: PageFunctionOn<E, Arg, R>, arg?: Arg, options?: { timeout?: number, signal?: AbortSignal, exposeFunctions?: boolean, serialize?: ('Map'|'Set')[] }): Promise<SmartHandle<R>>;evaluateAll<R, Arg, E extends SVGElement | HTMLElement = SVGElement | HTMLElement>(pageFunction: PageFunctionOn<E[], Arg, R>, arg?: Arg, options?: { world?: 'main'|'utility' }): Promise<R>;waitForFunction<Arg, E extends SVGElement | HTMLElement = SVGElement | HTMLElement>(pageFunction: PageFunctionOn<E, Arg, any>, arg?: Arg, options?: { timeout?: number, signal?: AbortSignal }): Promise<void>;elementHandle(options?: { timeout?: number, signal?: AbortSignal }): Promise<ElementHandle<SVGElement | HTMLElement>>;diff --git a/utils/generate_types/test/test.ts b/utils/generate_types/test/test.tsindex 3d098fc0f4..68069e258b 100644--- a/utils/generate_types/test/test.ts+++ b/utils/generate_types/test/test.ts@@ -336,6 +336,18 @@ playwright.chromium.launch().then(async browser => {await browser.close();})();+// Collection serialization unboxes handles inside collections.+(async () => {+ const body = await page.evaluateHandle(() => document.body);+ const input = { map: new Map([[body, new Set([body])]]) };+ const value = await page.evaluate(({ map }) => {+ const elements = map.get(document.body)!;+ const assertion: AssertType<Set<HTMLElement>, typeof elements> = true;+ return new Set([...elements].map(element => element.tagName));+ }, input, { serialize: ['Map', 'Set'] });+ const assertion: AssertType<Set<string>, typeof value> = true;+})();+// test $eval and $$eval(async () => {const browser = await playwright.firefox.launch();@@ -1049,4 +1061,3 @@ import {Geolocation,HTTPCredentials,} from 'playwright';-