Skip to content

Playwright is a framework for Web Testing and Automation. It allows testing Chromium, Firefox and WebKit with a single API.

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.md
index 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.md
index 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.md
index 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, csharp
diff --git a/docs/src/api/class-page.md b/docs/src/api/class-page.md
index 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.md
index 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.ts
index 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.ts
index 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.ts
index 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) => HandleOrVa
if (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.ts
index 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.ts
index 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.ts
index 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.Fr
return 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.ts
index 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> im
this._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: Functi
if (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>, p
const 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.ts
index 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.ts
index 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.Page
return 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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 JSHandleDispatcherParentScop
async 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.ts
index 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.Bindin
super(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.ts
index 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.ts
index 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.ts
index 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: boolean
return 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.ts
index 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.ts
index 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.ts
index 778a39cc98..9eb21ca724 100644
--- a/packages/playwright/src/index.ts
+++ b/packages/playwright/src/index.ts
@@ -508,7 +508,7 @@ const playwrightFixtures: Fixtures<TestFixtures, WorkerFixtures, UtilityTestFixt
if (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.yml
index 439ebfd99a..3b34d5207e 100644
--- a/packages/protocol/spec/frame.yml
+++ b/packages/protocol/spec/frame.yml
@@ -337,6 +337,13 @@ Frame:
expression: string
isFunction: boolean?
arg: SerializedArgument
+ serialize:
+ type: array?
+ items:
+ type: enum
+ literals:
+ - Map
+ - Set
world:
type: enum?
literals:
@@ -354,6 +361,13 @@ Frame:
expression: string
isFunction: boolean?
arg: SerializedArgument
+ serialize:
+ type: array?
+ items:
+ type: enum
+ literals:
+ - Map
+ - Set
returns:
handle: JSHandle
flags:
diff --git a/packages/protocol/spec/handles.yml b/packages/protocol/spec/handles.yml
index 00e581fe65..15e17c3ecf 100644
--- a/packages/protocol/spec/handles.yml
+++ b/packages/protocol/spec/handles.yml
@@ -29,6 +29,13 @@ JSHandle:
expression: string
isFunction: boolean?
arg: SerializedArgument
+ serialize:
+ type: array?
+ items:
+ type: enum
+ literals:
+ - Map
+ - Set
world:
type: enum?
literals:
@@ -46,6 +53,13 @@ JSHandle:
expression: string
isFunction: boolean?
arg: SerializedArgument
+ serialize:
+ type: array?
+ items:
+ type: enum
+ literals:
+ - Map
+ - Set
returns:
handle: JSHandle
flags:
diff --git a/packages/protocol/spec/serialized.yml b/packages/protocol/spec/serialized.yml
index e40ee4803c..0b82544a8d 100644
--- a/packages/protocol/spec/serialized.yml
+++ b/packages/protocol/spec/serialized.yml
@@ -77,6 +77,18 @@ SerializedValue:
properties:
k: string
v: 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.ts
index 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[] | unde
result[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: any
type 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) => Handl
if (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.ts
index 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.ts
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
index 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.ts
index 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';
-