Skip to content

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

chore: revert "feat(evaluate): opt in to Map and Set serialization" (#43029)

Yury Semikhatsky6152cce6dd64
diff --git a/docs/src/api/class-frame.md b/docs/src/api/class-frame.md
index de7735b599..b13d3aa9e6 100644
--- a/docs/src/api/class-frame.md
+++ b/docs/src/api/class-frame.md
@@ -757,9 +757,6 @@ 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
@@ -878,9 +875,6 @@ 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 9910841d11..5a883bf889 100644
--- a/docs/src/api/class-jshandle.md
+++ b/docs/src/api/class-jshandle.md
@@ -99,9 +99,6 @@ 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]>
@@ -132,9 +129,6 @@ 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 a5a31e6e69..64afc019d9 100644
--- a/docs/src/api/class-locator.md
+++ b/docs/src/api/class-locator.md
@@ -1181,9 +1181,6 @@ 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
@@ -1292,9 +1289,6 @@ 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 6d8a65d002..03d1f91fc1 100644
--- a/docs/src/api/class-page.md
+++ b/docs/src/api/class-page.md
@@ -1608,9 +1608,6 @@ 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
@@ -1726,9 +1723,6 @@ 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 c08ec6ded3..b303f49dc8 100644
--- a/docs/src/api/params.md
+++ b/docs/src/api/params.md
@@ -604,12 +604,6 @@ 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 6f917aa268..efb3054cef 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 };
- }, { serialize: ['Map', 'Set'] });
+ }, { extendedSerialization: true });
if (trivial)
return { trivial: value };
return { encoded };
diff --git a/packages/injected/src/utilityScript.ts b/packages/injected/src/utilityScript.ts
index af98c76550..5c257ef25d 100644
--- a/packages/injected/src/utilityScript.ts
+++ b/packages/injected/src/utilityScript.ts
@@ -65,7 +65,7 @@ export class UtilityScript {
(global as any).builtins = this.builtins;
}
- evaluate(isFunction: boolean | undefined, returnByValue: boolean, serialize: ('Map' | 'Set')[] | undefined, expression: string, argCount: number, ...argsAndHandles: any[]) {
+ evaluate(isFunction: boolean | undefined, returnByValue: boolean, expression: string, argCount: number, ...argsAndHandles: any[]) {
const args = argsAndHandles.slice(0, argCount);
const handles = argsAndHandles.slice(argCount);
const parameters = [];
@@ -82,20 +82,20 @@ export class UtilityScript {
if (typeof result === 'function')
result = result(...parameters);
}
- return returnByValue ? this._promiseAwareJsonValueNoThrow(result, serialize) : result;
+ return returnByValue ? this._promiseAwareJsonValueNoThrow(result) : result;
}
- jsonValue(returnByValue: true, value: any, serialize?: ('Map' | 'Set')[]) {
+ jsonValue(returnByValue: true, value: any) {
// 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 }), { serialize });
+ return serializeAsCallArgument(value, (value: any) => ({ fallThrough: value }));
}
- private _promiseAwareJsonValueNoThrow(value: any, serialize?: ('Map' | 'Set')[]) {
+ private _promiseAwareJsonValueNoThrow(value: any) {
const safeJson = (value: any) => {
try {
- return this.jsonValue(true, value, serialize);
+ return this.jsonValue(true, value);
} catch (e) {
return undefined;
}
diff --git a/packages/isomorphic/utilityScriptSerializers.ts b/packages/isomorphic/utilityScriptSerializers.ts
index 6027e77e1f..7132bc8626 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;
- serialize?: ('Map' | 'Set')[];
+ extendedSerialization?: boolean;
};
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: { serialize?: ('Map' | 'Set')[] } = {}): SerializedValue {
- return serialize(value, handleSerializer, { visited: new Map(), lastId: 0, serialize: options.serialize });
+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 });
}
function serialize(value: any, handleSerializer: (value: any) => HandleOrValue, visitorInfo: VisitorInfo): SerializedValue {
@@ -308,33 +308,35 @@ function innerSerialize(value: any, handleSerializer: (value: any) => HandleOrVa
if (id)
return { ref: 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 (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 };
}
- 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));
+ 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 { 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 561dd5dbeb..b86402670e 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, serialize?: ('Map'|'Set')[], world?: 'main'|'utility' }): Promise<R>;
+ evaluate<R, Arg>(pageFunction: PageFunction<Arg, R>, arg: Arg, options?: { exposeFunctions?: boolean, 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, serialize?: ('Map'|'Set')[], world?: 'main'|'utility' }): Promise<R>;
+ evaluate<R>(pageFunction: PageFunction<void, R>, arg?: any, options?: { exposeFunctions?: boolean, 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, serialize?: ('Map'|'Set')[] }): Promise<SmartHandle<R>>;
+ evaluateHandle<R, Arg>(pageFunction: PageFunction<Arg, R>, arg: Arg, options?: { exposeFunctions?: boolean }): 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, serialize?: ('Map'|'Set')[] }): Promise<SmartHandle<R>>;
+ evaluateHandle<R>(pageFunction: PageFunction<void, R>, arg?: any, options?: { exposeFunctions?: boolean }): Promise<SmartHandle<R>>;
/**
* Adds a script which would be evaluated in one of the following scenarios:
@@ -5988,7 +5988,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, serialize?: ('Map'|'Set')[], world?: 'main'|'utility' }): Promise<R>;
+ evaluate<R, Arg>(pageFunction: PageFunction<Arg, R>, arg: Arg, options?: { exposeFunctions?: boolean, world?: 'main'|'utility' }): Promise<R>;
/**
* Returns the return value of
* [`pageFunction`](https://playwright.dev/docs/api/class-frame#frame-evaluate-option-expression).
@@ -6037,7 +6037,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, serialize?: ('Map'|'Set')[], world?: 'main'|'utility' }): Promise<R>;
+ evaluate<R>(pageFunction: PageFunction<void, R>, arg?: any, options?: { exposeFunctions?: boolean, world?: 'main'|'utility' }): Promise<R>;
/**
* Returns the return value of
@@ -6087,7 +6087,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, serialize?: ('Map'|'Set')[] }): Promise<SmartHandle<R>>;
+ evaluateHandle<R, Arg>(pageFunction: PageFunction<Arg, R>, arg: Arg, options?: { exposeFunctions?: boolean }): Promise<SmartHandle<R>>;
/**
* Returns the return value of
* [`pageFunction`](https://playwright.dev/docs/api/class-frame#frame-evaluate-handle-option-expression) as a
@@ -6136,7 +6136,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, serialize?: ('Map'|'Set')[] }): Promise<SmartHandle<R>>;
+ evaluateHandle<R>(pageFunction: PageFunction<void, R>, arg?: any, options?: { exposeFunctions?: boolean }): Promise<SmartHandle<R>>;
/**
* **NOTE** Use locator-based [frame.locator(selector[, options])](https://playwright.dev/docs/api/class-frame#frame-locator)
@@ -12101,7 +12101,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, serialize?: ('Map'|'Set')[] }): Promise<R>;
+ evaluate<R, Arg, O extends T = T>(pageFunction: PageFunctionOn<O, Arg, R>, arg: Arg, options?: { exposeFunctions?: boolean }): Promise<R>;
/**
* Returns the return value of
* [`pageFunction`](https://playwright.dev/docs/api/class-elementhandle#element-handle-evaluate-option-expression).
@@ -12124,7 +12124,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, serialize?: ('Map'|'Set')[] }): Promise<R>;
+ evaluate<R, O extends T = T>(pageFunction: PageFunctionOn<O, void, R>, arg?: any, options?: { exposeFunctions?: boolean }): Promise<R>;
/**
* Returns the return value of
@@ -12148,7 +12148,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, serialize?: ('Map'|'Set')[] }): Promise<SmartHandle<R>>;
+ evaluateHandle<R, Arg, O extends T = T>(pageFunction: PageFunctionOn<O, Arg, R>, arg: Arg, options?: { exposeFunctions?: boolean }): Promise<SmartHandle<R>>;
/**
* Returns the return value of
* [`pageFunction`](https://playwright.dev/docs/api/class-elementhandle#element-handle-evaluate-handle-option-expression)
@@ -12171,7 +12171,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, serialize?: ('Map'|'Set')[] }): Promise<SmartHandle<R>>;
+ evaluateHandle<R, O extends T = T>(pageFunction: PageFunctionOn<O, void, R>, arg?: any, options?: { exposeFunctions?: boolean }): Promise<SmartHandle<R>>;
/**
* Returns a JSON representation of the object. If the object has a `toJSON` function, it **will not be called**.
@@ -14366,7 +14366,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, serialize?: ('Map'|'Set')[], 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, 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.
@@ -14400,7 +14400,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, serialize?: ('Map'|'Set')[] }): 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 }): 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 7e0b2a868f..bc133ac010 100644
--- a/packages/playwright-core/src/client/channels.d.ts
+++ b/packages/playwright-core/src/client/channels.d.ts
@@ -2574,12 +2574,10 @@ 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 = {
@@ -2589,11 +2587,9 @@ 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,
@@ -3068,12 +3064,10 @@ 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 = {
@@ -3083,11 +3077,9 @@ 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 accf6079cf..1dea08fa16 100644
--- a/packages/playwright-core/src/client/frame.ts
+++ b/packages/playwright-core/src/client/frame.ts
@@ -36,7 +36,7 @@ import { Waiter } from './waiter';
import { WebMCP } from './webmcp';
import { TimeoutSettings, kNoTimeout } from './timeoutSettings';
-import type { EvaluateOptions, EvaluateHandleOptions, WorldOptions } from './jsHandle';
+import type { EvaluateOptions, ExposeFunctionsOptions, 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';
@@ -210,19 +210,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?: EvaluateHandleOptions): Promise<structs.SmartHandle<R>> {
+ async evaluateHandle<R, Arg>(pageFunction: structs.PageFunction<Arg, R>, arg?: Arg, options?: ExposeFunctionsOptions): Promise<structs.SmartHandle<R>> {
assertMaxArguments(arguments.length, 3);
assertEvaluateOptions(options);
- 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);
+ 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);
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, 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);
+ 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);
return parseResult(result.value);
}
diff --git a/packages/playwright-core/src/client/jsHandle.ts b/packages/playwright-core/src/client/jsHandle.ts
index bfcf903b63..8a73882ce7 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?: EvaluateHandleOptions): Promise<R> {
+ async evaluate<R, Arg>(pageFunction: structs.PageFunctionOn<T, Arg, R>, arg?: Arg, options?: ExposeFunctionsOptions): Promise<R> {
assertEvaluateOptions(options);
- return await this._evaluate(pageFunction, arg, { exposeFunctions: options?.exposeFunctions, serialize: options?.serialize });
+ return await this._evaluate(pageFunction, arg, { exposeFunctions: options?.exposeFunctions });
}
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, 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);
+ 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);
return parseResult(result.value);
}
- async evaluateHandle<R, Arg>(pageFunction: structs.PageFunctionOn<T, Arg, R>, arg?: Arg, options?: EvaluateHandleOptions): Promise<structs.SmartHandle<R>> {
+ async evaluateHandle<R, Arg>(pageFunction: structs.PageFunctionOn<T, Arg, R>, arg?: Arg, options?: ExposeFunctionsOptions): Promise<structs.SmartHandle<R>> {
assertEvaluateOptions(options);
- 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);
+ 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);
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, options?: SerializationOptions): channels.SerializedArgument {
+export function serializeArgument(arg: any, registerCallback?: (callback: Function) => string): channels.SerializedArgument {
const handles: channels.Channel[] = [];
const pushHandle = (channel: channels.Channel): number => {
handles.push(channel);
@@ -112,17 +112,15 @@ 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 SerializationOptions = { serialize?: ('Map' | 'Set')[] };
-export type EvaluateHandleOptions = ExposeFunctionsOptions & SerializationOptions;
-export type EvaluateOptions = EvaluateHandleOptions & WorldOptions;
+export type EvaluateOptions = ExposeFunctionsOptions & WorldOptions;
-export async function serializeArgumentWithCallbacks(owner: ChannelOwner<any>, page: Page | undefined, arg: any, options?: SerializationOptions): Promise<channels.SerializedArgument> {
+export async function serializeArgumentWithCallbacks(owner: ChannelOwner<any>, page: Page | undefined, arg: any): Promise<channels.SerializedArgument> {
return await owner._wrapApiCall(async () => {
const exposePromises: Promise<void>[] = [];
const serialized = serializeArgument(arg, callback => {
@@ -131,7 +129,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 });
@@ -149,8 +147,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)');
if (options?.exposeFunctions && options?.world === 'utility')
throw new Error('Option "exposeFunctions" is not supported in the "utility" world.');
}
diff --git a/packages/playwright-core/src/client/locator.ts b/packages/playwright-core/src/client/locator.ts
index c282a1484e..caf2ba828a 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, EvaluateHandleOptions, WorldOptions } from './jsHandle';
+import type { EvaluateOptions, ExposeFunctionsOptions, 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 & EvaluateHandleOptions): Promise<structs.SmartHandle<R>> {
+ async evaluateHandle<R, Arg>(pageFunction: structs.PageFunctionOn<any, Arg, R>, arg?: Arg, options?: TimeoutOptions & ExposeFunctionsOptions): 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 7a3d6fad75..9b08fbf329 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, EvaluateHandleOptions, ExposeFunctionsOptions, WorldOptions } from './jsHandle';
+import type { EvaluateOptions, ExposeFunctionsOptions, WorldOptions } from './jsHandle';
import type { Clock } from './clock';
import type { APIRequestContext } from './fetch';
import type { WaitForNavigationOptions } from './frame';
@@ -341,7 +341,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?: EvaluateHandleOptions): Promise<structs.SmartHandle<R>> {
+ async evaluateHandle<R, Arg>(pageFunction: structs.PageFunction<Arg, R>, arg?: Arg, options?: ExposeFunctionsOptions): 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 44cc79099d..adefbefd2a 100644
--- a/packages/playwright-core/src/server/channels.d.ts
+++ b/packages/playwright-core/src/server/channels.d.ts
@@ -2575,12 +2575,10 @@ 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 = {
@@ -2590,11 +2588,9 @@ 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,
@@ -3069,12 +3065,10 @@ 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 = {
@@ -3084,11 +3078,9 @@ 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 3268ee07de..f724a14775 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, serialize: params.serialize }, parseArgument(params.arg));
- return { value: serializeResult(value, params) };
+ const value = await this._elementHandle.evaluateExpression(progress, params.expression, { isFunction: params.isFunction, world: params.world }, parseArgument(params.arg));
+ return { value: serializeResult(value) };
}
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 f2773bc7c4..6242949f5a 100644
--- a/packages/playwright-core/src/server/dispatchers/frameDispatcher.ts
+++ b/packages/playwright-core/src/server/dispatchers/frameDispatcher.ts
@@ -84,11 +84,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, serialize: params.serialize }, parseArgument(params.arg)), params) };
+ return { value: serializeResult(await this._frame.evaluateExpression(progress, params.expression, { isFunction: params.isFunction, world: params.world }, parseArgument(params.arg))) };
}
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, serialize: params.serialize }, parseArgument(params.arg))) };
+ return { handle: ElementHandleDispatcher.fromJSOrElementHandle(this, await this._frame.evaluateExpressionHandle(progress, params.expression, { isFunction: params.isFunction }, 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 6c489f8790..c2aa99a892 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, serialize: params.serialize }, parseArgument(params.arg));
- return { value: serializeResult(jsHandle, params) };
+ const jsHandle = await this._object.evaluateExpression(progress, params.expression, { isFunction: params.isFunction }, parseArgument(params.arg));
+ return { value: serializeResult(jsHandle) };
}
async evaluateExpressionHandle(params: channels.JSHandleEvaluateExpressionHandleParams, progress: Progress): Promise<channels.JSHandleEvaluateExpressionHandleResult> {
- const jsHandle = await this._object.evaluateExpressionHandle(progress, params.expression, { isFunction: params.isFunction, serialize: params.serialize }, parseArgument(params.arg));
+ const jsHandle = await this._object.evaluateExpressionHandle(progress, params.expression, { isFunction: params.isFunction }, 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, options?: { serialize?: ('Map' | 'Set')[] }): channels.SerializedValue {
- return serializeValue(arg, value => ({ fallThrough: value }), options);
+export function serializeResult(arg: any): channels.SerializedValue {
+ return serializeValue(arg, value => ({ fallThrough: value }));
}
diff --git a/packages/playwright-core/src/server/dispatchers/pageDispatcher.ts b/packages/playwright-core/src/server/dispatchers/pageDispatcher.ts
index 59295be3ea..766da99153 100644
--- a/packages/playwright-core/src/server/dispatchers/pageDispatcher.ts
+++ b/packages/playwright-core/src/server/dispatchers/pageDispatcher.ts
@@ -601,7 +601,7 @@ export class BindingCallDispatcher extends Dispatcher<SdkObject, channels.Bindin
super(scope, new SdkObject(scope._object, 'bindingCall'), 'BindingCall', {
frame: frameDispatcher,
name,
- args: args.map(arg => serializeResult(arg)),
+ args: args.map(serializeResult),
});
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 551e9eb368..35c364705b 100644
--- a/packages/playwright-core/src/server/dom.ts
+++ b/packages/playwright-core/src/server/dom.ts
@@ -84,11 +84,11 @@ export class FrameExecutionContext extends js.ExecutionContext {
return js.evaluate(this, false /* returnByValue */, pageFunction, arg);
}
- async evaluateExpression(expression: string, options: { isFunction?: boolean, serialize?: ('Map' | 'Set')[] }, arg?: any): Promise<any> {
+ async evaluateExpression(expression: string, options: { isFunction?: boolean }, arg?: any): Promise<any> {
return js.evaluateExpression(this, expression, { ...options, returnByValue: true }, arg);
}
- async evaluateExpressionHandle(expression: string, options: { isFunction?: boolean, serialize?: ('Map' | 'Set')[] }, arg?: any): Promise<js.JSHandle<any>> {
+ async evaluateExpressionHandle(expression: string, options: { isFunction?: boolean }, arg?: any): Promise<js.JSHandle<any>> {
return js.evaluateExpression(this, expression, { ...options, returnByValue: false }, arg);
}
@@ -882,13 +882,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, serialize?: ('Map' | 'Set')[] }, arg: any): Promise<any> {
+ override async evaluateExpression(progress: Progress, expression: string, options: { isFunction?: boolean, world?: types.World }, arg: any): Promise<any> {
return await progress.race(this.internalEvaluateExpression(expression, options, arg));
}
- override async internalEvaluateExpression(expression: string, options: { isFunction?: boolean, world?: types.World, serialize?: ('Map' | 'Set')[] }, arg: any): Promise<any> {
+ override async internalEvaluateExpression(expression: string, options: { isFunction?: boolean, world?: types.World }, 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, serialize: options.serialize, returnByValue: true }, this, arg);
+ return await js.evaluateExpression(context, expression, { isFunction: options.isFunction, returnByValue: true }, this, arg);
}
async evalOnSelector(progress: Progress, target: types.SelectorTarget, 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 3bd1af6843..3e635e85f5 100644
--- a/packages/playwright-core/src/server/frames.ts
+++ b/packages/playwright-core/src/server/frames.ts
@@ -814,21 +814,21 @@ export class Frame extends SdkObject<FrameEventMap> {
return this.context('utility');
}
- async evaluateExpression(progress: Progress, expression: string, options: { isFunction?: boolean, world?: types.World, serialize?: ('Map' | 'Set')[] } = {}, arg?: any): Promise<any> {
+ async evaluateExpression(progress: Progress, expression: string, options: { isFunction?: boolean, world?: types.World } = {}, arg?: any): Promise<any> {
return await progress.race(this._evaluateExpression(expression, options, arg));
}
- private async _evaluateExpression(expression: string, options: { isFunction?: boolean, world?: types.World, serialize?: ('Map' | 'Set')[] } = {}, arg?: any): Promise<any> {
+ private async _evaluateExpression(expression: string, options: { isFunction?: boolean, world?: types.World } = {}, 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, serialize?: ('Map' | 'Set')[] } = {}, arg?: any): Promise<js.JSHandle<any>> {
+ async evaluateExpressionHandle(progress: Progress, expression: string, options: { isFunction?: boolean, world?: types.World } = {}, 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, serialize?: ('Map' | 'Set')[] } = {}, arg?: any): Promise<js.JSHandle<any>> {
+ private async _evaluateExpressionHandle(expression: string, options: { isFunction?: boolean, world?: types.World } = {}, 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 420d4ec669..adaae310f1 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, serialize?: ('Map' | 'Set')[] }, arg: any) {
+ async evaluateExpression(progress: Progress, expression: string, options: { isFunction?: boolean }, arg: any) {
return await progress.race(this.internalEvaluateExpression(expression, options, arg));
}
- async evaluateExpressionHandle(progress: Progress, expression: string, options: { isFunction?: boolean, serialize?: ('Map' | 'Set')[] }, arg: any): Promise<JSHandle<any>> {
+ async evaluateExpressionHandle(progress: Progress, expression: string, options: { isFunction?: boolean }, 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, serialize?: ('Map' | 'Set')[] }, arg: any) {
+ async internalEvaluateExpression(expression: string, options: { isFunction?: boolean }, arg: any) {
return await evaluateExpression(this._context, expression, { ...options, returnByValue: true }, this, arg);
}
- private async _evaluateExpressionHandle(expression: string, options: { isFunction?: boolean, serialize?: ('Map' | 'Set')[] }, arg: any): Promise<JSHandle<any>> {
+ private async _evaluateExpressionHandle(expression: string, options: { isFunction?: boolean }, 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, serialize?: ('Map' | 'Set')[] }, ...args: any[]): Promise<any> {
+export async function evaluateExpression(context: ExecutionContext, expression: string, options: { returnByValue?: boolean, isFunction?: boolean }, ...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, options.serialize, expression, args.length, ...args];
+ const utilityScriptValues = [options.isFunction, options.returnByValue, 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 a5b6c922a7..3b671e99ac 100644
--- a/packages/playwright-core/types/structs.d.ts
+++ b/packages/playwright-core/types/structs.d.ts
@@ -27,8 +27,6 @@ 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]> } :
@@ -36,8 +34,6 @@ 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 561dd5dbeb..b86402670e 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, serialize?: ('Map'|'Set')[], world?: 'main'|'utility' }): Promise<R>;
+ evaluate<R, Arg>(pageFunction: PageFunction<Arg, R>, arg: Arg, options?: { exposeFunctions?: boolean, 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, serialize?: ('Map'|'Set')[], world?: 'main'|'utility' }): Promise<R>;
+ evaluate<R>(pageFunction: PageFunction<void, R>, arg?: any, options?: { exposeFunctions?: boolean, 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, serialize?: ('Map'|'Set')[] }): Promise<SmartHandle<R>>;
+ evaluateHandle<R, Arg>(pageFunction: PageFunction<Arg, R>, arg: Arg, options?: { exposeFunctions?: boolean }): 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, serialize?: ('Map'|'Set')[] }): Promise<SmartHandle<R>>;
+ evaluateHandle<R>(pageFunction: PageFunction<void, R>, arg?: any, options?: { exposeFunctions?: boolean }): Promise<SmartHandle<R>>;
/**
* Adds a script which would be evaluated in one of the following scenarios:
@@ -5988,7 +5988,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, serialize?: ('Map'|'Set')[], world?: 'main'|'utility' }): Promise<R>;
+ evaluate<R, Arg>(pageFunction: PageFunction<Arg, R>, arg: Arg, options?: { exposeFunctions?: boolean, world?: 'main'|'utility' }): Promise<R>;
/**
* Returns the return value of
* [`pageFunction`](https://playwright.dev/docs/api/class-frame#frame-evaluate-option-expression).
@@ -6037,7 +6037,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, serialize?: ('Map'|'Set')[], world?: 'main'|'utility' }): Promise<R>;
+ evaluate<R>(pageFunction: PageFunction<void, R>, arg?: any, options?: { exposeFunctions?: boolean, world?: 'main'|'utility' }): Promise<R>;
/**
* Returns the return value of
@@ -6087,7 +6087,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, serialize?: ('Map'|'Set')[] }): Promise<SmartHandle<R>>;
+ evaluateHandle<R, Arg>(pageFunction: PageFunction<Arg, R>, arg: Arg, options?: { exposeFunctions?: boolean }): Promise<SmartHandle<R>>;
/**
* Returns the return value of
* [`pageFunction`](https://playwright.dev/docs/api/class-frame#frame-evaluate-handle-option-expression) as a
@@ -6136,7 +6136,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, serialize?: ('Map'|'Set')[] }): Promise<SmartHandle<R>>;
+ evaluateHandle<R>(pageFunction: PageFunction<void, R>, arg?: any, options?: { exposeFunctions?: boolean }): Promise<SmartHandle<R>>;
/**
* **NOTE** Use locator-based [frame.locator(selector[, options])](https://playwright.dev/docs/api/class-frame#frame-locator)
@@ -12101,7 +12101,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, serialize?: ('Map'|'Set')[] }): Promise<R>;
+ evaluate<R, Arg, O extends T = T>(pageFunction: PageFunctionOn<O, Arg, R>, arg: Arg, options?: { exposeFunctions?: boolean }): Promise<R>;
/**
* Returns the return value of
* [`pageFunction`](https://playwright.dev/docs/api/class-elementhandle#element-handle-evaluate-option-expression).
@@ -12124,7 +12124,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, serialize?: ('Map'|'Set')[] }): Promise<R>;
+ evaluate<R, O extends T = T>(pageFunction: PageFunctionOn<O, void, R>, arg?: any, options?: { exposeFunctions?: boolean }): Promise<R>;
/**
* Returns the return value of
@@ -12148,7 +12148,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, serialize?: ('Map'|'Set')[] }): Promise<SmartHandle<R>>;
+ evaluateHandle<R, Arg, O extends T = T>(pageFunction: PageFunctionOn<O, Arg, R>, arg: Arg, options?: { exposeFunctions?: boolean }): Promise<SmartHandle<R>>;
/**
* Returns the return value of
* [`pageFunction`](https://playwright.dev/docs/api/class-elementhandle#element-handle-evaluate-handle-option-expression)
@@ -12171,7 +12171,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, serialize?: ('Map'|'Set')[] }): Promise<SmartHandle<R>>;
+ evaluateHandle<R, O extends T = T>(pageFunction: PageFunctionOn<O, void, R>, arg?: any, options?: { exposeFunctions?: boolean }): Promise<SmartHandle<R>>;
/**
* Returns a JSON representation of the object. If the object has a `toJSON` function, it **will not be called**.
@@ -14366,7 +14366,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, serialize?: ('Map'|'Set')[], 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, 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.
@@ -14400,7 +14400,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, serialize?: ('Map'|'Set')[] }): 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 }): 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 ddd84a685b..4ea9c43c3b 100644
--- a/packages/playwright/src/index.ts
+++ b/packages/playwright/src/index.ts
@@ -513,7 +513,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, serialize: ['Map', 'Set'] });
+ }, params, { exposeFunctions: true });
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 e0bea36e2e..dfac57e523 100644
--- a/packages/protocol/spec/frame.yml
+++ b/packages/protocol/spec/frame.yml
@@ -339,13 +339,6 @@ Frame:
expression: string
isFunction: boolean?
arg: SerializedArgument
- serialize:
- type: array?
- items:
- type: enum
- literals:
- - Map
- - Set
world:
type: enum?
literals:
@@ -363,13 +356,6 @@ 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 15e17c3ecf..00e581fe65 100644
--- a/packages/protocol/spec/handles.yml
+++ b/packages/protocol/spec/handles.yml
@@ -29,13 +29,6 @@ JSHandle:
expression: string
isFunction: boolean?
arg: SerializedArgument
- serialize:
- type: array?
- items:
- type: enum
- literals:
- - Map
- - Set
world:
type: enum?
literals:
@@ -53,13 +46,6 @@ 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 0b82544a8d..e40ee4803c 100644
--- a/packages/protocol/spec/serialized.yml
+++ b/packages/protocol/spec/serialized.yml
@@ -77,18 +77,6 @@ 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 ef59330e6e..0b245c1b8f 100644
--- a/packages/protocol/src/serializers.ts
+++ b/packages/protocol/src/serializers.ts
@@ -111,20 +111,6 @@ 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');
@@ -142,11 +128,10 @@ 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, options: { serialize?: ('Map' | 'Set')[] } = {}): SerializedValue {
- return innerSerializeValue(value, handleSerializer, { lastId: 0, visited: new Map(), serialize: options.serialize }, []);
+export function serializeValue(value: any, handleSerializer: (value: any) => HandleOrValue): SerializedValue {
+ return innerSerializeValue(value, handleSerializer, { lastId: 0, visited: new Map() }, []);
}
export function serializePlainValue(arg: any): SerializedValue {
@@ -199,23 +184,6 @@ 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 1d230fda89..084e3c13e7 100644
--- a/packages/protocol/src/structs.d.ts
+++ b/packages/protocol/src/structs.d.ts
@@ -297,11 +297,6 @@ 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 a1a8a1488e..52f8b5ac9e 100644
--- a/packages/protocol/src/validator.ts
+++ b/packages/protocol/src/validator.ts
@@ -1403,7 +1403,6 @@ 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({
@@ -1413,7 +1412,6 @@ scheme.FrameEvaluateExpressionHandleParams = tObject({
expression: tString,
isFunction: tOptional(tBoolean),
arg: tType('SerializedArgument'),
- serialize: tOptional(tArray(tEnum(['Map', 'Set']))),
});
scheme.FrameEvaluateExpressionHandleResult = tObject({
handle: tChannel(['ElementHandle', 'JSHandle']),
@@ -1719,7 +1717,6 @@ 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');
@@ -1731,7 +1728,6 @@ scheme.JSHandleEvaluateExpressionHandleParams = tObject({
expression: tString,
isFunction: tOptional(tBoolean),
arg: tType('SerializedArgument'),
- serialize: tOptional(tArray(tEnum(['Map', 'Set']))),
});
scheme.ElementHandleEvaluateExpressionHandleParams = tType('JSHandleEvaluateExpressionHandleParams');
scheme.JSHandleEvaluateExpressionHandleResult = tObject({
@@ -3086,11 +3082,6 @@ 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
deleted file mode 100644
index 1c1f7e63b9..0000000000
--- a/tests/page/page-evaluate-serialization.spec.ts
+++ /dev/null
@@ -1,63 +0,0 @@
-/**
- * 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
deleted file mode 100644
index 0927f92bad..0000000000
--- a/tests/playwright-test/playwright.mount.spec.ts
+++ /dev/null
@@ -1,68 +0,0 @@
-/**
- * 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 0b186e0353..ebde294dff 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, 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>;
+ 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>;
- 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>>;
+ 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>>;
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, 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>;
+ 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>;
- 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>>;
+ 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>>;
$<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, 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>;
+ 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>;
- 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>>;
+ 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>>;
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, 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>>;
+ 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>>;
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 68069e258b..3d098fc0f4 100644
--- a/utils/generate_types/test/test.ts
+++ b/utils/generate_types/test/test.ts
@@ -336,18 +336,6 @@ 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();
@@ -1061,3 +1049,4 @@ import {
Geolocation,
HTTPCredentials,
} from 'playwright';
+