Skip to content

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

chore(protocol): make timeout a protocol-level field (#41712)

Simon Knott33173da843d9
diff --git a/packages/playwright-core/src/client/android.ts b/packages/playwright-core/src/client/android.ts
index 62db6ef1cd..5b0e179890 100644
--- a/packages/playwright-core/src/client/android.ts
+++ b/packages/playwright-core/src/client/android.ts
@@ -25,7 +25,7 @@ import { ChannelOwner } from './channelOwner';
import { TargetClosedError, isTargetClosedError } from './errors';
import { Events } from './events';
import { Waiter } from './waiter';
-import { TimeoutSettings } from './timeoutSettings';
+import { TimeoutSettings, kNoTimeout } from './timeoutSettings';
import { connectToEndpoint } from './connect';
import type { Page } from './page';
@@ -57,7 +57,7 @@ export class Android extends ChannelOwner<channels.AndroidChannel> implements ap
}
async devices(options: { port?: number } = {}): Promise<AndroidDevice[]> {
- const { devices } = await this._channel.devices(options, undefined);
+ const { devices } = await this._channel.devices(options, kNoTimeout);
return devices.map(d => AndroidDevice.from(d));
}
@@ -71,8 +71,8 @@ export class Android extends ChannelOwner<channels.AndroidChannel> implements ap
return await this._wrapApiCall(async () => {
const deadline = options.timeout ? monotonicTime() + options.timeout : 0;
const headers = { 'x-playwright-browser': 'android', ...options.headers };
- const connectParams: channels.LocalUtilsConnectParams = { endpoint, headers, slowMo: options.slowMo, timeout: options.timeout || 0 };
- const connection = await connectToEndpoint(this._connection, connectParams);
+ const connectParams: channels.LocalUtilsConnectParams = { endpoint, headers, slowMo: options.slowMo };
+ const connection = await connectToEndpoint(this._connection, connectParams, { signal: undefined, timeout: options.timeout || 0 });
let device: AndroidDevice;
connection.on('close', () => {
@@ -166,11 +166,11 @@ export class AndroidDevice extends ChannelOwner<channels.AndroidDeviceChannel> i
}
async wait(selector: api.AndroidSelector, options: { state?: 'gone' } & types.TimeoutOptions = {}) {
- await this._channel.wait({ androidSelector: toSelectorChannel(selector), ...options, timeout: this._timeoutSettings.timeout(options) }, options.signal);
+ await this._channel.wait({ androidSelector: toSelectorChannel(selector), ...options }, this._timeoutSettings.timeout(options));
}
async fill(selector: api.AndroidSelector, text: string, options: types.TimeoutOptions = {}) {
- await this._channel.fill({ androidSelector: toSelectorChannel(selector), text, ...options, timeout: this._timeoutSettings.timeout(options) }, options.signal);
+ await this._channel.fill({ androidSelector: toSelectorChannel(selector), text, ...options }, this._timeoutSettings.timeout(options));
}
async press(selector: api.AndroidSelector, key: api.AndroidKey, options: types.TimeoutOptions = {}) {
@@ -179,43 +179,43 @@ export class AndroidDevice extends ChannelOwner<channels.AndroidDeviceChannel> i
}
async tap(selector: api.AndroidSelector, options: { duration?: number } & types.TimeoutOptions = {}) {
- await this._channel.tap({ androidSelector: toSelectorChannel(selector), ...options, timeout: this._timeoutSettings.timeout(options) }, options.signal);
+ await this._channel.tap({ androidSelector: toSelectorChannel(selector), ...options }, this._timeoutSettings.timeout(options));
}
async drag(selector: api.AndroidSelector, dest: types.Point, options: SpeedOptions & types.TimeoutOptions = {}) {
- await this._channel.drag({ androidSelector: toSelectorChannel(selector), dest, ...options, timeout: this._timeoutSettings.timeout(options) }, options.signal);
+ await this._channel.drag({ androidSelector: toSelectorChannel(selector), dest, ...options }, this._timeoutSettings.timeout(options));
}
async fling(selector: api.AndroidSelector, direction: Direction, options: SpeedOptions & types.TimeoutOptions = {}) {
- await this._channel.fling({ androidSelector: toSelectorChannel(selector), direction, ...options, timeout: this._timeoutSettings.timeout(options) }, options.signal);
+ await this._channel.fling({ androidSelector: toSelectorChannel(selector), direction, ...options }, this._timeoutSettings.timeout(options));
}
async longTap(selector: api.AndroidSelector, options: types.TimeoutOptions = {}) {
- await this._channel.longTap({ androidSelector: toSelectorChannel(selector), ...options, timeout: this._timeoutSettings.timeout(options) }, options.signal);
+ await this._channel.longTap({ androidSelector: toSelectorChannel(selector), ...options }, this._timeoutSettings.timeout(options));
}
async pinchClose(selector: api.AndroidSelector, percent: number, options: SpeedOptions & types.TimeoutOptions = {}) {
- await this._channel.pinchClose({ androidSelector: toSelectorChannel(selector), percent, ...options, timeout: this._timeoutSettings.timeout(options) }, options.signal);
+ await this._channel.pinchClose({ androidSelector: toSelectorChannel(selector), percent, ...options }, this._timeoutSettings.timeout(options));
}
async pinchOpen(selector: api.AndroidSelector, percent: number, options: SpeedOptions & types.TimeoutOptions = {}) {
- await this._channel.pinchOpen({ androidSelector: toSelectorChannel(selector), percent, ...options, timeout: this._timeoutSettings.timeout(options) }, options.signal);
+ await this._channel.pinchOpen({ androidSelector: toSelectorChannel(selector), percent, ...options }, this._timeoutSettings.timeout(options));
}
async scroll(selector: api.AndroidSelector, direction: Direction, percent: number, options: SpeedOptions & types.TimeoutOptions = {}) {
- await this._channel.scroll({ androidSelector: toSelectorChannel(selector), direction, percent, ...options, timeout: this._timeoutSettings.timeout(options) }, options.signal);
+ await this._channel.scroll({ androidSelector: toSelectorChannel(selector), direction, percent, ...options }, this._timeoutSettings.timeout(options));
}
async swipe(selector: api.AndroidSelector, direction: Direction, percent: number, options: SpeedOptions & types.TimeoutOptions = {}) {
- await this._channel.swipe({ androidSelector: toSelectorChannel(selector), direction, percent, ...options, timeout: this._timeoutSettings.timeout(options) }, options.signal);
+ await this._channel.swipe({ androidSelector: toSelectorChannel(selector), direction, percent, ...options }, this._timeoutSettings.timeout(options));
}
async info(selector: api.AndroidSelector): Promise<api.AndroidElementInfo> {
- return (await this._channel.info({ androidSelector: toSelectorChannel(selector) }, undefined)).info;
+ return (await this._channel.info({ androidSelector: toSelectorChannel(selector) }, kNoTimeout)).info;
}
async screenshot(options: { path?: string } = {}): Promise<Buffer> {
- const { binary } = await this._channel.screenshot({}, undefined);
+ const { binary } = await this._channel.screenshot({}, kNoTimeout);
if (options.path)
await fs.promises.writeFile(options.path, binary);
return binary;
@@ -230,7 +230,7 @@ export class AndroidDevice extends ChannelOwner<channels.AndroidDeviceChannel> i
if (this._shouldCloseConnectionOnClose)
this._connection.close();
else
- await this._channel.close({}, undefined);
+ await this._channel.close({}, kNoTimeout);
} catch (e) {
if (isTargetClosedError(e))
return;
@@ -243,25 +243,25 @@ export class AndroidDevice extends ChannelOwner<channels.AndroidDeviceChannel> i
}
async shell(command: string): Promise<Buffer> {
- const { result } = await this._channel.shell({ command }, undefined);
+ const { result } = await this._channel.shell({ command }, kNoTimeout);
return result;
}
async open(command: string): Promise<AndroidSocket> {
- return AndroidSocket.from((await this._channel.open({ command }, undefined)).socket);
+ return AndroidSocket.from((await this._channel.open({ command }, kNoTimeout)).socket);
}
async installApk(file: string | Buffer, options?: { args: string[] }): Promise<void> {
- await this._channel.installApk({ file: await loadFile(file), args: options && options.args }, undefined);
+ await this._channel.installApk({ file: await loadFile(file), args: options && options.args }, kNoTimeout);
}
async push(file: string | Buffer, path: string, options?: { mode: number }): Promise<void> {
- await this._channel.push({ file: await loadFile(file), path, mode: options ? options.mode : undefined }, undefined);
+ await this._channel.push({ file: await loadFile(file), path, mode: options ? options.mode : undefined }, kNoTimeout);
}
async launchBrowser(options: types.BrowserContextOptions & { pkg?: string } = {}): Promise<BrowserContext> {
const contextOptions = await prepareBrowserContextParams(options);
- const result = await this._channel.launchBrowser(contextOptions, undefined);
+ const result = await this._channel.launchBrowser(contextOptions, kNoTimeout);
const context = BrowserContext.from(result.context);
const selectors = this._android._playwright.selectors;
selectors._contextsForSelectors.add(context);
@@ -272,9 +272,8 @@ export class AndroidDevice extends ChannelOwner<channels.AndroidDeviceChannel> i
async waitForEvent(event: string, optionsOrPredicate: types.WaitForEventOptions = {}): Promise<any> {
return await this._wrapApiCall(async () => {
- const timeout = this._timeoutSettings.timeout(typeof optionsOrPredicate === 'function' ? {} : optionsOrPredicate);
+ const { timeout, signal } = this._timeoutSettings.timeout(typeof optionsOrPredicate === 'function' ? {} : optionsOrPredicate);
const predicate = typeof optionsOrPredicate === 'function' ? optionsOrPredicate : optionsOrPredicate.predicate;
- const signal = typeof optionsOrPredicate === 'function' ? undefined : (optionsOrPredicate as types.TimeoutOptions).signal;
const waiter = Waiter.createForEvent(this, event);
waiter.rejectOnTimeout(timeout, `Timeout ${timeout}ms exceeded while waiting for event "${event}"`);
waiter.rejectOnSignal(signal);
@@ -299,11 +298,11 @@ export class AndroidSocket extends ChannelOwner<channels.AndroidSocketChannel> i
}
async write(data: Buffer): Promise<void> {
- await this._channel.write({ data }, undefined);
+ await this._channel.write({ data }, kNoTimeout);
}
async close(): Promise<void> {
- await this._channel.close({}, undefined);
+ await this._channel.close({}, kNoTimeout);
}
async [Symbol.asyncDispose]() {
@@ -325,23 +324,23 @@ export class AndroidInput implements api.AndroidInput {
}
async type(text: string) {
- await this._device._channel.inputType({ text }, undefined);
+ await this._device._channel.inputType({ text }, kNoTimeout);
}
async press(key: api.AndroidKey) {
- await this._device._channel.inputPress({ key }, undefined);
+ await this._device._channel.inputPress({ key }, kNoTimeout);
}
async tap(point: types.Point) {
- await this._device._channel.inputTap({ point }, undefined);
+ await this._device._channel.inputTap({ point }, kNoTimeout);
}
async swipe(from: types.Point, segments: types.Point[], steps: number) {
- await this._device._channel.inputSwipe({ segments, steps }, undefined);
+ await this._device._channel.inputSwipe({ segments, steps }, kNoTimeout);
}
async drag(from: types.Point, to: types.Point, steps: number) {
- await this._device._channel.inputDrag({ from, to, steps }, undefined);
+ await this._device._channel.inputDrag({ from, to, steps }, kNoTimeout);
}
}
@@ -425,7 +424,7 @@ export class AndroidWebView extends EventEmitter implements api.AndroidWebView {
}
private async _fetchPage(): Promise<Page> {
- const { context } = await this._device._channel.connectToWebView({ socketName: this._data.socketName }, undefined);
+ const { context } = await this._device._channel.connectToWebView({ socketName: this._data.socketName }, kNoTimeout);
return BrowserContext.from(context).pages()[0];
}
}
diff --git a/packages/playwright-core/src/client/artifact.ts b/packages/playwright-core/src/client/artifact.ts
index add07a472e..f08357e774 100644
--- a/packages/playwright-core/src/client/artifact.ts
+++ b/packages/playwright-core/src/client/artifact.ts
@@ -19,6 +19,7 @@ import fs from 'fs';
import { ChannelOwner } from './channelOwner';
import { Stream } from './stream';
import { mkdirIfNeeded } from './fileUtils';
+import { kNoTimeout } from './timeoutSettings';
import type * as channels from './channels';
import type { Readable } from 'stream';
@@ -31,16 +32,16 @@ export class Artifact extends ChannelOwner<channels.ArtifactChannel> {
async pathAfterFinished(): Promise<string> {
if (this._connection.isRemote())
throw new Error(`Path is not available when connecting remotely. Use saveAs() to save a local copy.`);
- return (await this._channel.pathAfterFinished({}, undefined)).value;
+ return (await this._channel.pathAfterFinished({}, kNoTimeout)).value;
}
async saveAs(path: string): Promise<void> {
if (!this._connection.isRemote()) {
- await this._channel.saveAs({ path }, undefined);
+ await this._channel.saveAs({ path }, kNoTimeout);
return;
}
- const result = await this._channel.saveAsStream({}, undefined);
+ const result = await this._channel.saveAsStream({}, kNoTimeout);
const stream = Stream.from(result.stream);
await mkdirIfNeeded(path);
await new Promise((resolve, reject) => {
@@ -51,11 +52,11 @@ export class Artifact extends ChannelOwner<channels.ArtifactChannel> {
}
async failure(): Promise<string | null> {
- return (await this._channel.failure({}, undefined)).error || null;
+ return (await this._channel.failure({}, kNoTimeout)).error || null;
}
async createReadStream(): Promise<Readable> {
- const result = await this._channel.stream({}, undefined);
+ const result = await this._channel.stream({}, kNoTimeout);
const stream = Stream.from(result.stream);
return stream.stream();
}
@@ -75,10 +76,10 @@ export class Artifact extends ChannelOwner<channels.ArtifactChannel> {
}
async cancel(): Promise<void> {
- return await this._channel.cancel({}, undefined);
+ return await this._channel.cancel({}, kNoTimeout);
}
async delete(): Promise<void> {
- return await this._channel.delete({}, undefined);
+ return await this._channel.delete({}, kNoTimeout);
}
}
diff --git a/packages/playwright-core/src/client/browser.ts b/packages/playwright-core/src/client/browser.ts
index 803a53f969..368e518bb9 100644
--- a/packages/playwright-core/src/client/browser.ts
+++ b/packages/playwright-core/src/client/browser.ts
@@ -23,6 +23,7 @@ import { ChannelOwner } from './channelOwner';
import { isTargetClosedError } from './errors';
import { Events } from './events';
import { mkdirIfNeeded } from './fileUtils';
+import { kNoTimeout } from './timeoutSettings';
import type { BrowserType } from './browserType';
import type { Page } from './page';
@@ -75,14 +76,14 @@ export class Browser extends ChannelOwner<channels.BrowserChannel> implements ap
for (const page of context.pages())
page._onClose();
context._onClose();
- await this._channel.disconnectFromReusedContext({ reason }, undefined);
+ await this._channel.disconnectFromReusedContext({ reason }, kNoTimeout);
}
async _innerNewContext(userOptions: BrowserContextOptions = {}, forReuse: boolean): Promise<BrowserContext> {
const options = this._browserType._playwright.selectors._withSelectorOptions(userOptions);
await this._instrumentation.runBeforeCreateBrowserContext(options);
const contextOptions = await prepareBrowserContextParams(options);
- const response = forReuse ? await this._channel.newContextForReuse(contextOptions, undefined) : await this._channel.newContext(contextOptions, undefined);
+ const response = forReuse ? await this._channel.newContextForReuse(contextOptions, kNoTimeout) : await this._channel.newContext(contextOptions, kNoTimeout);
const context = BrowserContext.from(response.context);
if (forReuse)
context._forReuse = true;
@@ -132,12 +133,12 @@ export class Browser extends ChannelOwner<channels.BrowserChannel> implements ap
}
async bind(title: string, options: { workspaceDir?: string, metadata?: Record<string, any>, host?: string, port?: number } = {}): Promise<{ endpoint: string }> {
- const { endpoint } = await this._channel.startServer({ title, ...options }, undefined);
+ const { endpoint } = await this._channel.startServer({ title, ...options }, kNoTimeout);
return { endpoint };
}
async unbind(): Promise<void> {
- await this._channel.stopServer({}, undefined);
+ await this._channel.stopServer({}, kNoTimeout);
}
async newPage(options: BrowserContextOptions = {}): Promise<Page> {
@@ -155,16 +156,16 @@ export class Browser extends ChannelOwner<channels.BrowserChannel> implements ap
}
async newBrowserCDPSession(): Promise<api.CDPSession> {
- return CDPSession.from((await this._channel.newBrowserCDPSession({}, undefined)).session);
+ return CDPSession.from((await this._channel.newBrowserCDPSession({}, kNoTimeout)).session);
}
async startTracing(page?: Page, options: { path?: string; screenshots?: boolean; categories?: string[]; } = {}) {
this._path = options.path;
- await this._channel.startTracing({ ...options, page: page ? page._channel : undefined }, undefined);
+ await this._channel.startTracing({ ...options, page: page ? page._channel : undefined }, kNoTimeout);
}
async stopTracing(): Promise<Buffer> {
- const artifact = Artifact.from((await this._channel.stopTracing({}, undefined)).artifact);
+ const artifact = Artifact.from((await this._channel.stopTracing({}, kNoTimeout)).artifact);
const buffer = await artifact.readIntoBuffer();
await artifact.delete();
if (this._path) {
@@ -185,7 +186,7 @@ export class Browser extends ChannelOwner<channels.BrowserChannel> implements ap
if (this._shouldCloseConnectionOnClose)
this._connection.close();
else
- await this._channel.close(options, undefined);
+ await this._channel.close(options, kNoTimeout);
await this._closedPromise;
} catch (e) {
if (isTargetClosedError(e))
diff --git a/packages/playwright-core/src/client/browserContext.ts b/packages/playwright-core/src/client/browserContext.ts
index 70ada2e326..89c160f789 100644
--- a/packages/playwright-core/src/client/browserContext.ts
+++ b/packages/playwright-core/src/client/browserContext.ts
@@ -43,10 +43,10 @@ import { Tracing } from './tracing';
import { Waiter } from './waiter';
import { WebError } from './webError';
import { Worker } from './worker';
-import { TimeoutSettings } from './timeoutSettings';
+import { TimeoutSettings, kNoTimeout } from './timeoutSettings';
import { mkdirIfNeeded } from './fileUtils';
-import type { BrowserContextOptions, Headers, SetStorageState, StorageState, TimeoutOptions, WaitForEventOptions } from './types';
+import type { BrowserContextOptions, Headers, SetStorageState, StorageState, WaitForEventOptions } from './types';
import type * as structs from '../../types/structs';
import type * as api from '../../types/types';
import type { URLMatch } from '@isomorphic/urlMatch';
@@ -149,9 +149,9 @@ export class BrowserContext extends ChannelOwner<channels.BrowserContextChannel>
// a) removing "dialog" listener subscription (client->server)
// b) actual "dialog" event (server->client)
if (dialogObject.type() === 'beforeunload')
- dialog.accept({}, undefined).catch(() => {});
+ dialog.accept({}, kNoTimeout).catch(() => {});
else
- dialog.dismiss({}, undefined).catch(() => {});
+ dialog.dismiss({}, kNoTimeout).catch(() => {});
}
});
this._channel.on('request', ({ request, page }) => this._onRequest(network.Request.from(request), Page.fromNullable(page)));
@@ -304,7 +304,7 @@ export class BrowserContext extends ChannelOwner<channels.BrowserContextChannel>
async newPage(): Promise<Page> {
if (this._ownerPage)
throw new Error('Please use browser.newContext()');
- return Page.from((await this._channel.newPage({}, undefined)).page);
+ return Page.from((await this._channel.newPage({}, kNoTimeout)).page);
}
async cookies(urls?: string | string[]): Promise<network.NetworkCookie[]> {
@@ -312,11 +312,11 @@ export class BrowserContext extends ChannelOwner<channels.BrowserContextChannel>
urls = [];
if (urls && typeof urls === 'string')
urls = [urls];
- return (await this._channel.cookies({ urls: urls as string[] }, undefined)).cookies;
+ return (await this._channel.cookies({ urls: urls as string[] }, kNoTimeout)).cookies;
}
async addCookies(cookies: network.SetNetworkCookieParam[]): Promise<void> {
- await this._channel.addCookies({ cookies }, undefined);
+ await this._channel.addCookies({ cookies }, kNoTimeout);
}
async clearCookies(options: network.ClearNetworkCookieOptions = {}): Promise<void> {
@@ -330,47 +330,47 @@ export class BrowserContext extends ChannelOwner<channels.BrowserContextChannel>
path: isString(options.path) ? options.path : undefined,
pathRegexSource: isRegExp(options.path) ? options.path.source : undefined,
pathRegexFlags: isRegExp(options.path) ? options.path.flags : undefined,
- }, undefined);
+ }, kNoTimeout);
}
async grantPermissions(permissions: string[], options?: { origin?: string }): Promise<void> {
- await this._channel.grantPermissions({ permissions, ...options }, undefined);
+ await this._channel.grantPermissions({ permissions, ...options }, kNoTimeout);
}
async clearPermissions(): Promise<void> {
- await this._channel.clearPermissions({}, undefined);
+ await this._channel.clearPermissions({}, kNoTimeout);
}
async setGeolocation(geolocation: { longitude: number, latitude: number, accuracy?: number } | null): Promise<void> {
- await this._channel.setGeolocation({ geolocation: geolocation || undefined }, undefined);
+ await this._channel.setGeolocation({ geolocation: geolocation || undefined }, kNoTimeout);
}
async setExtraHTTPHeaders(headers: Headers): Promise<void> {
network.validateHeaders(headers);
- await this._channel.setExtraHTTPHeaders({ headers: headersObjectToArray(headers) }, undefined);
+ await this._channel.setExtraHTTPHeaders({ headers: headersObjectToArray(headers) }, kNoTimeout);
}
async setOffline(offline: boolean): Promise<void> {
- await this._channel.setOffline({ offline }, undefined);
+ await this._channel.setOffline({ offline }, kNoTimeout);
}
async setHTTPCredentials(httpCredentials: { username: string, password: string } | null): Promise<void> {
- await this._channel.setHTTPCredentials({ httpCredentials: httpCredentials || undefined }, undefined);
+ await this._channel.setHTTPCredentials({ httpCredentials: httpCredentials || undefined }, kNoTimeout);
}
async addInitScript(script: Function | string | { path?: string, content?: string }, arg?: any) {
const source = await evaluationScript(script, arg);
- return DisposableObject.from((await this._channel.addInitScript({ source }, undefined)).disposable);
+ return DisposableObject.from((await this._channel.addInitScript({ source }, kNoTimeout)).disposable);
}
async exposeBinding(name: string, callback: (source: structs.BindingSource, ...args: any[]) => any): Promise<DisposableObject> {
- const result = await this._channel.exposeBinding({ name }, undefined);
+ const result = await this._channel.exposeBinding({ name }, kNoTimeout);
this._bindings.set(name, callback);
return DisposableObject.from(result.disposable);
}
async exposeFunction(name: string, callback: Function): Promise<DisposableObject> {
- const result = await this._channel.exposeBinding({ name }, undefined);
+ const result = await this._channel.exposeBinding({ name }, kNoTimeout);
const binding = (source: structs.BindingSource, ...args: any[]) => callback(...args);
this._bindings.set(name, binding);
return DisposableObject.from(result.disposable);
@@ -435,12 +435,12 @@ export class BrowserContext extends ChannelOwner<channels.BrowserContextChannel>
private async _updateInterceptionPatterns(options: { internal: true } | { title: string }) {
const patterns = network.RouteHandler.prepareInterceptionPatterns(this._routes);
- await this._wrapApiCall(() => this._channel.setNetworkInterceptionPatterns({ patterns }, undefined), options);
+ await this._wrapApiCall(() => this._channel.setNetworkInterceptionPatterns({ patterns }, kNoTimeout), options);
}
private async _updateWebSocketInterceptionPatterns(options: { internal: true } | { title: string }) {
const patterns = network.WebSocketRouteHandler.prepareInterceptionPatterns(this._webSocketRoutes);
- await this._wrapApiCall(() => this._channel.setWebSocketInterceptionPatterns({ patterns }, undefined), options);
+ await this._wrapApiCall(() => this._channel.setWebSocketInterceptionPatterns({ patterns }, kNoTimeout), options);
}
_effectiveCloseReason(): string | undefined {
@@ -449,9 +449,8 @@ export class BrowserContext extends ChannelOwner<channels.BrowserContextChannel>
async waitForEvent(event: string, optionsOrPredicate: WaitForEventOptions = {}): Promise<any> {
return await this._wrapApiCall(async () => {
- const timeout = this._timeoutSettings.timeout(typeof optionsOrPredicate === 'function' ? {} : optionsOrPredicate);
+ const { timeout, signal } = this._timeoutSettings.timeout(typeof optionsOrPredicate === 'function' ? {} : optionsOrPredicate);
const predicate = typeof optionsOrPredicate === 'function' ? optionsOrPredicate : optionsOrPredicate.predicate;
- const signal = typeof optionsOrPredicate === 'function' ? undefined : (optionsOrPredicate as TimeoutOptions).signal;
const waiter = Waiter.createForEvent(this, event);
waiter.rejectOnTimeout(timeout, `Timeout ${timeout}ms exceeded while waiting for event "${event}"`);
waiter.rejectOnSignal(signal);
@@ -464,7 +463,7 @@ export class BrowserContext extends ChannelOwner<channels.BrowserContextChannel>
}
async storageState(options: { path?: string, indexedDB?: boolean, credentials?: boolean } = {}): Promise<StorageState> {
- const state = await this._channel.storageState({ indexedDB: options.indexedDB, credentials: options.credentials }, undefined);
+ const state = await this._channel.storageState({ indexedDB: options.indexedDB, credentials: options.credentials }, kNoTimeout);
if (options.path) {
await mkdirIfNeeded(options.path);
await fs.promises.writeFile(options.path, JSON.stringify(state, undefined, 2), 'utf8');
@@ -474,7 +473,7 @@ export class BrowserContext extends ChannelOwner<channels.BrowserContextChannel>
async setStorageState(storageState: string | SetStorageState): Promise<void> {
const state = await prepareStorageState(storageState);
- await this._channel.setStorageState({ storageState: state }, undefined);
+ await this._channel.setStorageState({ storageState: state }, kNoTimeout);
}
backgroundPages(): Page[] {
@@ -489,7 +488,7 @@ export class BrowserContext extends ChannelOwner<channels.BrowserContextChannel>
// channelOwner.ts's validation messages don't handle the pseudo-union type, so we're explicit here
if (!(page instanceof Page) && !(page instanceof Frame))
throw new Error('page: expected Page or Frame');
- const result = await this._channel.newCDPSession(page instanceof Page ? { page: page._channel } : { frame: page._channel }, undefined);
+ const result = await this._channel.newCDPSession(page instanceof Page ? { page: page._channel } : { frame: page._channel }, kNoTimeout);
return CDPSession.from(result.session);
}
@@ -515,23 +514,23 @@ export class BrowserContext extends ChannelOwner<channels.BrowserContextChannel>
await this.request.dispose(options);
await this._instrumentation.runBeforeCloseBrowserContext(this);
await this.tracing._exportAllHars();
- await this._channel.close(options, undefined);
+ await this._channel.close(options, kNoTimeout);
await this._closedPromise;
}
async _enableRecorder(params: channels.BrowserContextEnableRecorderParams, eventSink?: RecorderEventSink) {
if (eventSink)
this._onRecorderEventSink = eventSink;
- await this._channel.enableRecorder(params, undefined);
+ await this._channel.enableRecorder(params, kNoTimeout);
}
async _disableRecorder() {
this._onRecorderEventSink = undefined;
- await this._channel.disableRecorder({}, undefined);
+ await this._channel.disableRecorder({}, kNoTimeout);
}
async _exposeConsoleApi() {
- await this._channel.exposeConsoleApi({}, undefined);
+ await this._channel.exposeConsoleApi({}, kNoTimeout);
}
}
diff --git a/packages/playwright-core/src/client/browserType.ts b/packages/playwright-core/src/client/browserType.ts
index 9b6d42cc6b..444c315e30 100644
--- a/packages/playwright-core/src/client/browserType.ts
+++ b/packages/playwright-core/src/client/browserType.ts
@@ -74,10 +74,9 @@ export class BrowserType extends ChannelOwner<channels.BrowserTypeChannel> imple
ignoreDefaultArgs: Array.isArray(options.ignoreDefaultArgs) ? options.ignoreDefaultArgs : undefined,
ignoreAllDefaultArgs: !!options.ignoreDefaultArgs && !Array.isArray(options.ignoreDefaultArgs),
env: options.env ? envObjectToArray(options.env) : undefined,
- timeout: new TimeoutSettings().launchTimeout(options),
};
return await this._wrapApiCall(async () => {
- const browser = Browser.from((await this._channel.launch(launchOptions, options.signal)).browser);
+ const browser = Browser.from((await this._channel.launch(launchOptions, new TimeoutSettings().launchTimeout(options))).browser);
browser._connectToBrowserType(this, options, logger);
return browser;
});
@@ -107,10 +106,9 @@ export class BrowserType extends ChannelOwner<channels.BrowserTypeChannel> imple
env: options.env ? envObjectToArray(options.env) : undefined,
channel: options.channel,
userDataDir: (path.isAbsolute(userDataDir) || !userDataDir) ? userDataDir : path.resolve(userDataDir),
- timeout: new TimeoutSettings().launchTimeout(options),
};
const context = await this._wrapApiCall(async () => {
- const result = await this._channel.launchPersistentContext(persistentParams, options.signal);
+ const result = await this._channel.launchPersistentContext(persistentParams, new TimeoutSettings().launchTimeout(options));
const browser = Browser.from(result.browser);
browser._connectToBrowserType(this, options, logger);
const context = BrowserContext.from(result.context);
@@ -168,11 +166,10 @@ export class BrowserType extends ChannelOwner<channels.BrowserTypeChannel> imple
transport: transport as any,
headers: params.headers ? headersObjectToArray(params.headers) : undefined,
slowMo: params.slowMo,
- timeout: new TimeoutSettings().timeout(params),
isLocal: params.isLocal,
noDefaults: params.noDefaults,
artifactsDir: params.artifactsDir,
- }, undefined);
+ }, new TimeoutSettings().timeout(params));
return await this._browserFromConnectResult(result);
}
@@ -189,8 +186,7 @@ export class BrowserType extends ChannelOwner<channels.BrowserTypeChannel> imple
throw new Error('Connecting to workers is only supported in Chromium.');
const result = await this._channel.connectToWorker({
endpoint,
- timeout: new TimeoutSettings().timeout(options),
- }, undefined);
+ }, new TimeoutSettings().timeout(options));
return Worker.from(result.worker);
}
}
diff --git a/packages/playwright-core/src/client/cdpSession.ts b/packages/playwright-core/src/client/cdpSession.ts
index 0353411054..cb861295b6 100644
--- a/packages/playwright-core/src/client/cdpSession.ts
+++ b/packages/playwright-core/src/client/cdpSession.ts
@@ -15,6 +15,7 @@
*/
import { ChannelOwner } from './channelOwner';
+import { kNoTimeout } from './timeoutSettings';
import type * as api from '../../types/types';
import type { Protocol } from '../server/chromium/protocol';
@@ -48,11 +49,11 @@ export class CDPSession extends ChannelOwner<channels.CDPSessionChannel> impleme
method: T,
params?: Protocol.CommandParameters[T]
): Promise<Protocol.CommandReturnValues[T]> {
- const result = await this._channel.send({ method, params }, undefined);
+ const result = await this._channel.send({ method, params }, kNoTimeout);
return result.result as Protocol.CommandReturnValues[T];
}
async detach() {
- return await this._channel.detach({}, undefined);
+ return await this._channel.detach({}, kNoTimeout);
}
}
diff --git a/packages/playwright-core/src/client/channelOwner.ts b/packages/playwright-core/src/client/channelOwner.ts
index 18d1e7ddc7..e2f2856b53 100644
--- a/packages/playwright-core/src/client/channelOwner.ts
+++ b/packages/playwright-core/src/client/channelOwner.ts
@@ -151,19 +151,20 @@ export abstract class ChannelOwner<T extends channels.Channel = channels.Channel
const validator = maybeFindValidator(this._type, prop, 'Params');
const { internal } = getMetainfo({ type: this._type, method: prop }) || {};
if (validator) {
- return async (params: any, signal: AbortSignal | undefined) => {
+ return async (params: any, options: { signal?: AbortSignal, timeout?: number } = {}) => {
return await this._wrapApiCall(async apiZone => {
const validatedParams = validator(params, '', this._validatorToWireContext());
+ const { signal, timeout = 0 } = options;
if (!apiZone.internal && !apiZone.reported) {
// Reporting/tracing/logging this api call for the first time.
apiZone.reported = true;
this._instrumentation.onApiCallBegin(apiZone, { type: this._type, method: prop, params });
logApiCall(this._logger, `=> ${apiZone.apiName} started`);
- return await this._connection.sendMessageToServer(this, prop, validatedParams, { ...apiZone, signal });
+ return await this._connection.sendMessageToServer(this, prop, validatedParams, { ...apiZone, signal, timeout });
}
// Since this api call is either internal, or has already been reported/traced once,
// passing as internal.
- return await this._connection.sendMessageToServer(this, prop, validatedParams, { internal: true, signal });
+ return await this._connection.sendMessageToServer(this, prop, validatedParams, { internal: true, signal, timeout });
}, { internal });
};
}
diff --git a/packages/playwright-core/src/client/channels.d.ts b/packages/playwright-core/src/client/channels.d.ts
index 6a2902e0f5..e24253c85e 100644
--- a/packages/playwright-core/src/client/channels.d.ts
+++ b/packages/playwright-core/src/client/channels.d.ts
@@ -18,6 +18,8 @@
import type { Binary, Channel, AndroidWebView, AndroidSelector, AndroidElementInfo, APIResponse, Metadata, ClientSideCallMetadata, SDKLanguage, WaitInfo, SetNetworkCookie, NetworkCookie, ResourceTiming, SecurityDetails, RequestSizes, RemoteAddr, ExpectedTextValue, SelectorEngine, FormField, LifecycleEvent, ConsoleMessagesFilter, RecorderSource, IndexedDBDatabase, SetOriginStorage, OriginStorage, RecordHarOptions, SerializedValue, SerializedArgument, SerializedError, StackFrame, VirtualCredential, Point, Rect, URLPattern, NameValue } from '@protocol/structs';
export type { Binary, Channel, AndroidWebView, AndroidSelector, AndroidElementInfo, APIResponse, Metadata, ClientSideCallMetadata, SDKLanguage, WaitInfo, SetNetworkCookie, NetworkCookie, ResourceTiming, SecurityDetails, RequestSizes, RemoteAddr, ExpectedTextValue, SelectorEngine, FormField, LifecycleEvent, ConsoleMessagesFilter, RecorderSource, IndexedDBDatabase, SetOriginStorage, OriginStorage, RecordHarOptions, SerializedValue, SerializedArgument, SerializedError, StackFrame, VirtualCredential, Point, Rect, URLPattern, NameValue } from '@protocol/structs';
+export type TimeoutOptions = { signal: AbortSignal | undefined, timeout: number };
+
// ----------- Initializer Traits -----------
export type InitializerTraits<T> =
T extends ElementHandleChannel ? ElementHandleInitializer :
@@ -138,7 +140,7 @@ export interface AndroidEventTarget {
}
export interface AndroidChannel extends AndroidEventTarget, Channel {
_type_Android: boolean;
- devices(params: AndroidDevicesParams, signal: AbortSignal | undefined): Promise<AndroidDevicesResult>;
+ devices(params: AndroidDevicesParams, options: TimeoutOptions): Promise<AndroidDevicesResult>;
}
export type AndroidDevicesParams = {
host?: string,
@@ -165,8 +167,8 @@ export interface AndroidSocketEventTarget {
}
export interface AndroidSocketChannel extends AndroidSocketEventTarget, Channel {
_type_AndroidSocket: boolean;
- write(params: AndroidSocketWriteParams, signal: AbortSignal | undefined): Promise<AndroidSocketWriteResult>;
- close(params: AndroidSocketCloseParams, signal: AbortSignal | undefined): Promise<AndroidSocketCloseResult>;
+ write(params: AndroidSocketWriteParams, options: TimeoutOptions): Promise<AndroidSocketWriteResult>;
+ close(params: AndroidSocketCloseParams, options: TimeoutOptions): Promise<AndroidSocketCloseResult>;
}
export type AndroidSocketDataEvent = {
data: Binary,
@@ -200,30 +202,30 @@ export interface AndroidDeviceEventTarget {
}
export interface AndroidDeviceChannel extends AndroidDeviceEventTarget, Channel {
_type_AndroidDevice: boolean;
- wait(params: AndroidDeviceWaitParams, signal: AbortSignal | undefined): Promise<AndroidDeviceWaitResult>;
- fill(params: AndroidDeviceFillParams, signal: AbortSignal | undefined): Promise<AndroidDeviceFillResult>;
- tap(params: AndroidDeviceTapParams, signal: AbortSignal | undefined): Promise<AndroidDeviceTapResult>;
- drag(params: AndroidDeviceDragParams, signal: AbortSignal | undefined): Promise<AndroidDeviceDragResult>;
- fling(params: AndroidDeviceFlingParams, signal: AbortSignal | undefined): Promise<AndroidDeviceFlingResult>;
- longTap(params: AndroidDeviceLongTapParams, signal: AbortSignal | undefined): Promise<AndroidDeviceLongTapResult>;
- pinchClose(params: AndroidDevicePinchCloseParams, signal: AbortSignal | undefined): Promise<AndroidDevicePinchCloseResult>;
- pinchOpen(params: AndroidDevicePinchOpenParams, signal: AbortSignal | undefined): Promise<AndroidDevicePinchOpenResult>;
- scroll(params: AndroidDeviceScrollParams, signal: AbortSignal | undefined): Promise<AndroidDeviceScrollResult>;
- swipe(params: AndroidDeviceSwipeParams, signal: AbortSignal | undefined): Promise<AndroidDeviceSwipeResult>;
- info(params: AndroidDeviceInfoParams, signal: AbortSignal | undefined): Promise<AndroidDeviceInfoResult>;
- screenshot(params: AndroidDeviceScreenshotParams, signal: AbortSignal | undefined): Promise<AndroidDeviceScreenshotResult>;
- inputType(params: AndroidDeviceInputTypeParams, signal: AbortSignal | undefined): Promise<AndroidDeviceInputTypeResult>;
- inputPress(params: AndroidDeviceInputPressParams, signal: AbortSignal | undefined): Promise<AndroidDeviceInputPressResult>;
- inputTap(params: AndroidDeviceInputTapParams, signal: AbortSignal | undefined): Promise<AndroidDeviceInputTapResult>;
- inputSwipe(params: AndroidDeviceInputSwipeParams, signal: AbortSignal | undefined): Promise<AndroidDeviceInputSwipeResult>;
- inputDrag(params: AndroidDeviceInputDragParams, signal: AbortSignal | undefined): Promise<AndroidDeviceInputDragResult>;
- launchBrowser(params: AndroidDeviceLaunchBrowserParams, signal: AbortSignal | undefined): Promise<AndroidDeviceLaunchBrowserResult>;
- open(params: AndroidDeviceOpenParams, signal: AbortSignal | undefined): Promise<AndroidDeviceOpenResult>;
- shell(params: AndroidDeviceShellParams, signal: AbortSignal | undefined): Promise<AndroidDeviceShellResult>;
- installApk(params: AndroidDeviceInstallApkParams, signal: AbortSignal | undefined): Promise<AndroidDeviceInstallApkResult>;
- push(params: AndroidDevicePushParams, signal: AbortSignal | undefined): Promise<AndroidDevicePushResult>;
- connectToWebView(params: AndroidDeviceConnectToWebViewParams, signal: AbortSignal | undefined): Promise<AndroidDeviceConnectToWebViewResult>;
- close(params: AndroidDeviceCloseParams, signal: AbortSignal | undefined): Promise<AndroidDeviceCloseResult>;
+ wait(params: AndroidDeviceWaitParams, options: TimeoutOptions): Promise<AndroidDeviceWaitResult>;
+ fill(params: AndroidDeviceFillParams, options: TimeoutOptions): Promise<AndroidDeviceFillResult>;
+ tap(params: AndroidDeviceTapParams, options: TimeoutOptions): Promise<AndroidDeviceTapResult>;
+ drag(params: AndroidDeviceDragParams, options: TimeoutOptions): Promise<AndroidDeviceDragResult>;
+ fling(params: AndroidDeviceFlingParams, options: TimeoutOptions): Promise<AndroidDeviceFlingResult>;
+ longTap(params: AndroidDeviceLongTapParams, options: TimeoutOptions): Promise<AndroidDeviceLongTapResult>;
+ pinchClose(params: AndroidDevicePinchCloseParams, options: TimeoutOptions): Promise<AndroidDevicePinchCloseResult>;
+ pinchOpen(params: AndroidDevicePinchOpenParams, options: TimeoutOptions): Promise<AndroidDevicePinchOpenResult>;
+ scroll(params: AndroidDeviceScrollParams, options: TimeoutOptions): Promise<AndroidDeviceScrollResult>;
+ swipe(params: AndroidDeviceSwipeParams, options: TimeoutOptions): Promise<AndroidDeviceSwipeResult>;
+ info(params: AndroidDeviceInfoParams, options: TimeoutOptions): Promise<AndroidDeviceInfoResult>;
+ screenshot(params: AndroidDeviceScreenshotParams, options: TimeoutOptions): Promise<AndroidDeviceScreenshotResult>;
+ inputType(params: AndroidDeviceInputTypeParams, options: TimeoutOptions): Promise<AndroidDeviceInputTypeResult>;
+ inputPress(params: AndroidDeviceInputPressParams, options: TimeoutOptions): Promise<AndroidDeviceInputPressResult>;
+ inputTap(params: AndroidDeviceInputTapParams, options: TimeoutOptions): Promise<AndroidDeviceInputTapResult>;
+ inputSwipe(params: AndroidDeviceInputSwipeParams, options: TimeoutOptions): Promise<AndroidDeviceInputSwipeResult>;
+ inputDrag(params: AndroidDeviceInputDragParams, options: TimeoutOptions): Promise<AndroidDeviceInputDragResult>;
+ launchBrowser(params: AndroidDeviceLaunchBrowserParams, options: TimeoutOptions): Promise<AndroidDeviceLaunchBrowserResult>;
+ open(params: AndroidDeviceOpenParams, options: TimeoutOptions): Promise<AndroidDeviceOpenResult>;
+ shell(params: AndroidDeviceShellParams, options: TimeoutOptions): Promise<AndroidDeviceShellResult>;
+ installApk(params: AndroidDeviceInstallApkParams, options: TimeoutOptions): Promise<AndroidDeviceInstallApkResult>;
+ push(params: AndroidDevicePushParams, options: TimeoutOptions): Promise<AndroidDevicePushResult>;
+ connectToWebView(params: AndroidDeviceConnectToWebViewParams, options: TimeoutOptions): Promise<AndroidDeviceConnectToWebViewResult>;
+ close(params: AndroidDeviceCloseParams, options: TimeoutOptions): Promise<AndroidDeviceCloseResult>;
}
export type AndroidDeviceCloseEvent = {};
export type AndroidDeviceWebViewAddedEvent = {
@@ -235,7 +237,6 @@ export type AndroidDeviceWebViewRemovedEvent = {
export type AndroidDeviceWaitParams = {
androidSelector: AndroidSelector,
state?: 'gone',
- timeout: number,
};
export type AndroidDeviceWaitOptions = {
state?: 'gone',
@@ -244,7 +245,6 @@ export type AndroidDeviceWaitResult = void;
export type AndroidDeviceFillParams = {
androidSelector: AndroidSelector,
text: string,
- timeout: number,
};
export type AndroidDeviceFillOptions = {
@@ -253,7 +253,6 @@ export type AndroidDeviceFillResult = void;
export type AndroidDeviceTapParams = {
androidSelector: AndroidSelector,
duration?: number,
- timeout: number,
};
export type AndroidDeviceTapOptions = {
duration?: number,
@@ -263,7 +262,6 @@ export type AndroidDeviceDragParams = {
androidSelector: AndroidSelector,
dest: Point,
speed?: number,
- timeout: number,
};
export type AndroidDeviceDragOptions = {
speed?: number,
@@ -273,7 +271,6 @@ export type AndroidDeviceFlingParams = {
androidSelector: AndroidSelector,
direction: 'up' | 'down' | 'left' | 'right',
speed?: number,
- timeout: number,
};
export type AndroidDeviceFlingOptions = {
speed?: number,
@@ -281,7 +278,6 @@ export type AndroidDeviceFlingOptions = {
export type AndroidDeviceFlingResult = void;
export type AndroidDeviceLongTapParams = {
androidSelector: AndroidSelector,
- timeout: number,
};
export type AndroidDeviceLongTapOptions = {
@@ -291,7 +287,6 @@ export type AndroidDevicePinchCloseParams = {
androidSelector: AndroidSelector,
percent: number,
speed?: number,
- timeout: number,
};
export type AndroidDevicePinchCloseOptions = {
speed?: number,
@@ -301,7 +296,6 @@ export type AndroidDevicePinchOpenParams = {
androidSelector: AndroidSelector,
percent: number,
speed?: number,
- timeout: number,
};
export type AndroidDevicePinchOpenOptions = {
speed?: number,
@@ -312,7 +306,6 @@ export type AndroidDeviceScrollParams = {
direction: 'up' | 'down' | 'left' | 'right',
percent: number,
speed?: number,
- timeout: number,
};
export type AndroidDeviceScrollOptions = {
speed?: number,
@@ -323,7 +316,6 @@ export type AndroidDeviceSwipeParams = {
direction: 'up' | 'down' | 'left' | 'right',
percent: number,
speed?: number,
- timeout: number,
};
export type AndroidDeviceSwipeOptions = {
speed?: number,
@@ -590,12 +582,12 @@ export interface APIRequestContextEventTarget {
}
export interface APIRequestContextChannel extends APIRequestContextEventTarget, Channel {
_type_APIRequestContext: boolean;
- fetch(params: APIRequestContextFetchParams, signal: AbortSignal | undefined): Promise<APIRequestContextFetchResult>;
- fetchResponseBody(params: APIRequestContextFetchResponseBodyParams, signal: AbortSignal | undefined): Promise<APIRequestContextFetchResponseBodyResult>;
- fetchLog(params: APIRequestContextFetchLogParams, signal: AbortSignal | undefined): Promise<APIRequestContextFetchLogResult>;
- storageState(params: APIRequestContextStorageStateParams, signal: AbortSignal | undefined): Promise<APIRequestContextStorageStateResult>;
- disposeAPIResponse(params: APIRequestContextDisposeAPIResponseParams, signal: AbortSignal | undefined): Promise<APIRequestContextDisposeAPIResponseResult>;
- dispose(params: APIRequestContextDisposeParams, signal: AbortSignal | undefined): Promise<APIRequestContextDisposeResult>;
+ fetch(params: APIRequestContextFetchParams, options: TimeoutOptions): Promise<APIRequestContextFetchResult>;
+ fetchResponseBody(params: APIRequestContextFetchResponseBodyParams, options: TimeoutOptions): Promise<APIRequestContextFetchResponseBodyResult>;
+ fetchLog(params: APIRequestContextFetchLogParams, options: TimeoutOptions): Promise<APIRequestContextFetchLogResult>;
+ storageState(params: APIRequestContextStorageStateParams, options: TimeoutOptions): Promise<APIRequestContextStorageStateResult>;
+ disposeAPIResponse(params: APIRequestContextDisposeAPIResponseParams, options: TimeoutOptions): Promise<APIRequestContextDisposeAPIResponseResult>;
+ dispose(params: APIRequestContextDisposeParams, options: TimeoutOptions): Promise<APIRequestContextDisposeResult>;
}
export type APIRequestContextFetchParams = {
url: string,
@@ -607,7 +599,6 @@ export type APIRequestContextFetchParams = {
jsonData?: string,
formData?: NameValue[],
multipartData?: FormField[],
- timeout: number,
failOnStatusCode?: boolean,
ignoreHTTPSErrors?: boolean,
maxRedirects?: number,
@@ -684,13 +675,13 @@ export interface ArtifactEventTarget {
}
export interface ArtifactChannel extends ArtifactEventTarget, Channel {
_type_Artifact: boolean;
- pathAfterFinished(params: ArtifactPathAfterFinishedParams, signal: AbortSignal | undefined): Promise<ArtifactPathAfterFinishedResult>;
- saveAs(params: ArtifactSaveAsParams, signal: AbortSignal | undefined): Promise<ArtifactSaveAsResult>;
- saveAsStream(params: ArtifactSaveAsStreamParams, signal: AbortSignal | undefined): Promise<ArtifactSaveAsStreamResult>;
- failure(params: ArtifactFailureParams, signal: AbortSignal | undefined): Promise<ArtifactFailureResult>;
- stream(params: ArtifactStreamParams, signal: AbortSignal | undefined): Promise<ArtifactStreamResult>;
- cancel(params: ArtifactCancelParams, signal: AbortSignal | undefined): Promise<ArtifactCancelResult>;
- delete(params: ArtifactDeleteParams, signal: AbortSignal | undefined): Promise<ArtifactDeleteResult>;
+ pathAfterFinished(params: ArtifactPathAfterFinishedParams, options: TimeoutOptions): Promise<ArtifactPathAfterFinishedResult>;
+ saveAs(params: ArtifactSaveAsParams, options: TimeoutOptions): Promise<ArtifactSaveAsResult>;
+ saveAsStream(params: ArtifactSaveAsStreamParams, options: TimeoutOptions): Promise<ArtifactSaveAsStreamResult>;
+ failure(params: ArtifactFailureParams, options: TimeoutOptions): Promise<ArtifactFailureResult>;
+ stream(params: ArtifactStreamParams, options: TimeoutOptions): Promise<ArtifactStreamResult>;
+ cancel(params: ArtifactCancelParams, options: TimeoutOptions): Promise<ArtifactCancelResult>;
+ delete(params: ArtifactDeleteParams, options: TimeoutOptions): Promise<ArtifactDeleteResult>;
}
export type ArtifactPathAfterFinishedParams = {};
export type ArtifactPathAfterFinishedOptions = {};
@@ -735,8 +726,8 @@ export interface StreamEventTarget {
}
export interface StreamChannel extends StreamEventTarget, Channel {
_type_Stream: boolean;
- read(params: StreamReadParams, signal: AbortSignal | undefined): Promise<StreamReadResult>;
- close(params: StreamCloseParams, signal: AbortSignal | undefined): Promise<StreamCloseResult>;
+ read(params: StreamReadParams, options: TimeoutOptions): Promise<StreamReadResult>;
+ close(params: StreamCloseParams, options: TimeoutOptions): Promise<StreamCloseResult>;
}
export type StreamReadParams = {
size?: number,
@@ -760,8 +751,8 @@ export interface WritableStreamEventTarget {
}
export interface WritableStreamChannel extends WritableStreamEventTarget, Channel {
_type_WritableStream: boolean;
- write(params: WritableStreamWriteParams, signal: AbortSignal | undefined): Promise<WritableStreamWriteResult>;
- close(params: WritableStreamCloseParams, signal: AbortSignal | undefined): Promise<WritableStreamCloseResult>;
+ write(params: WritableStreamWriteParams, options: TimeoutOptions): Promise<WritableStreamWriteResult>;
+ close(params: WritableStreamCloseParams, options: TimeoutOptions): Promise<WritableStreamCloseResult>;
}
export type WritableStreamWriteParams = {
binary: Binary,
@@ -789,17 +780,17 @@ export interface BrowserEventTarget {
}
export interface BrowserChannel extends BrowserEventTarget, Channel {
_type_Browser: boolean;
- startServer(params: BrowserStartServerParams, signal: AbortSignal | undefined): Promise<BrowserStartServerResult>;
- stopServer(params: BrowserStopServerParams, signal: AbortSignal | undefined): Promise<BrowserStopServerResult>;
- close(params: BrowserCloseParams, signal: AbortSignal | undefined): Promise<BrowserCloseResult>;
- killForTests(params: BrowserKillForTestsParams, signal: AbortSignal | undefined): Promise<BrowserKillForTestsResult>;
- defaultUserAgentForTest(params: BrowserDefaultUserAgentForTestParams, signal: AbortSignal | undefined): Promise<BrowserDefaultUserAgentForTestResult>;
- newContext(params: BrowserNewContextParams, signal: AbortSignal | undefined): Promise<BrowserNewContextResult>;
- newContextForReuse(params: BrowserNewContextForReuseParams, signal: AbortSignal | undefined): Promise<BrowserNewContextForReuseResult>;
- disconnectFromReusedContext(params: BrowserDisconnectFromReusedContextParams, signal: AbortSignal | undefined): Promise<BrowserDisconnectFromReusedContextResult>;
- newBrowserCDPSession(params: BrowserNewBrowserCDPSessionParams, signal: AbortSignal | undefined): Promise<BrowserNewBrowserCDPSessionResult>;
- startTracing(params: BrowserStartTracingParams, signal: AbortSignal | undefined): Promise<BrowserStartTracingResult>;
- stopTracing(params: BrowserStopTracingParams, signal: AbortSignal | undefined): Promise<BrowserStopTracingResult>;
+ startServer(params: BrowserStartServerParams, options: TimeoutOptions): Promise<BrowserStartServerResult>;
+ stopServer(params: BrowserStopServerParams, options: TimeoutOptions): Promise<BrowserStopServerResult>;
+ close(params: BrowserCloseParams, options: TimeoutOptions): Promise<BrowserCloseResult>;
+ killForTests(params: BrowserKillForTestsParams, options: TimeoutOptions): Promise<BrowserKillForTestsResult>;
+ defaultUserAgentForTest(params: BrowserDefaultUserAgentForTestParams, options: TimeoutOptions): Promise<BrowserDefaultUserAgentForTestResult>;
+ newContext(params: BrowserNewContextParams, options: TimeoutOptions): Promise<BrowserNewContextResult>;
+ newContextForReuse(params: BrowserNewContextForReuseParams, options: TimeoutOptions): Promise<BrowserNewContextForReuseResult>;
+ disconnectFromReusedContext(params: BrowserDisconnectFromReusedContextParams, options: TimeoutOptions): Promise<BrowserDisconnectFromReusedContextResult>;
+ newBrowserCDPSession(params: BrowserNewBrowserCDPSessionParams, options: TimeoutOptions): Promise<BrowserNewBrowserCDPSessionResult>;
+ startTracing(params: BrowserStartTracingParams, options: TimeoutOptions): Promise<BrowserStartTracingResult>;
+ stopTracing(params: BrowserStopTracingParams, options: TimeoutOptions): Promise<BrowserStopTracingResult>;
}
export type BrowserContextEvent = {
context: BrowserContextChannel,
@@ -1267,45 +1258,45 @@ export interface BrowserContextEventTarget {
}
export interface BrowserContextChannel extends BrowserContextEventTarget, Channel {
_type_BrowserContext: boolean;
- addCookies(params: BrowserContextAddCookiesParams, signal: AbortSignal | undefined): Promise<BrowserContextAddCookiesResult>;
- addInitScript(params: BrowserContextAddInitScriptParams, signal: AbortSignal | undefined): Promise<BrowserContextAddInitScriptResult>;
- clearCookies(params: BrowserContextClearCookiesParams, signal: AbortSignal | undefined): Promise<BrowserContextClearCookiesResult>;
- clearPermissions(params: BrowserContextClearPermissionsParams, signal: AbortSignal | undefined): Promise<BrowserContextClearPermissionsResult>;
- close(params: BrowserContextCloseParams, signal: AbortSignal | undefined): Promise<BrowserContextCloseResult>;
- cookies(params: BrowserContextCookiesParams, signal: AbortSignal | undefined): Promise<BrowserContextCookiesResult>;
- exposeBinding(params: BrowserContextExposeBindingParams, signal: AbortSignal | undefined): Promise<BrowserContextExposeBindingResult>;
- grantPermissions(params: BrowserContextGrantPermissionsParams, signal: AbortSignal | undefined): Promise<BrowserContextGrantPermissionsResult>;
- newPage(params: BrowserContextNewPageParams, signal: AbortSignal | undefined): Promise<BrowserContextNewPageResult>;
- registerSelectorEngine(params: BrowserContextRegisterSelectorEngineParams, signal: AbortSignal | undefined): Promise<BrowserContextRegisterSelectorEngineResult>;
- setTestIdAttributeName(params: BrowserContextSetTestIdAttributeNameParams, signal: AbortSignal | undefined): Promise<BrowserContextSetTestIdAttributeNameResult>;
- setExtraHTTPHeaders(params: BrowserContextSetExtraHTTPHeadersParams, signal: AbortSignal | undefined): Promise<BrowserContextSetExtraHTTPHeadersResult>;
- setGeolocation(params: BrowserContextSetGeolocationParams, signal: AbortSignal | undefined): Promise<BrowserContextSetGeolocationResult>;
- setHTTPCredentials(params: BrowserContextSetHTTPCredentialsParams, signal: AbortSignal | undefined): Promise<BrowserContextSetHTTPCredentialsResult>;
- setNetworkInterceptionPatterns(params: BrowserContextSetNetworkInterceptionPatternsParams, signal: AbortSignal | undefined): Promise<BrowserContextSetNetworkInterceptionPatternsResult>;
- routeAPIRequestsFromHar(params: BrowserContextRouteAPIRequestsFromHarParams, signal: AbortSignal | undefined): Promise<BrowserContextRouteAPIRequestsFromHarResult>;
- unrouteAPIRequestsFromHar(params: BrowserContextUnrouteAPIRequestsFromHarParams, signal: AbortSignal | undefined): Promise<BrowserContextUnrouteAPIRequestsFromHarResult>;
- setWebSocketInterceptionPatterns(params: BrowserContextSetWebSocketInterceptionPatternsParams, signal: AbortSignal | undefined): Promise<BrowserContextSetWebSocketInterceptionPatternsResult>;
- setOffline(params: BrowserContextSetOfflineParams, signal: AbortSignal | undefined): Promise<BrowserContextSetOfflineResult>;
- storageState(params: BrowserContextStorageStateParams, signal: AbortSignal | undefined): Promise<BrowserContextStorageStateResult>;
- setStorageState(params: BrowserContextSetStorageStateParams, signal: AbortSignal | undefined): Promise<BrowserContextSetStorageStateResult>;
- pause(params: BrowserContextPauseParams, signal: AbortSignal | undefined): Promise<BrowserContextPauseResult>;
- enableRecorder(params: BrowserContextEnableRecorderParams, signal: AbortSignal | undefined): Promise<BrowserContextEnableRecorderResult>;
- disableRecorder(params: BrowserContextDisableRecorderParams, signal: AbortSignal | undefined): Promise<BrowserContextDisableRecorderResult>;
- exposeConsoleApi(params: BrowserContextExposeConsoleApiParams, signal: AbortSignal | undefined): Promise<BrowserContextExposeConsoleApiResult>;
- newCDPSession(params: BrowserContextNewCDPSessionParams, signal: AbortSignal | undefined): Promise<BrowserContextNewCDPSessionResult>;
- createTempFiles(params: BrowserContextCreateTempFilesParams, signal: AbortSignal | undefined): Promise<BrowserContextCreateTempFilesResult>;
- updateSubscription(params: BrowserContextUpdateSubscriptionParams, signal: AbortSignal | undefined): Promise<BrowserContextUpdateSubscriptionResult>;
- clockFastForward(params: BrowserContextClockFastForwardParams, signal: AbortSignal | undefined): Promise<BrowserContextClockFastForwardResult>;
- clockInstall(params: BrowserContextClockInstallParams, signal: AbortSignal | undefined): Promise<BrowserContextClockInstallResult>;
- clockPauseAt(params: BrowserContextClockPauseAtParams, signal: AbortSignal | undefined): Promise<BrowserContextClockPauseAtResult>;
- clockResume(params: BrowserContextClockResumeParams, signal: AbortSignal | undefined): Promise<BrowserContextClockResumeResult>;
- clockRunFor(params: BrowserContextClockRunForParams, signal: AbortSignal | undefined): Promise<BrowserContextClockRunForResult>;
- clockSetFixedTime(params: BrowserContextClockSetFixedTimeParams, signal: AbortSignal | undefined): Promise<BrowserContextClockSetFixedTimeResult>;
- clockSetSystemTime(params: BrowserContextClockSetSystemTimeParams, signal: AbortSignal | undefined): Promise<BrowserContextClockSetSystemTimeResult>;
- credentialsInstall(params: BrowserContextCredentialsInstallParams, signal: AbortSignal | undefined): Promise<BrowserContextCredentialsInstallResult>;
- credentialsCreate(params: BrowserContextCredentialsCreateParams, signal: AbortSignal | undefined): Promise<BrowserContextCredentialsCreateResult>;
- credentialsGet(params: BrowserContextCredentialsGetParams, signal: AbortSignal | undefined): Promise<BrowserContextCredentialsGetResult>;
- credentialsDelete(params: BrowserContextCredentialsDeleteParams, signal: AbortSignal | undefined): Promise<BrowserContextCredentialsDeleteResult>;
+ addCookies(params: BrowserContextAddCookiesParams, options: TimeoutOptions): Promise<BrowserContextAddCookiesResult>;
+ addInitScript(params: BrowserContextAddInitScriptParams, options: TimeoutOptions): Promise<BrowserContextAddInitScriptResult>;
+ clearCookies(params: BrowserContextClearCookiesParams, options: TimeoutOptions): Promise<BrowserContextClearCookiesResult>;
+ clearPermissions(params: BrowserContextClearPermissionsParams, options: TimeoutOptions): Promise<BrowserContextClearPermissionsResult>;
+ close(params: BrowserContextCloseParams, options: TimeoutOptions): Promise<BrowserContextCloseResult>;
+ cookies(params: BrowserContextCookiesParams, options: TimeoutOptions): Promise<BrowserContextCookiesResult>;
+ exposeBinding(params: BrowserContextExposeBindingParams, options: TimeoutOptions): Promise<BrowserContextExposeBindingResult>;
+ grantPermissions(params: BrowserContextGrantPermissionsParams, options: TimeoutOptions): Promise<BrowserContextGrantPermissionsResult>;
+ newPage(params: BrowserContextNewPageParams, options: TimeoutOptions): Promise<BrowserContextNewPageResult>;
+ registerSelectorEngine(params: BrowserContextRegisterSelectorEngineParams, options: TimeoutOptions): Promise<BrowserContextRegisterSelectorEngineResult>;
+ setTestIdAttributeName(params: BrowserContextSetTestIdAttributeNameParams, options: TimeoutOptions): Promise<BrowserContextSetTestIdAttributeNameResult>;
+ setExtraHTTPHeaders(params: BrowserContextSetExtraHTTPHeadersParams, options: TimeoutOptions): Promise<BrowserContextSetExtraHTTPHeadersResult>;
+ setGeolocation(params: BrowserContextSetGeolocationParams, options: TimeoutOptions): Promise<BrowserContextSetGeolocationResult>;
+ setHTTPCredentials(params: BrowserContextSetHTTPCredentialsParams, options: TimeoutOptions): Promise<BrowserContextSetHTTPCredentialsResult>;
+ setNetworkInterceptionPatterns(params: BrowserContextSetNetworkInterceptionPatternsParams, options: TimeoutOptions): Promise<BrowserContextSetNetworkInterceptionPatternsResult>;
+ routeAPIRequestsFromHar(params: BrowserContextRouteAPIRequestsFromHarParams, options: TimeoutOptions): Promise<BrowserContextRouteAPIRequestsFromHarResult>;
+ unrouteAPIRequestsFromHar(params: BrowserContextUnrouteAPIRequestsFromHarParams, options: TimeoutOptions): Promise<BrowserContextUnrouteAPIRequestsFromHarResult>;
+ setWebSocketInterceptionPatterns(params: BrowserContextSetWebSocketInterceptionPatternsParams, options: TimeoutOptions): Promise<BrowserContextSetWebSocketInterceptionPatternsResult>;
+ setOffline(params: BrowserContextSetOfflineParams, options: TimeoutOptions): Promise<BrowserContextSetOfflineResult>;
+ storageState(params: BrowserContextStorageStateParams, options: TimeoutOptions): Promise<BrowserContextStorageStateResult>;
+ setStorageState(params: BrowserContextSetStorageStateParams, options: TimeoutOptions): Promise<BrowserContextSetStorageStateResult>;
+ pause(params: BrowserContextPauseParams, options: TimeoutOptions): Promise<BrowserContextPauseResult>;
+ enableRecorder(params: BrowserContextEnableRecorderParams, options: TimeoutOptions): Promise<BrowserContextEnableRecorderResult>;
+ disableRecorder(params: BrowserContextDisableRecorderParams, options: TimeoutOptions): Promise<BrowserContextDisableRecorderResult>;
+ exposeConsoleApi(params: BrowserContextExposeConsoleApiParams, options: TimeoutOptions): Promise<BrowserContextExposeConsoleApiResult>;
+ newCDPSession(params: BrowserContextNewCDPSessionParams, options: TimeoutOptions): Promise<BrowserContextNewCDPSessionResult>;
+ createTempFiles(params: BrowserContextCreateTempFilesParams, options: TimeoutOptions): Promise<BrowserContextCreateTempFilesResult>;
+ updateSubscription(params: BrowserContextUpdateSubscriptionParams, options: TimeoutOptions): Promise<BrowserContextUpdateSubscriptionResult>;
+ clockFastForward(params: BrowserContextClockFastForwardParams, options: TimeoutOptions): Promise<BrowserContextClockFastForwardResult>;
+ clockInstall(params: BrowserContextClockInstallParams, options: TimeoutOptions): Promise<BrowserContextClockInstallResult>;
+ clockPauseAt(params: BrowserContextClockPauseAtParams, options: TimeoutOptions): Promise<BrowserContextClockPauseAtResult>;
+ clockResume(params: BrowserContextClockResumeParams, options: TimeoutOptions): Promise<BrowserContextClockResumeResult>;
+ clockRunFor(params: BrowserContextClockRunForParams, options: TimeoutOptions): Promise<BrowserContextClockRunForResult>;
+ clockSetFixedTime(params: BrowserContextClockSetFixedTimeParams, options: TimeoutOptions): Promise<BrowserContextClockSetFixedTimeResult>;
+ clockSetSystemTime(params: BrowserContextClockSetSystemTimeParams, options: TimeoutOptions): Promise<BrowserContextClockSetSystemTimeResult>;
+ credentialsInstall(params: BrowserContextCredentialsInstallParams, options: TimeoutOptions): Promise<BrowserContextCredentialsInstallResult>;
+ credentialsCreate(params: BrowserContextCredentialsCreateParams, options: TimeoutOptions): Promise<BrowserContextCredentialsCreateResult>;
+ credentialsGet(params: BrowserContextCredentialsGetParams, options: TimeoutOptions): Promise<BrowserContextCredentialsGetResult>;
+ credentialsDelete(params: BrowserContextCredentialsDeleteParams, options: TimeoutOptions): Promise<BrowserContextCredentialsDeleteResult>;
}
export type BrowserContextBindingCallEvent = {
binding: BindingCallChannel,
@@ -1778,10 +1769,10 @@ export interface BrowserTypeEventTarget {
}
export interface BrowserTypeChannel extends BrowserTypeEventTarget, Channel {
_type_BrowserType: boolean;
- launch(params: BrowserTypeLaunchParams, signal: AbortSignal | undefined): Promise<BrowserTypeLaunchResult>;
- launchPersistentContext(params: BrowserTypeLaunchPersistentContextParams, signal: AbortSignal | undefined): Promise<BrowserTypeLaunchPersistentContextResult>;
- connectOverCDP(params: BrowserTypeConnectOverCDPParams, signal: AbortSignal | undefined): Promise<BrowserTypeConnectOverCDPResult>;
- connectToWorker(params: BrowserTypeConnectToWorkerParams, signal: AbortSignal | undefined): Promise<BrowserTypeConnectToWorkerResult>;
+ launch(params: BrowserTypeLaunchParams, options: TimeoutOptions): Promise<BrowserTypeLaunchResult>;
+ launchPersistentContext(params: BrowserTypeLaunchPersistentContextParams, options: TimeoutOptions): Promise<BrowserTypeLaunchPersistentContextResult>;
+ connectOverCDP(params: BrowserTypeConnectOverCDPParams, options: TimeoutOptions): Promise<BrowserTypeConnectOverCDPResult>;
+ connectToWorker(params: BrowserTypeConnectToWorkerParams, options: TimeoutOptions): Promise<BrowserTypeConnectToWorkerResult>;
}
export type BrowserTypeLaunchParams = {
channel?: string,
@@ -1792,7 +1783,6 @@ export type BrowserTypeLaunchParams = {
handleSIGINT?: boolean,
handleSIGTERM?: boolean,
handleSIGHUP?: boolean,
- timeout: number,
env?: NameValue[],
headless?: boolean,
proxy?: {
@@ -1846,7 +1836,6 @@ export type BrowserTypeLaunchPersistentContextParams = {
handleSIGINT?: boolean,
handleSIGTERM?: boolean,
handleSIGHUP?: boolean,
- timeout: number,
env?: NameValue[],
headless?: boolean,
proxy?: {
@@ -2021,7 +2010,6 @@ export type BrowserTypeConnectOverCDPParams = {
endpointURL?: string,
headers?: NameValue[],
slowMo?: number,
- timeout: number,
isLocal?: boolean,
noDefaults?: boolean,
artifactsDir?: string,
@@ -2042,7 +2030,6 @@ export type BrowserTypeConnectOverCDPResult = {
};
export type BrowserTypeConnectToWorkerParams = {
endpoint: string,
- timeout: number,
};
export type BrowserTypeConnectToWorkerOptions = {
@@ -2060,7 +2047,7 @@ export interface DisposableEventTarget {
}
export interface DisposableChannel extends DisposableEventTarget, Channel {
_type_Disposable: boolean;
- dispose(params: DisposableDisposeParams, signal: AbortSignal | undefined): Promise<DisposableDisposeResult>;
+ dispose(params: DisposableDisposeParams, options: TimeoutOptions): Promise<DisposableDisposeResult>;
}
export type DisposableDisposeParams = {};
export type DisposableDisposeOptions = {};
@@ -2075,7 +2062,7 @@ export interface ElectronEventTarget {
}
export interface ElectronChannel extends ElectronEventTarget, Channel {
_type_Electron: boolean;
- launch(params: ElectronLaunchParams, signal: AbortSignal | undefined): Promise<ElectronLaunchResult>;
+ launch(params: ElectronLaunchParams, options: TimeoutOptions): Promise<ElectronLaunchResult>;
}
export type ElectronLaunchParams = {
executablePath?: string,
@@ -2083,7 +2070,6 @@ export type ElectronLaunchParams = {
chromiumSandbox?: boolean,
cwd?: string,
env?: NameValue[],
- timeout: number,
acceptDownloads?: 'accept' | 'deny' | 'internal-browser-default',
bypassCSP?: boolean,
colorScheme?: 'dark' | 'light' | 'no-preference' | 'no-override',
@@ -2181,10 +2167,10 @@ export interface ElectronApplicationEventTarget {
}
export interface ElectronApplicationChannel extends ElectronApplicationEventTarget, Channel {
_type_ElectronApplication: boolean;
- browserWindow(params: ElectronApplicationBrowserWindowParams, signal: AbortSignal | undefined): Promise<ElectronApplicationBrowserWindowResult>;
- evaluateExpression(params: ElectronApplicationEvaluateExpressionParams, signal: AbortSignal | undefined): Promise<ElectronApplicationEvaluateExpressionResult>;
- evaluateExpressionHandle(params: ElectronApplicationEvaluateExpressionHandleParams, signal: AbortSignal | undefined): Promise<ElectronApplicationEvaluateExpressionHandleResult>;
- updateSubscription(params: ElectronApplicationUpdateSubscriptionParams, signal: AbortSignal | undefined): Promise<ElectronApplicationUpdateSubscriptionResult>;
+ browserWindow(params: ElectronApplicationBrowserWindowParams, options: TimeoutOptions): Promise<ElectronApplicationBrowserWindowResult>;
+ evaluateExpression(params: ElectronApplicationEvaluateExpressionParams, options: TimeoutOptions): Promise<ElectronApplicationEvaluateExpressionResult>;
+ evaluateExpressionHandle(params: ElectronApplicationEvaluateExpressionHandleParams, options: TimeoutOptions): Promise<ElectronApplicationEvaluateExpressionHandleResult>;
+ updateSubscription(params: ElectronApplicationUpdateSubscriptionParams, options: TimeoutOptions): Promise<ElectronApplicationUpdateSubscriptionResult>;
}
export type ElectronApplicationCloseEvent = {};
export type ElectronApplicationConsoleEvent = {
@@ -2256,55 +2242,55 @@ export interface FrameEventTarget {
}
export interface FrameChannel extends FrameEventTarget, Channel {
_type_Frame: boolean;
- evalOnSelector(params: FrameEvalOnSelectorParams, signal: AbortSignal | undefined): Promise<FrameEvalOnSelectorResult>;
- evalOnSelectorAll(params: FrameEvalOnSelectorAllParams, signal: AbortSignal | undefined): Promise<FrameEvalOnSelectorAllResult>;
- addScriptTag(params: FrameAddScriptTagParams, signal: AbortSignal | undefined): Promise<FrameAddScriptTagResult>;
- addStyleTag(params: FrameAddStyleTagParams, signal: AbortSignal | undefined): Promise<FrameAddStyleTagResult>;
- ariaSnapshot(params: FrameAriaSnapshotParams, signal: AbortSignal | undefined): Promise<FrameAriaSnapshotResult>;
- blur(params: FrameBlurParams, signal: AbortSignal | undefined): Promise<FrameBlurResult>;
- check(params: FrameCheckParams, signal: AbortSignal | undefined): Promise<FrameCheckResult>;
- click(params: FrameClickParams, signal: AbortSignal | undefined): Promise<FrameClickResult>;
- content(params: FrameContentParams, signal: AbortSignal | undefined): Promise<FrameContentResult>;
- dragAndDrop(params: FrameDragAndDropParams, signal: AbortSignal | undefined): Promise<FrameDragAndDropResult>;
- drop(params: FrameDropParams, signal: AbortSignal | undefined): Promise<FrameDropResult>;
- dblclick(params: FrameDblclickParams, signal: AbortSignal | undefined): Promise<FrameDblclickResult>;
- dispatchEvent(params: FrameDispatchEventParams, signal: AbortSignal | undefined): Promise<FrameDispatchEventResult>;
- evaluateExpression(params: FrameEvaluateExpressionParams, signal: AbortSignal | undefined): Promise<FrameEvaluateExpressionResult>;
- evaluateExpressionHandle(params: FrameEvaluateExpressionHandleParams, signal: AbortSignal | undefined): Promise<FrameEvaluateExpressionHandleResult>;
- fill(params: FrameFillParams, signal: AbortSignal | undefined): Promise<FrameFillResult>;
- focus(params: FrameFocusParams, signal: AbortSignal | undefined): Promise<FrameFocusResult>;
- frameElement(params: FrameFrameElementParams, signal: AbortSignal | undefined): Promise<FrameFrameElementResult>;
- resolveSelector(params: FrameResolveSelectorParams, signal: AbortSignal | undefined): Promise<FrameResolveSelectorResult>;
- highlight(params: FrameHighlightParams, signal: AbortSignal | undefined): Promise<FrameHighlightResult>;
- hideHighlight(params: FrameHideHighlightParams, signal: AbortSignal | undefined): Promise<FrameHideHighlightResult>;
- getAttribute(params: FrameGetAttributeParams, signal: AbortSignal | undefined): Promise<FrameGetAttributeResult>;
- goto(params: FrameGotoParams, signal: AbortSignal | undefined): Promise<FrameGotoResult>;
- hover(params: FrameHoverParams, signal: AbortSignal | undefined): Promise<FrameHoverResult>;
- innerHTML(params: FrameInnerHTMLParams, signal: AbortSignal | undefined): Promise<FrameInnerHTMLResult>;
- innerText(params: FrameInnerTextParams, signal: AbortSignal | undefined): Promise<FrameInnerTextResult>;
- inputValue(params: FrameInputValueParams, signal: AbortSignal | undefined): Promise<FrameInputValueResult>;
- isChecked(params: FrameIsCheckedParams, signal: AbortSignal | undefined): Promise<FrameIsCheckedResult>;
- isDisabled(params: FrameIsDisabledParams, signal: AbortSignal | undefined): Promise<FrameIsDisabledResult>;
- isEnabled(params: FrameIsEnabledParams, signal: AbortSignal | undefined): Promise<FrameIsEnabledResult>;
- isHidden(params: FrameIsHiddenParams, signal: AbortSignal | undefined): Promise<FrameIsHiddenResult>;
- isVisible(params: FrameIsVisibleParams, signal: AbortSignal | undefined): Promise<FrameIsVisibleResult>;
- isEditable(params: FrameIsEditableParams, signal: AbortSignal | undefined): Promise<FrameIsEditableResult>;
- press(params: FramePressParams, signal: AbortSignal | undefined): Promise<FramePressResult>;
- querySelector(params: FrameQuerySelectorParams, signal: AbortSignal | undefined): Promise<FrameQuerySelectorResult>;
- querySelectorAll(params: FrameQuerySelectorAllParams, signal: AbortSignal | undefined): Promise<FrameQuerySelectorAllResult>;
- queryCount(params: FrameQueryCountParams, signal: AbortSignal | undefined): Promise<FrameQueryCountResult>;
- selectOption(params: FrameSelectOptionParams, signal: AbortSignal | undefined): Promise<FrameSelectOptionResult>;
- setContent(params: FrameSetContentParams, signal: AbortSignal | undefined): Promise<FrameSetContentResult>;
- setInputFiles(params: FrameSetInputFilesParams, signal: AbortSignal | undefined): Promise<FrameSetInputFilesResult>;
- tap(params: FrameTapParams, signal: AbortSignal | undefined): Promise<FrameTapResult>;
- textContent(params: FrameTextContentParams, signal: AbortSignal | undefined): Promise<FrameTextContentResult>;
- title(params: FrameTitleParams, signal: AbortSignal | undefined): Promise<FrameTitleResult>;
- type(params: FrameTypeParams, signal: AbortSignal | undefined): Promise<FrameTypeResult>;
- uncheck(params: FrameUncheckParams, signal: AbortSignal | undefined): Promise<FrameUncheckResult>;
- waitForTimeout(params: FrameWaitForTimeoutParams, signal: AbortSignal | undefined): Promise<FrameWaitForTimeoutResult>;
- waitForFunction(params: FrameWaitForFunctionParams, signal: AbortSignal | undefined): Promise<FrameWaitForFunctionResult>;
- waitForSelector(params: FrameWaitForSelectorParams, signal: AbortSignal | undefined): Promise<FrameWaitForSelectorResult>;
- expect(params: FrameExpectParams, signal: AbortSignal | undefined): Promise<FrameExpectResult>;
+ evalOnSelector(params: FrameEvalOnSelectorParams, options: TimeoutOptions): Promise<FrameEvalOnSelectorResult>;
+ evalOnSelectorAll(params: FrameEvalOnSelectorAllParams, options: TimeoutOptions): Promise<FrameEvalOnSelectorAllResult>;
+ addScriptTag(params: FrameAddScriptTagParams, options: TimeoutOptions): Promise<FrameAddScriptTagResult>;
+ addStyleTag(params: FrameAddStyleTagParams, options: TimeoutOptions): Promise<FrameAddStyleTagResult>;
+ ariaSnapshot(params: FrameAriaSnapshotParams, options: TimeoutOptions): Promise<FrameAriaSnapshotResult>;
+ blur(params: FrameBlurParams, options: TimeoutOptions): Promise<FrameBlurResult>;
+ check(params: FrameCheckParams, options: TimeoutOptions): Promise<FrameCheckResult>;
+ click(params: FrameClickParams, options: TimeoutOptions): Promise<FrameClickResult>;
+ content(params: FrameContentParams, options: TimeoutOptions): Promise<FrameContentResult>;
+ dragAndDrop(params: FrameDragAndDropParams, options: TimeoutOptions): Promise<FrameDragAndDropResult>;
+ drop(params: FrameDropParams, options: TimeoutOptions): Promise<FrameDropResult>;
+ dblclick(params: FrameDblclickParams, options: TimeoutOptions): Promise<FrameDblclickResult>;
+ dispatchEvent(params: FrameDispatchEventParams, options: TimeoutOptions): Promise<FrameDispatchEventResult>;
+ evaluateExpression(params: FrameEvaluateExpressionParams, options: TimeoutOptions): Promise<FrameEvaluateExpressionResult>;
+ evaluateExpressionHandle(params: FrameEvaluateExpressionHandleParams, options: TimeoutOptions): Promise<FrameEvaluateExpressionHandleResult>;
+ fill(params: FrameFillParams, options: TimeoutOptions): Promise<FrameFillResult>;
+ focus(params: FrameFocusParams, options: TimeoutOptions): Promise<FrameFocusResult>;
+ frameElement(params: FrameFrameElementParams, options: TimeoutOptions): Promise<FrameFrameElementResult>;
+ resolveSelector(params: FrameResolveSelectorParams, options: TimeoutOptions): Promise<FrameResolveSelectorResult>;
+ highlight(params: FrameHighlightParams, options: TimeoutOptions): Promise<FrameHighlightResult>;
+ hideHighlight(params: FrameHideHighlightParams, options: TimeoutOptions): Promise<FrameHideHighlightResult>;
+ getAttribute(params: FrameGetAttributeParams, options: TimeoutOptions): Promise<FrameGetAttributeResult>;
+ goto(params: FrameGotoParams, options: TimeoutOptions): Promise<FrameGotoResult>;
+ hover(params: FrameHoverParams, options: TimeoutOptions): Promise<FrameHoverResult>;
+ innerHTML(params: FrameInnerHTMLParams, options: TimeoutOptions): Promise<FrameInnerHTMLResult>;
+ innerText(params: FrameInnerTextParams, options: TimeoutOptions): Promise<FrameInnerTextResult>;
+ inputValue(params: FrameInputValueParams, options: TimeoutOptions): Promise<FrameInputValueResult>;
+ isChecked(params: FrameIsCheckedParams, options: TimeoutOptions): Promise<FrameIsCheckedResult>;
+ isDisabled(params: FrameIsDisabledParams, options: TimeoutOptions): Promise<FrameIsDisabledResult>;
+ isEnabled(params: FrameIsEnabledParams, options: TimeoutOptions): Promise<FrameIsEnabledResult>;
+ isHidden(params: FrameIsHiddenParams, options: TimeoutOptions): Promise<FrameIsHiddenResult>;
+ isVisible(params: FrameIsVisibleParams, options: TimeoutOptions): Promise<FrameIsVisibleResult>;
+ isEditable(params: FrameIsEditableParams, options: TimeoutOptions): Promise<FrameIsEditableResult>;
+ press(params: FramePressParams, options: TimeoutOptions): Promise<FramePressResult>;
+ querySelector(params: FrameQuerySelectorParams, options: TimeoutOptions): Promise<FrameQuerySelectorResult>;
+ querySelectorAll(params: FrameQuerySelectorAllParams, options: TimeoutOptions): Promise<FrameQuerySelectorAllResult>;
+ queryCount(params: FrameQueryCountParams, options: TimeoutOptions): Promise<FrameQueryCountResult>;
+ selectOption(params: FrameSelectOptionParams, options: TimeoutOptions): Promise<FrameSelectOptionResult>;
+ setContent(params: FrameSetContentParams, options: TimeoutOptions): Promise<FrameSetContentResult>;
+ setInputFiles(params: FrameSetInputFilesParams, options: TimeoutOptions): Promise<FrameSetInputFilesResult>;
+ tap(params: FrameTapParams, options: TimeoutOptions): Promise<FrameTapResult>;
+ textContent(params: FrameTextContentParams, options: TimeoutOptions): Promise<FrameTextContentResult>;
+ title(params: FrameTitleParams, options: TimeoutOptions): Promise<FrameTitleResult>;
+ type(params: FrameTypeParams, options: TimeoutOptions): Promise<FrameTypeResult>;
+ uncheck(params: FrameUncheckParams, options: TimeoutOptions): Promise<FrameUncheckResult>;
+ waitForTimeout(params: FrameWaitForTimeoutParams, options: TimeoutOptions): Promise<FrameWaitForTimeoutResult>;
+ waitForFunction(params: FrameWaitForFunctionParams, options: TimeoutOptions): Promise<FrameWaitForFunctionResult>;
+ waitForSelector(params: FrameWaitForSelectorParams, options: TimeoutOptions): Promise<FrameWaitForSelectorResult>;
+ expect(params: FrameExpectParams, options: TimeoutOptions): Promise<FrameExpectResult>;
}
export type FrameLoadstateEvent = {
add?: LifecycleEvent,
@@ -2373,7 +2359,6 @@ export type FrameAriaSnapshotParams = {
selector?: string,
depth?: number,
boxes?: boolean,
- timeout: number,
};
export type FrameAriaSnapshotOptions = {
mode?: 'ai' | 'default',
@@ -2387,7 +2372,6 @@ export type FrameAriaSnapshotResult = {
export type FrameBlurParams = {
selector: string,
strict?: boolean,
- timeout: number,
};
export type FrameBlurOptions = {
strict?: boolean,
@@ -2399,7 +2383,6 @@ export type FrameCheckParams = {
force?: boolean,
scroll?: 'auto' | 'none',
position?: Point,
- timeout: number,
trial?: boolean,
};
export type FrameCheckOptions = {
@@ -2421,7 +2404,6 @@ export type FrameClickParams = {
delay?: number,
button?: 'left' | 'right' | 'middle',
clickCount?: number,
- timeout: number,
trial?: boolean,
steps?: number,
};
@@ -2449,7 +2431,6 @@ export type FrameDragAndDropParams = {
target: string,
force?: boolean,
scroll?: 'auto' | 'none',
- timeout: number,
trial?: boolean,
sourcePosition?: Point,
targetPosition?: Point,
@@ -2481,7 +2462,6 @@ export type FrameDropParams = {
mimeType: string,
value: string,
}[],
- timeout: number,
};
export type FrameDropOptions = {
strict?: boolean,
@@ -2508,7 +2488,6 @@ export type FrameDblclickParams = {
position?: Point,
delay?: number,
button?: 'left' | 'right' | 'middle',
- timeout: number,
trial?: boolean,
steps?: number,
};
@@ -2529,7 +2508,6 @@ export type FrameDispatchEventParams = {
strict?: boolean,
type: string,
eventInit: SerializedArgument,
- timeout: number,
};
export type FrameDispatchEventOptions = {
strict?: boolean,
@@ -2562,7 +2540,6 @@ export type FrameFillParams = {
strict?: boolean,
value: string,
force?: boolean,
- timeout: number,
};
export type FrameFillOptions = {
strict?: boolean,
@@ -2572,7 +2549,6 @@ export type FrameFillResult = void;
export type FrameFocusParams = {
selector: string,
strict?: boolean,
- timeout: number,
};
export type FrameFocusOptions = {
strict?: boolean,
@@ -2611,7 +2587,6 @@ export type FrameGetAttributeParams = {
selector: string,
strict?: boolean,
name: string,
- timeout: number,
};
export type FrameGetAttributeOptions = {
strict?: boolean,
@@ -2621,7 +2596,6 @@ export type FrameGetAttributeResult = {
};
export type FrameGotoParams = {
url: string,
- timeout: number,
waitUntil?: LifecycleEvent,
referer?: string,
};
@@ -2639,7 +2613,6 @@ export type FrameHoverParams = {
scroll?: 'auto' | 'none',
modifiers?: ('Alt' | 'Control' | 'ControlOrMeta' | 'Meta' | 'Shift')[],
position?: Point,
- timeout: number,
trial?: boolean,
};
export type FrameHoverOptions = {
@@ -2654,7 +2627,6 @@ export type FrameHoverResult = void;
export type FrameInnerHTMLParams = {
selector: string,
strict?: boolean,
- timeout: number,
};
export type FrameInnerHTMLOptions = {
strict?: boolean,
@@ -2665,7 +2637,6 @@ export type FrameInnerHTMLResult = {
export type FrameInnerTextParams = {
selector: string,
strict?: boolean,
- timeout: number,
};
export type FrameInnerTextOptions = {
strict?: boolean,
@@ -2676,7 +2647,6 @@ export type FrameInnerTextResult = {
export type FrameInputValueParams = {
selector: string,
strict?: boolean,
- timeout: number,
};
export type FrameInputValueOptions = {
strict?: boolean,
@@ -2687,7 +2657,6 @@ export type FrameInputValueResult = {
export type FrameIsCheckedParams = {
selector: string,
strict?: boolean,
- timeout: number,
};
export type FrameIsCheckedOptions = {
strict?: boolean,
@@ -2698,7 +2667,6 @@ export type FrameIsCheckedResult = {
export type FrameIsDisabledParams = {
selector: string,
strict?: boolean,
- timeout: number,
};
export type FrameIsDisabledOptions = {
strict?: boolean,
@@ -2709,7 +2677,6 @@ export type FrameIsDisabledResult = {
export type FrameIsEnabledParams = {
selector: string,
strict?: boolean,
- timeout: number,
};
export type FrameIsEnabledOptions = {
strict?: boolean,
@@ -2740,7 +2707,6 @@ export type FrameIsVisibleResult = {
export type FrameIsEditableParams = {
selector: string,
strict?: boolean,
- timeout: number,
};
export type FrameIsEditableOptions = {
strict?: boolean,
@@ -2754,7 +2720,6 @@ export type FramePressParams = {
key: string,
delay?: number,
noWaitAfter?: boolean,
- timeout: number,
};
export type FramePressOptions = {
strict?: boolean,
@@ -2801,7 +2766,6 @@ export type FrameSelectOptionParams = {
index?: number,
}[],
force?: boolean,
- timeout: number,
};
export type FrameSelectOptionOptions = {
strict?: boolean,
@@ -2819,7 +2783,6 @@ export type FrameSelectOptionResult = {
};
export type FrameSetContentParams = {
html: string,
- timeout: number,
waitUntil?: LifecycleEvent,
};
export type FrameSetContentOptions = {
@@ -2838,7 +2801,6 @@ export type FrameSetInputFilesParams = {
directoryStream?: WritableStreamChannel,
localPaths?: string[],
streams?: WritableStreamChannel[],
- timeout: number,
};
export type FrameSetInputFilesOptions = {
strict?: boolean,
@@ -2860,7 +2822,6 @@ export type FrameTapParams = {
scroll?: 'auto' | 'none',
modifiers?: ('Alt' | 'Control' | 'ControlOrMeta' | 'Meta' | 'Shift')[],
position?: Point,
- timeout: number,
trial?: boolean,
};
export type FrameTapOptions = {
@@ -2875,7 +2836,6 @@ export type FrameTapResult = void;
export type FrameTextContentParams = {
selector: string,
strict?: boolean,
- timeout: number,
};
export type FrameTextContentOptions = {
strict?: boolean,
@@ -2893,7 +2853,6 @@ export type FrameTypeParams = {
strict?: boolean,
text: string,
delay?: number,
- timeout: number,
};
export type FrameTypeOptions = {
strict?: boolean,
@@ -2906,7 +2865,6 @@ export type FrameUncheckParams = {
force?: boolean,
scroll?: 'auto' | 'none',
position?: Point,
- timeout: number,
trial?: boolean,
};
export type FrameUncheckOptions = {
@@ -2928,7 +2886,6 @@ export type FrameWaitForFunctionParams = {
expression: string,
isFunction?: boolean,
arg: SerializedArgument,
- timeout: number,
pollingInterval?: number,
selector?: string,
strict?: boolean,
@@ -2945,7 +2902,6 @@ export type FrameWaitForFunctionResult = {
export type FrameWaitForSelectorParams = {
selector: string,
strict?: boolean,
- timeout: number,
state?: 'attached' | 'detached' | 'visible' | 'hidden',
omitReturnValue?: boolean,
};
@@ -2967,7 +2923,6 @@ export type FrameExpectParams = {
expectedValue?: SerializedArgument,
useInnerText?: boolean,
isNot: boolean,
- timeout: number,
};
export type FrameExpectOptions = {
selector?: string,
@@ -3002,12 +2957,12 @@ export interface JSHandleEventTarget {
}
export interface JSHandleChannel extends JSHandleEventTarget, Channel {
_type_JSHandle: boolean;
- dispose(params: JSHandleDisposeParams, signal: AbortSignal | undefined): Promise<JSHandleDisposeResult>;
- evaluateExpression(params: JSHandleEvaluateExpressionParams, signal: AbortSignal | undefined): Promise<JSHandleEvaluateExpressionResult>;
- evaluateExpressionHandle(params: JSHandleEvaluateExpressionHandleParams, signal: AbortSignal | undefined): Promise<JSHandleEvaluateExpressionHandleResult>;
- getPropertyList(params: JSHandleGetPropertyListParams, signal: AbortSignal | undefined): Promise<JSHandleGetPropertyListResult>;
- getProperty(params: JSHandleGetPropertyParams, signal: AbortSignal | undefined): Promise<JSHandleGetPropertyResult>;
- jsonValue(params: JSHandleJsonValueParams, signal: AbortSignal | undefined): Promise<JSHandleJsonValueResult>;
+ dispose(params: JSHandleDisposeParams, options: TimeoutOptions): Promise<JSHandleDisposeResult>;
+ evaluateExpression(params: JSHandleEvaluateExpressionParams, options: TimeoutOptions): Promise<JSHandleEvaluateExpressionResult>;
+ evaluateExpressionHandle(params: JSHandleEvaluateExpressionHandleParams, options: TimeoutOptions): Promise<JSHandleEvaluateExpressionHandleResult>;
+ getPropertyList(params: JSHandleGetPropertyListParams, options: TimeoutOptions): Promise<JSHandleGetPropertyListResult>;
+ getProperty(params: JSHandleGetPropertyParams, options: TimeoutOptions): Promise<JSHandleGetPropertyResult>;
+ jsonValue(params: JSHandleJsonValueParams, options: TimeoutOptions): Promise<JSHandleJsonValueResult>;
}
export type JSHandlePreviewUpdatedEvent = {
preview: string,
@@ -3070,42 +3025,42 @@ export interface ElementHandleEventTarget {
}
export interface ElementHandleChannel extends ElementHandleEventTarget, JSHandleChannel {
_type_ElementHandle: boolean;
- evalOnSelector(params: ElementHandleEvalOnSelectorParams, signal: AbortSignal | undefined): Promise<ElementHandleEvalOnSelectorResult>;
- evalOnSelectorAll(params: ElementHandleEvalOnSelectorAllParams, signal: AbortSignal | undefined): Promise<ElementHandleEvalOnSelectorAllResult>;
- boundingBox(params: ElementHandleBoundingBoxParams, signal: AbortSignal | undefined): Promise<ElementHandleBoundingBoxResult>;
- check(params: ElementHandleCheckParams, signal: AbortSignal | undefined): Promise<ElementHandleCheckResult>;
- click(params: ElementHandleClickParams, signal: AbortSignal | undefined): Promise<ElementHandleClickResult>;
- contentFrame(params: ElementHandleContentFrameParams, signal: AbortSignal | undefined): Promise<ElementHandleContentFrameResult>;
- dblclick(params: ElementHandleDblclickParams, signal: AbortSignal | undefined): Promise<ElementHandleDblclickResult>;
- dispatchEvent(params: ElementHandleDispatchEventParams, signal: AbortSignal | undefined): Promise<ElementHandleDispatchEventResult>;
- fill(params: ElementHandleFillParams, signal: AbortSignal | undefined): Promise<ElementHandleFillResult>;
- focus(params: ElementHandleFocusParams, signal: AbortSignal | undefined): Promise<ElementHandleFocusResult>;
- getAttribute(params: ElementHandleGetAttributeParams, signal: AbortSignal | undefined): Promise<ElementHandleGetAttributeResult>;
- hover(params: ElementHandleHoverParams, signal: AbortSignal | undefined): Promise<ElementHandleHoverResult>;
- innerHTML(params: ElementHandleInnerHTMLParams, signal: AbortSignal | undefined): Promise<ElementHandleInnerHTMLResult>;
- innerText(params: ElementHandleInnerTextParams, signal: AbortSignal | undefined): Promise<ElementHandleInnerTextResult>;
- inputValue(params: ElementHandleInputValueParams, signal: AbortSignal | undefined): Promise<ElementHandleInputValueResult>;
- isChecked(params: ElementHandleIsCheckedParams, signal: AbortSignal | undefined): Promise<ElementHandleIsCheckedResult>;
- isDisabled(params: ElementHandleIsDisabledParams, signal: AbortSignal | undefined): Promise<ElementHandleIsDisabledResult>;
- isEditable(params: ElementHandleIsEditableParams, signal: AbortSignal | undefined): Promise<ElementHandleIsEditableResult>;
- isEnabled(params: ElementHandleIsEnabledParams, signal: AbortSignal | undefined): Promise<ElementHandleIsEnabledResult>;
- isHidden(params: ElementHandleIsHiddenParams, signal: AbortSignal | undefined): Promise<ElementHandleIsHiddenResult>;
- isVisible(params: ElementHandleIsVisibleParams, signal: AbortSignal | undefined): Promise<ElementHandleIsVisibleResult>;
- ownerFrame(params: ElementHandleOwnerFrameParams, signal: AbortSignal | undefined): Promise<ElementHandleOwnerFrameResult>;
- press(params: ElementHandlePressParams, signal: AbortSignal | undefined): Promise<ElementHandlePressResult>;
- querySelector(params: ElementHandleQuerySelectorParams, signal: AbortSignal | undefined): Promise<ElementHandleQuerySelectorResult>;
- querySelectorAll(params: ElementHandleQuerySelectorAllParams, signal: AbortSignal | undefined): Promise<ElementHandleQuerySelectorAllResult>;
- screenshot(params: ElementHandleScreenshotParams, signal: AbortSignal | undefined): Promise<ElementHandleScreenshotResult>;
- scrollIntoViewIfNeeded(params: ElementHandleScrollIntoViewIfNeededParams, signal: AbortSignal | undefined): Promise<ElementHandleScrollIntoViewIfNeededResult>;
- selectOption(params: ElementHandleSelectOptionParams, signal: AbortSignal | undefined): Promise<ElementHandleSelectOptionResult>;
- selectText(params: ElementHandleSelectTextParams, signal: AbortSignal | undefined): Promise<ElementHandleSelectTextResult>;
- setInputFiles(params: ElementHandleSetInputFilesParams, signal: AbortSignal | undefined): Promise<ElementHandleSetInputFilesResult>;
- tap(params: ElementHandleTapParams, signal: AbortSignal | undefined): Promise<ElementHandleTapResult>;
- textContent(params: ElementHandleTextContentParams, signal: AbortSignal | undefined): Promise<ElementHandleTextContentResult>;
- type(params: ElementHandleTypeParams, signal: AbortSignal | undefined): Promise<ElementHandleTypeResult>;
- uncheck(params: ElementHandleUncheckParams, signal: AbortSignal | undefined): Promise<ElementHandleUncheckResult>;
- waitForElementState(params: ElementHandleWaitForElementStateParams, signal: AbortSignal | undefined): Promise<ElementHandleWaitForElementStateResult>;
- waitForSelector(params: ElementHandleWaitForSelectorParams, signal: AbortSignal | undefined): Promise<ElementHandleWaitForSelectorResult>;
+ evalOnSelector(params: ElementHandleEvalOnSelectorParams, options: TimeoutOptions): Promise<ElementHandleEvalOnSelectorResult>;
+ evalOnSelectorAll(params: ElementHandleEvalOnSelectorAllParams, options: TimeoutOptions): Promise<ElementHandleEvalOnSelectorAllResult>;
+ boundingBox(params: ElementHandleBoundingBoxParams, options: TimeoutOptions): Promise<ElementHandleBoundingBoxResult>;
+ check(params: ElementHandleCheckParams, options: TimeoutOptions): Promise<ElementHandleCheckResult>;
+ click(params: ElementHandleClickParams, options: TimeoutOptions): Promise<ElementHandleClickResult>;
+ contentFrame(params: ElementHandleContentFrameParams, options: TimeoutOptions): Promise<ElementHandleContentFrameResult>;
+ dblclick(params: ElementHandleDblclickParams, options: TimeoutOptions): Promise<ElementHandleDblclickResult>;
+ dispatchEvent(params: ElementHandleDispatchEventParams, options: TimeoutOptions): Promise<ElementHandleDispatchEventResult>;
+ fill(params: ElementHandleFillParams, options: TimeoutOptions): Promise<ElementHandleFillResult>;
+ focus(params: ElementHandleFocusParams, options: TimeoutOptions): Promise<ElementHandleFocusResult>;
+ getAttribute(params: ElementHandleGetAttributeParams, options: TimeoutOptions): Promise<ElementHandleGetAttributeResult>;
+ hover(params: ElementHandleHoverParams, options: TimeoutOptions): Promise<ElementHandleHoverResult>;
+ innerHTML(params: ElementHandleInnerHTMLParams, options: TimeoutOptions): Promise<ElementHandleInnerHTMLResult>;
+ innerText(params: ElementHandleInnerTextParams, options: TimeoutOptions): Promise<ElementHandleInnerTextResult>;
+ inputValue(params: ElementHandleInputValueParams, options: TimeoutOptions): Promise<ElementHandleInputValueResult>;
+ isChecked(params: ElementHandleIsCheckedParams, options: TimeoutOptions): Promise<ElementHandleIsCheckedResult>;
+ isDisabled(params: ElementHandleIsDisabledParams, options: TimeoutOptions): Promise<ElementHandleIsDisabledResult>;
+ isEditable(params: ElementHandleIsEditableParams, options: TimeoutOptions): Promise<ElementHandleIsEditableResult>;
+ isEnabled(params: ElementHandleIsEnabledParams, options: TimeoutOptions): Promise<ElementHandleIsEnabledResult>;
+ isHidden(params: ElementHandleIsHiddenParams, options: TimeoutOptions): Promise<ElementHandleIsHiddenResult>;
+ isVisible(params: ElementHandleIsVisibleParams, options: TimeoutOptions): Promise<ElementHandleIsVisibleResult>;
+ ownerFrame(params: ElementHandleOwnerFrameParams, options: TimeoutOptions): Promise<ElementHandleOwnerFrameResult>;
+ press(params: ElementHandlePressParams, options: TimeoutOptions): Promise<ElementHandlePressResult>;
+ querySelector(params: ElementHandleQuerySelectorParams, options: TimeoutOptions): Promise<ElementHandleQuerySelectorResult>;
+ querySelectorAll(params: ElementHandleQuerySelectorAllParams, options: TimeoutOptions): Promise<ElementHandleQuerySelectorAllResult>;
+ screenshot(params: ElementHandleScreenshotParams, options: TimeoutOptions): Promise<ElementHandleScreenshotResult>;
+ scrollIntoViewIfNeeded(params: ElementHandleScrollIntoViewIfNeededParams, options: TimeoutOptions): Promise<ElementHandleScrollIntoViewIfNeededResult>;
+ selectOption(params: ElementHandleSelectOptionParams, options: TimeoutOptions): Promise<ElementHandleSelectOptionResult>;
+ selectText(params: ElementHandleSelectTextParams, options: TimeoutOptions): Promise<ElementHandleSelectTextResult>;
+ setInputFiles(params: ElementHandleSetInputFilesParams, options: TimeoutOptions): Promise<ElementHandleSetInputFilesResult>;
+ tap(params: ElementHandleTapParams, options: TimeoutOptions): Promise<ElementHandleTapResult>;
+ textContent(params: ElementHandleTextContentParams, options: TimeoutOptions): Promise<ElementHandleTextContentResult>;
+ type(params: ElementHandleTypeParams, options: TimeoutOptions): Promise<ElementHandleTypeResult>;
+ uncheck(params: ElementHandleUncheckParams, options: TimeoutOptions): Promise<ElementHandleUncheckResult>;
+ waitForElementState(params: ElementHandleWaitForElementStateParams, options: TimeoutOptions): Promise<ElementHandleWaitForElementStateResult>;
+ waitForSelector(params: ElementHandleWaitForSelectorParams, options: TimeoutOptions): Promise<ElementHandleWaitForSelectorResult>;
}
export type ElementHandleEvalOnSelectorParams = {
selector: string,
@@ -3142,7 +3097,6 @@ export type ElementHandleCheckParams = {
force?: boolean,
scroll?: 'auto' | 'none',
position?: Point,
- timeout: number,
trial?: boolean,
};
export type ElementHandleCheckOptions = {
@@ -3161,7 +3115,6 @@ export type ElementHandleClickParams = {
delay?: number,
button?: 'left' | 'right' | 'middle',
clickCount?: number,
- timeout: number,
trial?: boolean,
steps?: number,
};
@@ -3190,7 +3143,6 @@ export type ElementHandleDblclickParams = {
position?: Point,
delay?: number,
button?: 'left' | 'right' | 'middle',
- timeout: number,
trial?: boolean,
steps?: number,
};
@@ -3216,7 +3168,6 @@ export type ElementHandleDispatchEventResult = void;
export type ElementHandleFillParams = {
value: string,
force?: boolean,
- timeout: number,
};
export type ElementHandleFillOptions = {
force?: boolean,
@@ -3239,7 +3190,6 @@ export type ElementHandleHoverParams = {
scroll?: 'auto' | 'none',
modifiers?: ('Alt' | 'Control' | 'ControlOrMeta' | 'Meta' | 'Shift')[],
position?: Point,
- timeout: number,
trial?: boolean,
};
export type ElementHandleHoverOptions = {
@@ -3303,7 +3253,6 @@ export type ElementHandleOwnerFrameResult = {
export type ElementHandlePressParams = {
key: string,
delay?: number,
- timeout: number,
noWaitAfter?: boolean,
};
export type ElementHandlePressOptions = {
@@ -3331,7 +3280,6 @@ export type ElementHandleQuerySelectorAllResult = {
elements: ElementHandleChannel[],
};
export type ElementHandleScreenshotParams = {
- timeout: number,
type?: 'png' | 'jpeg' | 'webp',
quality?: number,
omitBackground?: boolean,
@@ -3362,12 +3310,8 @@ export type ElementHandleScreenshotOptions = {
export type ElementHandleScreenshotResult = {
binary: Binary,
};
-export type ElementHandleScrollIntoViewIfNeededParams = {
- timeout: number,
-};
-export type ElementHandleScrollIntoViewIfNeededOptions = {
-
-};
+export type ElementHandleScrollIntoViewIfNeededParams = {};
+export type ElementHandleScrollIntoViewIfNeededOptions = {};
export type ElementHandleScrollIntoViewIfNeededResult = void;
export type ElementHandleSelectOptionParams = {
elements?: ElementHandleChannel[],
@@ -3378,7 +3322,6 @@ export type ElementHandleSelectOptionParams = {
index?: number,
}[],
force?: boolean,
- timeout: number,
};
export type ElementHandleSelectOptionOptions = {
elements?: ElementHandleChannel[],
@@ -3395,7 +3338,6 @@ export type ElementHandleSelectOptionResult = {
};
export type ElementHandleSelectTextParams = {
force?: boolean,
- timeout: number,
};
export type ElementHandleSelectTextOptions = {
force?: boolean,
@@ -3411,7 +3353,6 @@ export type ElementHandleSetInputFilesParams = {
directoryStream?: WritableStreamChannel,
localPaths?: string[],
streams?: WritableStreamChannel[],
- timeout: number,
};
export type ElementHandleSetInputFilesOptions = {
payloads?: {
@@ -3430,7 +3371,6 @@ export type ElementHandleTapParams = {
scroll?: 'auto' | 'none',
modifiers?: ('Alt' | 'Control' | 'ControlOrMeta' | 'Meta' | 'Shift')[],
position?: Point,
- timeout: number,
trial?: boolean,
};
export type ElementHandleTapOptions = {
@@ -3449,7 +3389,6 @@ export type ElementHandleTextContentResult = {
export type ElementHandleTypeParams = {
text: string,
delay?: number,
- timeout: number,
};
export type ElementHandleTypeOptions = {
delay?: number,
@@ -3459,7 +3398,6 @@ export type ElementHandleUncheckParams = {
force?: boolean,
scroll?: 'auto' | 'none',
position?: Point,
- timeout: number,
trial?: boolean,
};
export type ElementHandleUncheckOptions = {
@@ -3471,7 +3409,6 @@ export type ElementHandleUncheckOptions = {
export type ElementHandleUncheckResult = void;
export type ElementHandleWaitForElementStateParams = {
state: 'visible' | 'hidden' | 'stable' | 'enabled' | 'disabled' | 'editable',
- timeout: number,
};
export type ElementHandleWaitForElementStateOptions = {
@@ -3480,7 +3417,6 @@ export type ElementHandleWaitForElementStateResult = void;
export type ElementHandleWaitForSelectorParams = {
selector: string,
strict?: boolean,
- timeout: number,
state?: 'attached' | 'detached' | 'visible' | 'hidden',
};
export type ElementHandleWaitForSelectorOptions = {
@@ -3519,16 +3455,16 @@ export interface LocalUtilsEventTarget {
}
export interface LocalUtilsChannel extends LocalUtilsEventTarget, Channel {
_type_LocalUtils: boolean;
- zip(params: LocalUtilsZipParams, signal: AbortSignal | undefined): Promise<LocalUtilsZipResult>;
- harOpen(params: LocalUtilsHarOpenParams, signal: AbortSignal | undefined): Promise<LocalUtilsHarOpenResult>;
- harLookup(params: LocalUtilsHarLookupParams, signal: AbortSignal | undefined): Promise<LocalUtilsHarLookupResult>;
- harClose(params: LocalUtilsHarCloseParams, signal: AbortSignal | undefined): Promise<LocalUtilsHarCloseResult>;
- harUnzip(params: LocalUtilsHarUnzipParams, signal: AbortSignal | undefined): Promise<LocalUtilsHarUnzipResult>;
- connect(params: LocalUtilsConnectParams, signal: AbortSignal | undefined): Promise<LocalUtilsConnectResult>;
- tracingStarted(params: LocalUtilsTracingStartedParams, signal: AbortSignal | undefined): Promise<LocalUtilsTracingStartedResult>;
- addStackToTracingNoReply(params: LocalUtilsAddStackToTracingNoReplyParams, signal: AbortSignal | undefined): Promise<LocalUtilsAddStackToTracingNoReplyResult>;
- traceDiscarded(params: LocalUtilsTraceDiscardedParams, signal: AbortSignal | undefined): Promise<LocalUtilsTraceDiscardedResult>;
- globToRegex(params: LocalUtilsGlobToRegexParams, signal: AbortSignal | undefined): Promise<LocalUtilsGlobToRegexResult>;
+ zip(params: LocalUtilsZipParams, options: TimeoutOptions): Promise<LocalUtilsZipResult>;
+ harOpen(params: LocalUtilsHarOpenParams, options: TimeoutOptions): Promise<LocalUtilsHarOpenResult>;
+ harLookup(params: LocalUtilsHarLookupParams, options: TimeoutOptions): Promise<LocalUtilsHarLookupResult>;
+ harClose(params: LocalUtilsHarCloseParams, options: TimeoutOptions): Promise<LocalUtilsHarCloseResult>;
+ harUnzip(params: LocalUtilsHarUnzipParams, options: TimeoutOptions): Promise<LocalUtilsHarUnzipResult>;
+ connect(params: LocalUtilsConnectParams, options: TimeoutOptions): Promise<LocalUtilsConnectResult>;
+ tracingStarted(params: LocalUtilsTracingStartedParams, options: TimeoutOptions): Promise<LocalUtilsTracingStartedResult>;
+ addStackToTracingNoReply(params: LocalUtilsAddStackToTracingNoReplyParams, options: TimeoutOptions): Promise<LocalUtilsAddStackToTracingNoReplyResult>;
+ traceDiscarded(params: LocalUtilsTraceDiscardedParams, options: TimeoutOptions): Promise<LocalUtilsTraceDiscardedResult>;
+ globToRegex(params: LocalUtilsGlobToRegexParams, options: TimeoutOptions): Promise<LocalUtilsGlobToRegexResult>;
}
export type LocalUtilsZipParams = {
zipFile: string,
@@ -3593,7 +3529,6 @@ export type LocalUtilsConnectParams = {
headers?: any,
exposeNetwork?: string,
slowMo?: number,
- timeout: number,
socksProxyRedirectPortForTest?: number,
};
export type LocalUtilsConnectOptions = {
@@ -3664,8 +3599,8 @@ export interface RequestEventTarget {
}
export interface RequestChannel extends RequestEventTarget, Channel {
_type_Request: boolean;
- response(params: RequestResponseParams, signal: AbortSignal | undefined): Promise<RequestResponseResult>;
- rawRequestHeaders(params: RequestRawRequestHeadersParams, signal: AbortSignal | undefined): Promise<RequestRawRequestHeadersResult>;
+ response(params: RequestResponseParams, options: TimeoutOptions): Promise<RequestResponseResult>;
+ rawRequestHeaders(params: RequestRawRequestHeadersParams, options: TimeoutOptions): Promise<RequestRawRequestHeadersResult>;
}
export type RequestResponseParams = {};
export type RequestResponseOptions = {};
@@ -3689,10 +3624,10 @@ export interface RouteEventTarget {
}
export interface RouteChannel extends RouteEventTarget, Channel {
_type_Route: boolean;
- redirectNavigationRequest(params: RouteRedirectNavigationRequestParams, signal: AbortSignal | undefined): Promise<RouteRedirectNavigationRequestResult>;
- abort(params: RouteAbortParams, signal: AbortSignal | undefined): Promise<RouteAbortResult>;
- continue(params: RouteContinueParams, signal: AbortSignal | undefined): Promise<RouteContinueResult>;
- fulfill(params: RouteFulfillParams, signal: AbortSignal | undefined): Promise<RouteFulfillResult>;
+ redirectNavigationRequest(params: RouteRedirectNavigationRequestParams, options: TimeoutOptions): Promise<RouteRedirectNavigationRequestResult>;
+ abort(params: RouteAbortParams, options: TimeoutOptions): Promise<RouteAbortResult>;
+ continue(params: RouteContinueParams, options: TimeoutOptions): Promise<RouteContinueResult>;
+ fulfill(params: RouteFulfillParams, options: TimeoutOptions): Promise<RouteFulfillResult>;
}
export type RouteRedirectNavigationRequestParams = {
url: string,
@@ -3754,12 +3689,12 @@ export interface WebSocketRouteEventTarget {
}
export interface WebSocketRouteChannel extends WebSocketRouteEventTarget, Channel {
_type_WebSocketRoute: boolean;
- connect(params: WebSocketRouteConnectParams, signal: AbortSignal | undefined): Promise<WebSocketRouteConnectResult>;
- ensureOpened(params: WebSocketRouteEnsureOpenedParams, signal: AbortSignal | undefined): Promise<WebSocketRouteEnsureOpenedResult>;
- sendToPage(params: WebSocketRouteSendToPageParams, signal: AbortSignal | undefined): Promise<WebSocketRouteSendToPageResult>;
- sendToServer(params: WebSocketRouteSendToServerParams, signal: AbortSignal | undefined): Promise<WebSocketRouteSendToServerResult>;
- closePage(params: WebSocketRouteClosePageParams, signal: AbortSignal | undefined): Promise<WebSocketRouteClosePageResult>;
- closeServer(params: WebSocketRouteCloseServerParams, signal: AbortSignal | undefined): Promise<WebSocketRouteCloseServerResult>;
+ connect(params: WebSocketRouteConnectParams, options: TimeoutOptions): Promise<WebSocketRouteConnectResult>;
+ ensureOpened(params: WebSocketRouteEnsureOpenedParams, options: TimeoutOptions): Promise<WebSocketRouteEnsureOpenedResult>;
+ sendToPage(params: WebSocketRouteSendToPageParams, options: TimeoutOptions): Promise<WebSocketRouteSendToPageResult>;
+ sendToServer(params: WebSocketRouteSendToServerParams, options: TimeoutOptions): Promise<WebSocketRouteSendToServerResult>;
+ closePage(params: WebSocketRouteClosePageParams, options: TimeoutOptions): Promise<WebSocketRouteClosePageResult>;
+ closeServer(params: WebSocketRouteCloseServerParams, options: TimeoutOptions): Promise<WebSocketRouteCloseServerResult>;
}
export type WebSocketRouteMessageFromPageEvent = {
message: string,
@@ -3843,12 +3778,12 @@ export interface ResponseEventTarget {
}
export interface ResponseChannel extends ResponseEventTarget, Channel {
_type_Response: boolean;
- body(params: ResponseBodyParams, signal: AbortSignal | undefined): Promise<ResponseBodyResult>;
- securityDetails(params: ResponseSecurityDetailsParams, signal: AbortSignal | undefined): Promise<ResponseSecurityDetailsResult>;
- serverAddr(params: ResponseServerAddrParams, signal: AbortSignal | undefined): Promise<ResponseServerAddrResult>;
- rawResponseHeaders(params: ResponseRawResponseHeadersParams, signal: AbortSignal | undefined): Promise<ResponseRawResponseHeadersResult>;
- httpVersion(params: ResponseHttpVersionParams, signal: AbortSignal | undefined): Promise<ResponseHttpVersionResult>;
- sizes(params: ResponseSizesParams, signal: AbortSignal | undefined): Promise<ResponseSizesResult>;
+ body(params: ResponseBodyParams, options: TimeoutOptions): Promise<ResponseBodyResult>;
+ securityDetails(params: ResponseSecurityDetailsParams, options: TimeoutOptions): Promise<ResponseSecurityDetailsResult>;
+ serverAddr(params: ResponseServerAddrParams, options: TimeoutOptions): Promise<ResponseServerAddrResult>;
+ rawResponseHeaders(params: ResponseRawResponseHeadersParams, options: TimeoutOptions): Promise<ResponseRawResponseHeadersResult>;
+ httpVersion(params: ResponseHttpVersionParams, options: TimeoutOptions): Promise<ResponseHttpVersionResult>;
+ sizes(params: ResponseSizesParams, options: TimeoutOptions): Promise<ResponseSizesResult>;
}
export type ResponseBodyParams = {};
export type ResponseBodyOptions = {};
@@ -3949,64 +3884,64 @@ export interface PageEventTarget {
}
export interface PageChannel extends PageEventTarget, Channel {
_type_Page: boolean;
- addInitScript(params: PageAddInitScriptParams, signal: AbortSignal | undefined): Promise<PageAddInitScriptResult>;
- close(params: PageCloseParams, signal: AbortSignal | undefined): Promise<PageCloseResult>;
- runBeforeUnload(params: PageRunBeforeUnloadParams, signal: AbortSignal | undefined): Promise<PageRunBeforeUnloadResult>;
- clearConsoleMessages(params: PageClearConsoleMessagesParams, signal: AbortSignal | undefined): Promise<PageClearConsoleMessagesResult>;
- consoleMessages(params: PageConsoleMessagesParams, signal: AbortSignal | undefined): Promise<PageConsoleMessagesResult>;
- emulateMedia(params: PageEmulateMediaParams, signal: AbortSignal | undefined): Promise<PageEmulateMediaResult>;
- exposeBinding(params: PageExposeBindingParams, signal: AbortSignal | undefined): Promise<PageExposeBindingResult>;
- goBack(params: PageGoBackParams, signal: AbortSignal | undefined): Promise<PageGoBackResult>;
- goForward(params: PageGoForwardParams, signal: AbortSignal | undefined): Promise<PageGoForwardResult>;
- requestGC(params: PageRequestGCParams, signal: AbortSignal | undefined): Promise<PageRequestGCResult>;
- registerLocatorHandler(params: PageRegisterLocatorHandlerParams, signal: AbortSignal | undefined): Promise<PageRegisterLocatorHandlerResult>;
- resolveLocatorHandlerNoReply(params: PageResolveLocatorHandlerNoReplyParams, signal: AbortSignal | undefined): Promise<PageResolveLocatorHandlerNoReplyResult>;
- unregisterLocatorHandler(params: PageUnregisterLocatorHandlerParams, signal: AbortSignal | undefined): Promise<PageUnregisterLocatorHandlerResult>;
- reload(params: PageReloadParams, signal: AbortSignal | undefined): Promise<PageReloadResult>;
- expectScreenshot(params: PageExpectScreenshotParams, signal: AbortSignal | undefined): Promise<PageExpectScreenshotResult>;
- screenshot(params: PageScreenshotParams, signal: AbortSignal | undefined): Promise<PageScreenshotResult>;
- setExtraHTTPHeaders(params: PageSetExtraHTTPHeadersParams, signal: AbortSignal | undefined): Promise<PageSetExtraHTTPHeadersResult>;
- setNetworkInterceptionPatterns(params: PageSetNetworkInterceptionPatternsParams, signal: AbortSignal | undefined): Promise<PageSetNetworkInterceptionPatternsResult>;
- setWebSocketInterceptionPatterns(params: PageSetWebSocketInterceptionPatternsParams, signal: AbortSignal | undefined): Promise<PageSetWebSocketInterceptionPatternsResult>;
- setViewportSize(params: PageSetViewportSizeParams, signal: AbortSignal | undefined): Promise<PageSetViewportSizeResult>;
- keyboardDown(params: PageKeyboardDownParams, signal: AbortSignal | undefined): Promise<PageKeyboardDownResult>;
- keyboardUp(params: PageKeyboardUpParams, signal: AbortSignal | undefined): Promise<PageKeyboardUpResult>;
- keyboardInsertText(params: PageKeyboardInsertTextParams, signal: AbortSignal | undefined): Promise<PageKeyboardInsertTextResult>;
- keyboardType(params: PageKeyboardTypeParams, signal: AbortSignal | undefined): Promise<PageKeyboardTypeResult>;
- keyboardPress(params: PageKeyboardPressParams, signal: AbortSignal | undefined): Promise<PageKeyboardPressResult>;
- mouseMove(params: PageMouseMoveParams, signal: AbortSignal | undefined): Promise<PageMouseMoveResult>;
- mouseDown(params: PageMouseDownParams, signal: AbortSignal | undefined): Promise<PageMouseDownResult>;
- mouseUp(params: PageMouseUpParams, signal: AbortSignal | undefined): Promise<PageMouseUpResult>;
- mouseClick(params: PageMouseClickParams, signal: AbortSignal | undefined): Promise<PageMouseClickResult>;
- mouseWheel(params: PageMouseWheelParams, signal: AbortSignal | undefined): Promise<PageMouseWheelResult>;
- touchscreenTap(params: PageTouchscreenTapParams, signal: AbortSignal | undefined): Promise<PageTouchscreenTapResult>;
- clearPageErrors(params: PageClearPageErrorsParams, signal: AbortSignal | undefined): Promise<PageClearPageErrorsResult>;
- pageErrors(params: PagePageErrorsParams, signal: AbortSignal | undefined): Promise<PagePageErrorsResult>;
- pdf(params: PagePdfParams, signal: AbortSignal | undefined): Promise<PagePdfResult>;
- requests(params: PageRequestsParams, signal: AbortSignal | undefined): Promise<PageRequestsResult>;
- startJSCoverage(params: PageStartJSCoverageParams, signal: AbortSignal | undefined): Promise<PageStartJSCoverageResult>;
- stopJSCoverage(params: PageStopJSCoverageParams, signal: AbortSignal | undefined): Promise<PageStopJSCoverageResult>;
- startCSSCoverage(params: PageStartCSSCoverageParams, signal: AbortSignal | undefined): Promise<PageStartCSSCoverageResult>;
- stopCSSCoverage(params: PageStopCSSCoverageParams, signal: AbortSignal | undefined): Promise<PageStopCSSCoverageResult>;
- bringToFront(params: PageBringToFrontParams, signal: AbortSignal | undefined): Promise<PageBringToFrontResult>;
- pickLocator(params: PagePickLocatorParams, signal: AbortSignal | undefined): Promise<PagePickLocatorResult>;
- cancelPickLocator(params: PageCancelPickLocatorParams, signal: AbortSignal | undefined): Promise<PageCancelPickLocatorResult>;
- hideHighlight(params: PageHideHighlightParams, signal: AbortSignal | undefined): Promise<PageHideHighlightResult>;
- screencastShowOverlay(params: PageScreencastShowOverlayParams, signal: AbortSignal | undefined): Promise<PageScreencastShowOverlayResult>;
- screencastRemoveOverlay(params: PageScreencastRemoveOverlayParams, signal: AbortSignal | undefined): Promise<PageScreencastRemoveOverlayResult>;
- screencastChapter(params: PageScreencastChapterParams, signal: AbortSignal | undefined): Promise<PageScreencastChapterResult>;
- screencastSetOverlayVisible(params: PageScreencastSetOverlayVisibleParams, signal: AbortSignal | undefined): Promise<PageScreencastSetOverlayVisibleResult>;
- screencastShowActions(params: PageScreencastShowActionsParams, signal: AbortSignal | undefined): Promise<PageScreencastShowActionsResult>;
- screencastHideActions(params: PageScreencastHideActionsParams, signal: AbortSignal | undefined): Promise<PageScreencastHideActionsResult>;
- screencastStart(params: PageScreencastStartParams, signal: AbortSignal | undefined): Promise<PageScreencastStartResult>;
- screencastStop(params: PageScreencastStopParams, signal: AbortSignal | undefined): Promise<PageScreencastStopResult>;
- updateSubscription(params: PageUpdateSubscriptionParams, signal: AbortSignal | undefined): Promise<PageUpdateSubscriptionResult>;
- setDockTile(params: PageSetDockTileParams, signal: AbortSignal | undefined): Promise<PageSetDockTileResult>;
- webStorageItems(params: PageWebStorageItemsParams, signal: AbortSignal | undefined): Promise<PageWebStorageItemsResult>;
- webStorageGetItem(params: PageWebStorageGetItemParams, signal: AbortSignal | undefined): Promise<PageWebStorageGetItemResult>;
- webStorageSetItem(params: PageWebStorageSetItemParams, signal: AbortSignal | undefined): Promise<PageWebStorageSetItemResult>;
- webStorageRemoveItem(params: PageWebStorageRemoveItemParams, signal: AbortSignal | undefined): Promise<PageWebStorageRemoveItemResult>;
- webStorageClear(params: PageWebStorageClearParams, signal: AbortSignal | undefined): Promise<PageWebStorageClearResult>;
+ addInitScript(params: PageAddInitScriptParams, options: TimeoutOptions): Promise<PageAddInitScriptResult>;
+ close(params: PageCloseParams, options: TimeoutOptions): Promise<PageCloseResult>;
+ runBeforeUnload(params: PageRunBeforeUnloadParams, options: TimeoutOptions): Promise<PageRunBeforeUnloadResult>;
+ clearConsoleMessages(params: PageClearConsoleMessagesParams, options: TimeoutOptions): Promise<PageClearConsoleMessagesResult>;
+ consoleMessages(params: PageConsoleMessagesParams, options: TimeoutOptions): Promise<PageConsoleMessagesResult>;
+ emulateMedia(params: PageEmulateMediaParams, options: TimeoutOptions): Promise<PageEmulateMediaResult>;
+ exposeBinding(params: PageExposeBindingParams, options: TimeoutOptions): Promise<PageExposeBindingResult>;
+ goBack(params: PageGoBackParams, options: TimeoutOptions): Promise<PageGoBackResult>;
+ goForward(params: PageGoForwardParams, options: TimeoutOptions): Promise<PageGoForwardResult>;
+ requestGC(params: PageRequestGCParams, options: TimeoutOptions): Promise<PageRequestGCResult>;
+ registerLocatorHandler(params: PageRegisterLocatorHandlerParams, options: TimeoutOptions): Promise<PageRegisterLocatorHandlerResult>;
+ resolveLocatorHandlerNoReply(params: PageResolveLocatorHandlerNoReplyParams, options: TimeoutOptions): Promise<PageResolveLocatorHandlerNoReplyResult>;
+ unregisterLocatorHandler(params: PageUnregisterLocatorHandlerParams, options: TimeoutOptions): Promise<PageUnregisterLocatorHandlerResult>;
+ reload(params: PageReloadParams, options: TimeoutOptions): Promise<PageReloadResult>;
+ expectScreenshot(params: PageExpectScreenshotParams, options: TimeoutOptions): Promise<PageExpectScreenshotResult>;
+ screenshot(params: PageScreenshotParams, options: TimeoutOptions): Promise<PageScreenshotResult>;
+ setExtraHTTPHeaders(params: PageSetExtraHTTPHeadersParams, options: TimeoutOptions): Promise<PageSetExtraHTTPHeadersResult>;
+ setNetworkInterceptionPatterns(params: PageSetNetworkInterceptionPatternsParams, options: TimeoutOptions): Promise<PageSetNetworkInterceptionPatternsResult>;
+ setWebSocketInterceptionPatterns(params: PageSetWebSocketInterceptionPatternsParams, options: TimeoutOptions): Promise<PageSetWebSocketInterceptionPatternsResult>;
+ setViewportSize(params: PageSetViewportSizeParams, options: TimeoutOptions): Promise<PageSetViewportSizeResult>;
+ keyboardDown(params: PageKeyboardDownParams, options: TimeoutOptions): Promise<PageKeyboardDownResult>;
+ keyboardUp(params: PageKeyboardUpParams, options: TimeoutOptions): Promise<PageKeyboardUpResult>;
+ keyboardInsertText(params: PageKeyboardInsertTextParams, options: TimeoutOptions): Promise<PageKeyboardInsertTextResult>;
+ keyboardType(params: PageKeyboardTypeParams, options: TimeoutOptions): Promise<PageKeyboardTypeResult>;
+ keyboardPress(params: PageKeyboardPressParams, options: TimeoutOptions): Promise<PageKeyboardPressResult>;
+ mouseMove(params: PageMouseMoveParams, options: TimeoutOptions): Promise<PageMouseMoveResult>;
+ mouseDown(params: PageMouseDownParams, options: TimeoutOptions): Promise<PageMouseDownResult>;
+ mouseUp(params: PageMouseUpParams, options: TimeoutOptions): Promise<PageMouseUpResult>;
+ mouseClick(params: PageMouseClickParams, options: TimeoutOptions): Promise<PageMouseClickResult>;
+ mouseWheel(params: PageMouseWheelParams, options: TimeoutOptions): Promise<PageMouseWheelResult>;
+ touchscreenTap(params: PageTouchscreenTapParams, options: TimeoutOptions): Promise<PageTouchscreenTapResult>;
+ clearPageErrors(params: PageClearPageErrorsParams, options: TimeoutOptions): Promise<PageClearPageErrorsResult>;
+ pageErrors(params: PagePageErrorsParams, options: TimeoutOptions): Promise<PagePageErrorsResult>;
+ pdf(params: PagePdfParams, options: TimeoutOptions): Promise<PagePdfResult>;
+ requests(params: PageRequestsParams, options: TimeoutOptions): Promise<PageRequestsResult>;
+ startJSCoverage(params: PageStartJSCoverageParams, options: TimeoutOptions): Promise<PageStartJSCoverageResult>;
+ stopJSCoverage(params: PageStopJSCoverageParams, options: TimeoutOptions): Promise<PageStopJSCoverageResult>;
+ startCSSCoverage(params: PageStartCSSCoverageParams, options: TimeoutOptions): Promise<PageStartCSSCoverageResult>;
+ stopCSSCoverage(params: PageStopCSSCoverageParams, options: TimeoutOptions): Promise<PageStopCSSCoverageResult>;
+ bringToFront(params: PageBringToFrontParams, options: TimeoutOptions): Promise<PageBringToFrontResult>;
+ pickLocator(params: PagePickLocatorParams, options: TimeoutOptions): Promise<PagePickLocatorResult>;
+ cancelPickLocator(params: PageCancelPickLocatorParams, options: TimeoutOptions): Promise<PageCancelPickLocatorResult>;
+ hideHighlight(params: PageHideHighlightParams, options: TimeoutOptions): Promise<PageHideHighlightResult>;
+ screencastShowOverlay(params: PageScreencastShowOverlayParams, options: TimeoutOptions): Promise<PageScreencastShowOverlayResult>;
+ screencastRemoveOverlay(params: PageScreencastRemoveOverlayParams, options: TimeoutOptions): Promise<PageScreencastRemoveOverlayResult>;
+ screencastChapter(params: PageScreencastChapterParams, options: TimeoutOptions): Promise<PageScreencastChapterResult>;
+ screencastSetOverlayVisible(params: PageScreencastSetOverlayVisibleParams, options: TimeoutOptions): Promise<PageScreencastSetOverlayVisibleResult>;
+ screencastShowActions(params: PageScreencastShowActionsParams, options: TimeoutOptions): Promise<PageScreencastShowActionsResult>;
+ screencastHideActions(params: PageScreencastHideActionsParams, options: TimeoutOptions): Promise<PageScreencastHideActionsResult>;
+ screencastStart(params: PageScreencastStartParams, options: TimeoutOptions): Promise<PageScreencastStartResult>;
+ screencastStop(params: PageScreencastStopParams, options: TimeoutOptions): Promise<PageScreencastStopResult>;
+ updateSubscription(params: PageUpdateSubscriptionParams, options: TimeoutOptions): Promise<PageUpdateSubscriptionResult>;
+ setDockTile(params: PageSetDockTileParams, options: TimeoutOptions): Promise<PageSetDockTileResult>;
+ webStorageItems(params: PageWebStorageItemsParams, options: TimeoutOptions): Promise<PageWebStorageItemsResult>;
+ webStorageGetItem(params: PageWebStorageGetItemParams, options: TimeoutOptions): Promise<PageWebStorageGetItemResult>;
+ webStorageSetItem(params: PageWebStorageSetItemParams, options: TimeoutOptions): Promise<PageWebStorageSetItemResult>;
+ webStorageRemoveItem(params: PageWebStorageRemoveItemParams, options: TimeoutOptions): Promise<PageWebStorageRemoveItemResult>;
+ webStorageClear(params: PageWebStorageClearParams, options: TimeoutOptions): Promise<PageWebStorageClearResult>;
}
export type PageBindingCallEvent = {
binding: BindingCallChannel,
@@ -4121,7 +4056,6 @@ export type PageExposeBindingResult = {
disposable: DisposableChannel,
};
export type PageGoBackParams = {
- timeout: number,
waitUntil?: LifecycleEvent,
};
export type PageGoBackOptions = {
@@ -4131,7 +4065,6 @@ export type PageGoBackResult = {
response?: ResponseChannel,
};
export type PageGoForwardParams = {
- timeout: number,
waitUntil?: LifecycleEvent,
};
export type PageGoForwardOptions = {
@@ -4169,7 +4102,6 @@ export type PageUnregisterLocatorHandlerOptions = {
};
export type PageUnregisterLocatorHandlerResult = void;
export type PageReloadParams = {
- timeout: number,
waitUntil?: LifecycleEvent,
};
export type PageReloadOptions = {
@@ -4180,7 +4112,6 @@ export type PageReloadResult = {
};
export type PageExpectScreenshotParams = {
expected?: Binary,
- timeout: number,
isNot: boolean,
locator?: {
frame: FrameChannel,
@@ -4240,7 +4171,6 @@ export type PageExpectScreenshotErrorDetails = {
log?: string[],
};
export type PageScreenshotParams = {
- timeout: number,
type?: 'png' | 'jpeg' | 'webp',
quality?: number,
fullPage?: boolean,
@@ -4687,7 +4617,7 @@ export interface RootEventTarget {
}
export interface RootChannel extends RootEventTarget, Channel {
_type_Root: boolean;
- initialize(params: RootInitializeParams, signal: AbortSignal | undefined): Promise<RootInitializeResult>;
+ initialize(params: RootInitializeParams, options: TimeoutOptions): Promise<RootInitializeResult>;
}
export type RootInitializeParams = {
sdkLanguage: SDKLanguage,
@@ -4718,7 +4648,7 @@ export interface PlaywrightEventTarget {
}
export interface PlaywrightChannel extends PlaywrightEventTarget, Channel {
_type_Playwright: boolean;
- newRequest(params: PlaywrightNewRequestParams, signal: AbortSignal | undefined): Promise<PlaywrightNewRequestResult>;
+ newRequest(params: PlaywrightNewRequestParams, options: TimeoutOptions): Promise<PlaywrightNewRequestResult>;
}
export type PlaywrightNewRequestParams = {
baseURL?: string,
@@ -4802,13 +4732,13 @@ export interface DebugControllerEventTarget {
}
export interface DebugControllerChannel extends DebugControllerEventTarget, Channel {
_type_DebugController: boolean;
- initialize(params: DebugControllerInitializeParams, signal: AbortSignal | undefined): Promise<DebugControllerInitializeResult>;
- setReportStateChanged(params: DebugControllerSetReportStateChangedParams, signal: AbortSignal | undefined): Promise<DebugControllerSetReportStateChangedResult>;
- setRecorderMode(params: DebugControllerSetRecorderModeParams, signal: AbortSignal | undefined): Promise<DebugControllerSetRecorderModeResult>;
- highlight(params: DebugControllerHighlightParams, signal: AbortSignal | undefined): Promise<DebugControllerHighlightResult>;
- hideHighlight(params: DebugControllerHideHighlightParams, signal: AbortSignal | undefined): Promise<DebugControllerHideHighlightResult>;
- resume(params: DebugControllerResumeParams, signal: AbortSignal | undefined): Promise<DebugControllerResumeResult>;
- kill(params: DebugControllerKillParams, signal: AbortSignal | undefined): Promise<DebugControllerKillResult>;
+ initialize(params: DebugControllerInitializeParams, options: TimeoutOptions): Promise<DebugControllerInitializeResult>;
+ setReportStateChanged(params: DebugControllerSetReportStateChangedParams, options: TimeoutOptions): Promise<DebugControllerSetReportStateChangedResult>;
+ setRecorderMode(params: DebugControllerSetRecorderModeParams, options: TimeoutOptions): Promise<DebugControllerSetRecorderModeResult>;
+ highlight(params: DebugControllerHighlightParams, options: TimeoutOptions): Promise<DebugControllerHighlightResult>;
+ hideHighlight(params: DebugControllerHideHighlightParams, options: TimeoutOptions): Promise<DebugControllerHideHighlightResult>;
+ resume(params: DebugControllerResumeParams, options: TimeoutOptions): Promise<DebugControllerResumeResult>;
+ kill(params: DebugControllerKillParams, options: TimeoutOptions): Promise<DebugControllerKillResult>;
}
export type DebugControllerInspectRequestedEvent = {
selector: string,
@@ -4891,11 +4821,11 @@ export interface SocksSupportEventTarget {
}
export interface SocksSupportChannel extends SocksSupportEventTarget, Channel {
_type_SocksSupport: boolean;
- socksConnected(params: SocksSupportSocksConnectedParams, signal: AbortSignal | undefined): Promise<SocksSupportSocksConnectedResult>;
- socksFailed(params: SocksSupportSocksFailedParams, signal: AbortSignal | undefined): Promise<SocksSupportSocksFailedResult>;
- socksData(params: SocksSupportSocksDataParams, signal: AbortSignal | undefined): Promise<SocksSupportSocksDataResult>;
- socksError(params: SocksSupportSocksErrorParams, signal: AbortSignal | undefined): Promise<SocksSupportSocksErrorResult>;
- socksEnd(params: SocksSupportSocksEndParams, signal: AbortSignal | undefined): Promise<SocksSupportSocksEndResult>;
+ socksConnected(params: SocksSupportSocksConnectedParams, options: TimeoutOptions): Promise<SocksSupportSocksConnectedResult>;
+ socksFailed(params: SocksSupportSocksFailedParams, options: TimeoutOptions): Promise<SocksSupportSocksFailedResult>;
+ socksData(params: SocksSupportSocksDataParams, options: TimeoutOptions): Promise<SocksSupportSocksDataResult>;
+ socksError(params: SocksSupportSocksErrorParams, options: TimeoutOptions): Promise<SocksSupportSocksErrorResult>;
+ socksEnd(params: SocksSupportSocksEndParams, options: TimeoutOptions): Promise<SocksSupportSocksEndResult>;
}
export type SocksSupportSocksRequestedEvent = {
uid: string,
@@ -4964,8 +4894,8 @@ export interface JsonPipeEventTarget {
}
export interface JsonPipeChannel extends JsonPipeEventTarget, Channel {
_type_JsonPipe: boolean;
- send(params: JsonPipeSendParams, signal: AbortSignal | undefined): Promise<JsonPipeSendResult>;
- close(params: JsonPipeCloseParams, signal: AbortSignal | undefined): Promise<JsonPipeCloseResult>;
+ send(params: JsonPipeSendParams, options: TimeoutOptions): Promise<JsonPipeSendResult>;
+ close(params: JsonPipeCloseParams, options: TimeoutOptions): Promise<JsonPipeCloseResult>;
}
export type JsonPipeMessageEvent = {
message: any,
@@ -4997,8 +4927,8 @@ export interface CDPSessionEventTarget {
}
export interface CDPSessionChannel extends CDPSessionEventTarget, Channel {
_type_CDPSession: boolean;
- send(params: CDPSessionSendParams, signal: AbortSignal | undefined): Promise<CDPSessionSendResult>;
- detach(params: CDPSessionDetachParams, signal: AbortSignal | undefined): Promise<CDPSessionDetachResult>;
+ send(params: CDPSessionSendParams, options: TimeoutOptions): Promise<CDPSessionSendResult>;
+ detach(params: CDPSessionDetachParams, options: TimeoutOptions): Promise<CDPSessionDetachResult>;
}
export type CDPSessionEventEvent = {
method: string,
@@ -5034,8 +4964,8 @@ export interface BindingCallEventTarget {
}
export interface BindingCallChannel extends BindingCallEventTarget, Channel {
_type_BindingCall: boolean;
- reject(params: BindingCallRejectParams, signal: AbortSignal | undefined): Promise<BindingCallRejectResult>;
- resolve(params: BindingCallResolveParams, signal: AbortSignal | undefined): Promise<BindingCallResolveResult>;
+ reject(params: BindingCallRejectParams, options: TimeoutOptions): Promise<BindingCallRejectResult>;
+ resolve(params: BindingCallResolveParams, options: TimeoutOptions): Promise<BindingCallResolveResult>;
}
export type BindingCallRejectParams = {
error: SerializedError,
@@ -5062,10 +4992,10 @@ export interface DebuggerEventTarget {
}
export interface DebuggerChannel extends DebuggerEventTarget, Channel {
_type_Debugger: boolean;
- requestPause(params: DebuggerRequestPauseParams, signal: AbortSignal | undefined): Promise<DebuggerRequestPauseResult>;
- resume(params: DebuggerResumeParams, signal: AbortSignal | undefined): Promise<DebuggerResumeResult>;
- next(params: DebuggerNextParams, signal: AbortSignal | undefined): Promise<DebuggerNextResult>;
- runTo(params: DebuggerRunToParams, signal: AbortSignal | undefined): Promise<DebuggerRunToResult>;
+ requestPause(params: DebuggerRequestPauseParams, options: TimeoutOptions): Promise<DebuggerRequestPauseResult>;
+ resume(params: DebuggerResumeParams, options: TimeoutOptions): Promise<DebuggerResumeResult>;
+ next(params: DebuggerNextParams, options: TimeoutOptions): Promise<DebuggerNextResult>;
+ runTo(params: DebuggerRunToParams, options: TimeoutOptions): Promise<DebuggerRunToResult>;
}
export type DebuggerPausedStateChangedEvent = {
pausedDetails?: {
@@ -5114,8 +5044,8 @@ export interface DialogEventTarget {
}
export interface DialogChannel extends DialogEventTarget, Channel {
_type_Dialog: boolean;
- accept(params: DialogAcceptParams, signal: AbortSignal | undefined): Promise<DialogAcceptResult>;
- dismiss(params: DialogDismissParams, signal: AbortSignal | undefined): Promise<DialogDismissResult>;
+ accept(params: DialogAcceptParams, options: TimeoutOptions): Promise<DialogAcceptResult>;
+ dismiss(params: DialogDismissParams, options: TimeoutOptions): Promise<DialogDismissResult>;
}
export type DialogAcceptParams = {
promptText?: string,
@@ -5137,14 +5067,14 @@ export interface TracingEventTarget {
}
export interface TracingChannel extends TracingEventTarget, Channel {
_type_Tracing: boolean;
- tracingStart(params: TracingTracingStartParams, signal: AbortSignal | undefined): Promise<TracingTracingStartResult>;
- tracingStartChunk(params: TracingTracingStartChunkParams, signal: AbortSignal | undefined): Promise<TracingTracingStartChunkResult>;
- tracingGroup(params: TracingTracingGroupParams, signal: AbortSignal | undefined): Promise<TracingTracingGroupResult>;
- tracingGroupEnd(params: TracingTracingGroupEndParams, signal: AbortSignal | undefined): Promise<TracingTracingGroupEndResult>;
- tracingStopChunk(params: TracingTracingStopChunkParams, signal: AbortSignal | undefined): Promise<TracingTracingStopChunkResult>;
- tracingStop(params: TracingTracingStopParams, signal: AbortSignal | undefined): Promise<TracingTracingStopResult>;
- harStart(params: TracingHarStartParams, signal: AbortSignal | undefined): Promise<TracingHarStartResult>;
- harExport(params: TracingHarExportParams, signal: AbortSignal | undefined): Promise<TracingHarExportResult>;
+ tracingStart(params: TracingTracingStartParams, options: TimeoutOptions): Promise<TracingTracingStartResult>;
+ tracingStartChunk(params: TracingTracingStartChunkParams, options: TimeoutOptions): Promise<TracingTracingStartChunkResult>;
+ tracingGroup(params: TracingTracingGroupParams, options: TimeoutOptions): Promise<TracingTracingGroupResult>;
+ tracingGroupEnd(params: TracingTracingGroupEndParams, options: TimeoutOptions): Promise<TracingTracingGroupEndResult>;
+ tracingStopChunk(params: TracingTracingStopChunkParams, options: TimeoutOptions): Promise<TracingTracingStopChunkResult>;
+ tracingStop(params: TracingTracingStopParams, options: TimeoutOptions): Promise<TracingTracingStopResult>;
+ harStart(params: TracingHarStartParams, options: TimeoutOptions): Promise<TracingHarStartResult>;
+ harExport(params: TracingHarExportParams, options: TimeoutOptions): Promise<TracingHarExportResult>;
}
export type TracingTracingStartParams = {
name?: string,
@@ -5237,10 +5167,10 @@ export interface WorkerEventTarget {
}
export interface WorkerChannel extends WorkerEventTarget, Channel {
_type_Worker: boolean;
- disconnect(params: WorkerDisconnectParams, signal: AbortSignal | undefined): Promise<WorkerDisconnectResult>;
- evaluateExpression(params: WorkerEvaluateExpressionParams, signal: AbortSignal | undefined): Promise<WorkerEvaluateExpressionResult>;
- evaluateExpressionHandle(params: WorkerEvaluateExpressionHandleParams, signal: AbortSignal | undefined): Promise<WorkerEvaluateExpressionHandleResult>;
- updateSubscription(params: WorkerUpdateSubscriptionParams, signal: AbortSignal | undefined): Promise<WorkerUpdateSubscriptionResult>;
+ disconnect(params: WorkerDisconnectParams, options: TimeoutOptions): Promise<WorkerDisconnectResult>;
+ evaluateExpression(params: WorkerEvaluateExpressionParams, options: TimeoutOptions): Promise<WorkerEvaluateExpressionResult>;
+ evaluateExpressionHandle(params: WorkerEvaluateExpressionHandleParams, options: TimeoutOptions): Promise<WorkerEvaluateExpressionHandleResult>;
+ updateSubscription(params: WorkerUpdateSubscriptionParams, options: TimeoutOptions): Promise<WorkerUpdateSubscriptionResult>;
}
export type WorkerConsoleEvent = {
type: string,
diff --git a/packages/playwright-core/src/client/clock.ts b/packages/playwright-core/src/client/clock.ts
index 6fa6074110..3ad1cee75b 100644
--- a/packages/playwright-core/src/client/clock.ts
+++ b/packages/playwright-core/src/client/clock.ts
@@ -14,6 +14,7 @@
* limitations under the License.
*/
+import { kNoTimeout } from './timeoutSettings';
import type { BrowserContext } from './browserContext';
import type * as api from '../../types/types';
@@ -25,31 +26,31 @@ export class Clock implements api.Clock {
}
async install(options: { time?: number | string | Date } = { }) {
- await this._browserContext._channel.clockInstall({ ...(options.time !== undefined ? parseTime(options.time) : {}) }, undefined);
+ await this._browserContext._channel.clockInstall({ ...(options.time !== undefined ? parseTime(options.time) : {}) }, kNoTimeout);
}
async fastForward(ticks: number | string) {
- await this._browserContext._channel.clockFastForward({ ...parseTicks(ticks) }, undefined);
+ await this._browserContext._channel.clockFastForward({ ...parseTicks(ticks) }, kNoTimeout);
}
async pauseAt(time: number | string | Date) {
- await this._browserContext._channel.clockPauseAt({ ...parseTime(time) }, undefined);
+ await this._browserContext._channel.clockPauseAt({ ...parseTime(time) }, kNoTimeout);
}
async resume() {
- await this._browserContext._channel.clockResume({}, undefined);
+ await this._browserContext._channel.clockResume({}, kNoTimeout);
}
async runFor(ticks: number | string) {
- await this._browserContext._channel.clockRunFor({ ...parseTicks(ticks) }, undefined);
+ await this._browserContext._channel.clockRunFor({ ...parseTicks(ticks) }, kNoTimeout);
}
async setFixedTime(time: string | number | Date) {
- await this._browserContext._channel.clockSetFixedTime({ ...parseTime(time) }, undefined);
+ await this._browserContext._channel.clockSetFixedTime({ ...parseTime(time) }, kNoTimeout);
}
async setSystemTime(time: string | number | Date) {
- await this._browserContext._channel.clockSetSystemTime({ ...parseTime(time) }, undefined);
+ await this._browserContext._channel.clockSetSystemTime({ ...parseTime(time) }, kNoTimeout);
}
}
diff --git a/packages/playwright-core/src/client/connect.ts b/packages/playwright-core/src/client/connect.ts
index 6f06c320f2..ab648bd874 100644
--- a/packages/playwright-core/src/client/connect.ts
+++ b/packages/playwright-core/src/client/connect.ts
@@ -20,6 +20,7 @@ import { Browser } from './browser';
import { ChannelOwner } from './channelOwner';
import { Connection } from './connection';
import { Events } from './events';
+import { kNoTimeout } from './timeoutSettings';
import type { Playwright } from './playwright';
import type { ConnectOptions, HeadersArray } from './types';
@@ -34,11 +35,10 @@ export async function connectToBrowser(playwright: Playwright, params: ConnectOp
headers,
exposeNetwork: params.exposeNetwork,
slowMo: params.slowMo,
- timeout: params.timeout || 0,
};
if ((params as any).__testHookRedirectPortForwarding)
connectParams.socksProxyRedirectPortForTest = (params as any).__testHookRedirectPortForwarding;
- const connection = await connectToEndpoint(playwright._connection, connectParams);
+ const connection = await connectToEndpoint(playwright._connection, connectParams, { signal: undefined, timeout: params.timeout || 0 });
let browser: Browser;
connection.on('close', () => {
// Emulate all pages, contexts and the browser closing upon disconnect.
@@ -74,10 +74,10 @@ export async function connectToBrowser(playwright: Playwright, params: ConnectOp
}
}
-export async function connectToEndpoint(parentConnection: Connection, params: channels.LocalUtilsConnectParams): Promise<Connection> {
+export async function connectToEndpoint(parentConnection: Connection, params: channels.LocalUtilsConnectParams, timeout: channels.TimeoutOptions): Promise<Connection> {
const localUtils = parentConnection.localUtils();
const transport = localUtils ? new JsonPipeTransport(localUtils) : new WebSocketTransport();
- const connectHeaders = await transport.connect(params);
+ const connectHeaders = await transport.connect(params, timeout);
const connection = new Connection(localUtils, parentConnection._instrumentation, connectHeaders);
connection.markAsRemote();
connection.on('close', () => transport.close());
@@ -100,7 +100,7 @@ export async function connectToEndpoint(parentConnection: Connection, params: ch
}
interface Transport {
- connect(params: channels.LocalUtilsConnectParams): Promise<HeadersArray>;
+ connect(params: channels.LocalUtilsConnectParams, timeout: channels.TimeoutOptions): Promise<HeadersArray>;
send(message: any): Promise<void>;
onMessage(callback: (message: object) => void): void;
onClose(callback: (reason?: string) => void): void;
@@ -115,14 +115,14 @@ class JsonPipeTransport implements Transport {
this._owner = owner;
}
- async connect(params: channels.LocalUtilsConnectParams) {
- const { pipe, headers: connectHeaders } = await this._owner._channel.connect(params, undefined);
+ async connect(params: channels.LocalUtilsConnectParams, timeout: channels.TimeoutOptions) {
+ const { pipe, headers: connectHeaders } = await this._owner._channel.connect(params, timeout);
this._pipe = pipe;
return connectHeaders;
}
async send(message: object) {
- await this._pipe!.send({ message }, undefined);
+ await this._pipe!.send({ message }, kNoTimeout);
}
onMessage(callback: (message: object) => void) {
@@ -134,14 +134,14 @@ class JsonPipeTransport implements Transport {
}
async close() {
- await this._pipe!.close({}, undefined).catch(() => {});
+ await this._pipe!.close({}, kNoTimeout).catch(() => {});
}
}
class WebSocketTransport implements Transport {
private _ws: WebSocket | undefined;
- async connect(params: channels.LocalUtilsConnectParams) {
+ async connect(params: channels.LocalUtilsConnectParams, timeout: channels.TimeoutOptions) {
this._ws = new window.WebSocket(params.endpoint);
return [];
}
diff --git a/packages/playwright-core/src/client/connection.ts b/packages/playwright-core/src/client/connection.ts
index db9de249a0..58780fea8d 100644
--- a/packages/playwright-core/src/client/connection.ts
+++ b/packages/playwright-core/src/client/connection.ts
@@ -47,6 +47,7 @@ import { Stream } from './stream';
import { Tracing } from './tracing';
import { Worker } from './worker';
import { WritableStream } from './writableStream';
+import { kNoTimeout } from './timeoutSettings';
import type { ClientInstrumentation } from './clientInstrumentation';
import type { HeadersArray } from './types';
import type { ValidatorContext } from '@protocol/validator';
@@ -60,7 +61,7 @@ class Root extends ChannelOwner<channels.RootChannel> {
async initialize(): Promise<Playwright> {
return Playwright.from((await this._channel.initialize({
sdkLanguage: 'javascript',
- }, undefined)).playwright);
+ }, kNoTimeout)).playwright);
}
}
@@ -174,7 +175,7 @@ export class Connection extends EventEmitter {
this._tracingCount--;
}
- async sendMessageToServer(object: ChannelOwner, method: string, params: any, options: { apiName?: string, title?: string, internal?: boolean, frames?: channels.StackFrame[], stepId?: string, signal?: AbortSignal }): Promise<any> {
+ async sendMessageToServer(object: ChannelOwner, method: string, params: any, options: { apiName?: string, title?: string, internal?: boolean, frames?: channels.StackFrame[], stepId?: string, signal?: AbortSignal, timeout: number }): Promise<any> {
// Fire-and-forget: server intentionally never replies to __waitInfo__,
// so silently drop it after the connection is closed or the object was collected.
if (method === '__waitInfo__' && (this._closedError || object._wasCollected))
@@ -197,7 +198,7 @@ export class Connection extends EventEmitter {
debugLogger.log('channel', 'SEND> ' + JSON.stringify(message));
}
const location = options.frames?.[0] ? { file: options.frames[0].file, line: options.frames[0].line, column: options.frames[0].column } : undefined;
- const metadata: channels.Metadata = { title: options.title, location, internal: options.internal, stepId: options.stepId };
+ const metadata: channels.Metadata = { title: options.title, location, internal: options.internal, stepId: options.stepId, timeout: options.timeout };
if (this._tracingCount && options.frames && type !== 'LocalUtils')
this._localUtils?.addStackToTracingNoReply({ callData: { stack: options.frames ?? [], id } }).catch(() => {});
// We need to exit zones before calling into the server, otherwise
diff --git a/packages/playwright-core/src/client/coverage.ts b/packages/playwright-core/src/client/coverage.ts
index 0ce0bb2348..4e21554c78 100644
--- a/packages/playwright-core/src/client/coverage.ts
+++ b/packages/playwright-core/src/client/coverage.ts
@@ -14,6 +14,7 @@
* limitations under the License.
*/
+import { kNoTimeout } from './timeoutSettings';
import type * as api from '../../types/types';
import type * as channels from './channels';
@@ -25,18 +26,18 @@ export class Coverage implements api.Coverage {
}
async startJSCoverage(options: channels.PageStartJSCoverageOptions = {}) {
- await this._channel.startJSCoverage(options, undefined);
+ await this._channel.startJSCoverage(options, kNoTimeout);
}
async stopJSCoverage(): Promise<channels.PageStopJSCoverageResult['entries']> {
- return (await this._channel.stopJSCoverage({}, undefined)).entries;
+ return (await this._channel.stopJSCoverage({}, kNoTimeout)).entries;
}
async startCSSCoverage(options: channels.PageStartCSSCoverageOptions = {}) {
- await this._channel.startCSSCoverage(options, undefined);
+ await this._channel.startCSSCoverage(options, kNoTimeout);
}
async stopCSSCoverage(): Promise<channels.PageStopCSSCoverageResult['entries']> {
- return (await this._channel.stopCSSCoverage({}, undefined)).entries;
+ return (await this._channel.stopCSSCoverage({}, kNoTimeout)).entries;
}
}
diff --git a/packages/playwright-core/src/client/credentials.ts b/packages/playwright-core/src/client/credentials.ts
index e46c36bdba..f80c0fab7e 100644
--- a/packages/playwright-core/src/client/credentials.ts
+++ b/packages/playwright-core/src/client/credentials.ts
@@ -14,6 +14,7 @@
* limitations under the License.
*/
+import { kNoTimeout } from './timeoutSettings';
import type { BrowserContext } from './browserContext';
import type * as api from '../../types/types';
import type * as channels from './channels';
@@ -26,20 +27,20 @@ export class Credentials implements api.Credentials {
}
async install(): Promise<void> {
- await this._browserContext._channel.credentialsInstall({}, undefined);
+ await this._browserContext._channel.credentialsInstall({}, kNoTimeout);
}
async create(rpId: string, options: Omit<channels.BrowserContextCredentialsCreateParams, 'rpId'> = {}): Promise<channels.VirtualCredential> {
- const { credential } = await this._browserContext._channel.credentialsCreate({ ...options, rpId }, undefined);
+ const { credential } = await this._browserContext._channel.credentialsCreate({ ...options, rpId }, kNoTimeout);
return credential;
}
async get(options: channels.BrowserContextCredentialsGetParams = {}): Promise<channels.VirtualCredential[]> {
- const { credentials } = await this._browserContext._channel.credentialsGet(options, undefined);
+ const { credentials } = await this._browserContext._channel.credentialsGet(options, kNoTimeout);
return credentials;
}
async delete(id: string): Promise<void> {
- await this._browserContext._channel.credentialsDelete({ id }, undefined);
+ await this._browserContext._channel.credentialsDelete({ id }, kNoTimeout);
}
}
diff --git a/packages/playwright-core/src/client/debugger.ts b/packages/playwright-core/src/client/debugger.ts
index c61d7e6cbc..7c68e1ee91 100644
--- a/packages/playwright-core/src/client/debugger.ts
+++ b/packages/playwright-core/src/client/debugger.ts
@@ -16,6 +16,7 @@
import { ChannelOwner } from './channelOwner';
import { Events } from './events';
+import { kNoTimeout } from './timeoutSettings';
import type * as api from '../../types/types';
import type * as channels from './channels';
@@ -38,19 +39,19 @@ export class Debugger extends ChannelOwner<channels.DebuggerChannel> implements
}
async requestPause(): Promise<void> {
- await this._channel.requestPause({}, undefined);
+ await this._channel.requestPause({}, kNoTimeout);
}
async resume(): Promise<void> {
- await this._channel.resume({}, undefined);
+ await this._channel.resume({}, kNoTimeout);
}
async next(): Promise<void> {
- await this._channel.next({}, undefined);
+ await this._channel.next({}, kNoTimeout);
}
async runTo(location: { file: string, line?: number, column?: number }): Promise<void> {
- await this._channel.runTo({ location }, undefined);
+ await this._channel.runTo({ location }, kNoTimeout);
}
pausedDetails(): PausedDetails | null {
diff --git a/packages/playwright-core/src/client/dialog.ts b/packages/playwright-core/src/client/dialog.ts
index d169a46b6a..bd21d73b7b 100644
--- a/packages/playwright-core/src/client/dialog.ts
+++ b/packages/playwright-core/src/client/dialog.ts
@@ -17,6 +17,7 @@
import { ChannelOwner } from './channelOwner';
import { Page } from './page';
import { isTargetClosedError } from './errors';
+import { kNoTimeout } from './timeoutSettings';
import type * as api from '../../types/types';
import type * as channels from './channels';
@@ -53,12 +54,12 @@ export class Dialog extends ChannelOwner<channels.DialogChannel> implements api.
}
async accept(promptText: string | undefined) {
- await this._channel.accept({ promptText }, undefined);
+ await this._channel.accept({ promptText }, kNoTimeout);
}
async dismiss() {
try {
- await this._channel.dismiss({}, undefined);
+ await this._channel.dismiss({}, kNoTimeout);
} catch (e) {
if (isTargetClosedError(e))
return;
diff --git a/packages/playwright-core/src/client/disposable.ts b/packages/playwright-core/src/client/disposable.ts
index 061de9bc57..57817529db 100644
--- a/packages/playwright-core/src/client/disposable.ts
+++ b/packages/playwright-core/src/client/disposable.ts
@@ -16,6 +16,7 @@
import { ChannelOwner } from './channelOwner';
import { isTargetClosedError } from './errors';
+import { kNoTimeout } from './timeoutSettings';
import type * as channels from './channels';
@@ -34,7 +35,7 @@ export class DisposableObject<T extends channels.DisposableChannel = channels.Di
async dispose() {
try {
- await this._channel.dispose({}, undefined);
+ await this._channel.dispose({}, kNoTimeout);
} catch (e) {
if (isTargetClosedError(e))
return;
diff --git a/packages/playwright-core/src/client/electron.ts b/packages/playwright-core/src/client/electron.ts
index 81ec6c1cdc..c773ac36f6 100644
--- a/packages/playwright-core/src/client/electron.ts
+++ b/packages/playwright-core/src/client/electron.ts
@@ -22,7 +22,7 @@ import { TargetClosedError, isTargetClosedError } from './errors';
import { Events } from './events';
import { JSHandle, parseResult, serializeArgument } from './jsHandle';
import { Waiter } from './waiter';
-import { TimeoutSettings } from './timeoutSettings';
+import { TimeoutSettings, kNoTimeout } from './timeoutSettings';
import type { Page } from './page';
import type { BrowserContextOptions, Headers, TimeoutOptions, WaitForEventOptions } from './types';
@@ -62,9 +62,8 @@ export class Electron extends ChannelOwner<channels.ElectronChannel> implements
env: options.env ? envObjectToArray(options.env) : undefined,
tracesDir: options.tracesDir,
artifactsDir: options.artifactsDir,
- timeout: new TimeoutSettings().launchTimeout(options),
};
- const app = ElectronApplication.from((await this._channel.launch(params, undefined)).electronApplication);
+ const app = ElectronApplication.from((await this._channel.launch(params, new TimeoutSettings().launchTimeout(options))).electronApplication);
this._playwright.selectors._contextsForSelectors.add(app._context);
app.once(Events.ElectronApplication.Close, () => this._playwright.selectors._contextsForSelectors.delete(app._context));
await app._context._initializeHarFromOptions(options.recordHar);
@@ -140,9 +139,8 @@ export class ElectronApplication extends ChannelOwner<channels.ElectronApplicati
async waitForEvent(event: string, optionsOrPredicate: WaitForEventOptions = {}): Promise<any> {
return await this._wrapApiCall(async () => {
- const timeout = this._timeoutSettings.timeout(typeof optionsOrPredicate === 'function' ? {} : optionsOrPredicate);
+ const { timeout, signal } = this._timeoutSettings.timeout(typeof optionsOrPredicate === 'function' ? {} : optionsOrPredicate);
const predicate = typeof optionsOrPredicate === 'function' ? optionsOrPredicate : optionsOrPredicate.predicate;
- const signal = typeof optionsOrPredicate === 'function' ? undefined : (optionsOrPredicate as TimeoutOptions).signal;
const waiter = Waiter.createForEvent(this, event);
waiter.rejectOnTimeout(timeout, `Timeout ${timeout}ms exceeded while waiting for event "${event}"`);
waiter.rejectOnSignal(signal);
@@ -155,17 +153,17 @@ export class ElectronApplication extends ChannelOwner<channels.ElectronApplicati
}
async browserWindow(page: Page): Promise<JSHandle<BrowserWindow>> {
- const result = await this._channel.browserWindow({ page: page._channel }, undefined);
+ const result = await this._channel.browserWindow({ page: page._channel }, kNoTimeout);
return JSHandle.from(result.handle);
}
async evaluate<R, Arg>(pageFunction: structs.PageFunctionOn<ElectronAppType, Arg, R>, arg: Arg): Promise<R> {
- const result = await this._channel.evaluateExpression({ expression: String(pageFunction), isFunction: typeof pageFunction === 'function', arg: serializeArgument(arg) }, undefined);
+ const result = await this._channel.evaluateExpression({ expression: String(pageFunction), isFunction: typeof pageFunction === 'function', arg: serializeArgument(arg) }, kNoTimeout);
return parseResult(result.value);
}
async evaluateHandle<R, Arg>(pageFunction: structs.PageFunctionOn<ElectronAppType, Arg, R>, arg: Arg): Promise<structs.SmartHandle<R>> {
- const result = await this._channel.evaluateExpressionHandle({ expression: String(pageFunction), isFunction: typeof pageFunction === 'function', arg: serializeArgument(arg) }, undefined);
+ const result = await this._channel.evaluateExpressionHandle({ expression: String(pageFunction), isFunction: typeof pageFunction === 'function', arg: serializeArgument(arg) }, kNoTimeout);
return JSHandle.from(result.handle) as any as structs.SmartHandle<R>;
}
}
diff --git a/packages/playwright-core/src/client/elementHandle.ts b/packages/playwright-core/src/client/elementHandle.ts
index 8f0a63c7a5..4cee41bcf5 100644
--- a/packages/playwright-core/src/client/elementHandle.ts
+++ b/packages/playwright-core/src/client/elementHandle.ts
@@ -25,6 +25,7 @@ import { Frame } from './frame';
import { JSHandle, parseResult, serializeArgument } from './jsHandle';
import { fileUploadSizeLimit, mkdirIfNeeded } from './fileUtils';
import { WritableStream } from './writableStream';
+import { kNoTimeout } from './timeoutSettings';
import type { BrowserContext } from './browserContext';
import type { ChannelOwner } from './channelOwner';
@@ -57,94 +58,94 @@ export class ElementHandle<T extends Node = Node> extends JSHandle<T> implements
}
async ownerFrame(): Promise<Frame | null> {
- return Frame.fromNullable((await this._elementChannel.ownerFrame({}, undefined)).frame);
+ return Frame.fromNullable((await this._elementChannel.ownerFrame({}, kNoTimeout)).frame);
}
async contentFrame(): Promise<Frame | null> {
- return Frame.fromNullable((await this._elementChannel.contentFrame({}, undefined)).frame);
+ return Frame.fromNullable((await this._elementChannel.contentFrame({}, kNoTimeout)).frame);
}
async getAttribute(name: string): Promise<string | null> {
- const value = (await this._elementChannel.getAttribute({ name }, undefined)).value;
+ const value = (await this._elementChannel.getAttribute({ name }, kNoTimeout)).value;
return value === undefined ? null : value;
}
async inputValue(): Promise<string> {
- return (await this._elementChannel.inputValue({}, undefined)).value;
+ return (await this._elementChannel.inputValue({}, kNoTimeout)).value;
}
async textContent(): Promise<string | null> {
- const value = (await this._elementChannel.textContent({}, undefined)).value;
+ const value = (await this._elementChannel.textContent({}, kNoTimeout)).value;
return value === undefined ? null : value;
}
async innerText(): Promise<string> {
- return (await this._elementChannel.innerText({}, undefined)).value;
+ return (await this._elementChannel.innerText({}, kNoTimeout)).value;
}
async innerHTML(): Promise<string> {
- return (await this._elementChannel.innerHTML({}, undefined)).value;
+ return (await this._elementChannel.innerHTML({}, kNoTimeout)).value;
}
async isChecked(): Promise<boolean> {
- return (await this._elementChannel.isChecked({}, undefined)).value;
+ return (await this._elementChannel.isChecked({}, kNoTimeout)).value;
}
async isDisabled(): Promise<boolean> {
- return (await this._elementChannel.isDisabled({}, undefined)).value;
+ return (await this._elementChannel.isDisabled({}, kNoTimeout)).value;
}
async isEditable(): Promise<boolean> {
- return (await this._elementChannel.isEditable({}, undefined)).value;
+ return (await this._elementChannel.isEditable({}, kNoTimeout)).value;
}
async isEnabled(): Promise<boolean> {
- return (await this._elementChannel.isEnabled({}, undefined)).value;
+ return (await this._elementChannel.isEnabled({}, kNoTimeout)).value;
}
async isHidden(): Promise<boolean> {
- return (await this._elementChannel.isHidden({}, undefined)).value;
+ return (await this._elementChannel.isHidden({}, kNoTimeout)).value;
}
async isVisible(): Promise<boolean> {
- return (await this._elementChannel.isVisible({}, undefined)).value;
+ return (await this._elementChannel.isVisible({}, kNoTimeout)).value;
}
async dispatchEvent(type: string, eventInit: Object = {}) {
- await this._elementChannel.dispatchEvent({ type, eventInit: serializeArgument(eventInit) }, undefined);
+ await this._elementChannel.dispatchEvent({ type, eventInit: serializeArgument(eventInit) }, kNoTimeout);
}
async scrollIntoViewIfNeeded(options: channels.ElementHandleScrollIntoViewIfNeededOptions & TimeoutOptions = {}) {
- await this._elementChannel.scrollIntoViewIfNeeded({ ...options, timeout: this._frame._timeout(options) }, options.signal);
+ await this._elementChannel.scrollIntoViewIfNeeded({ ...options }, this._frame._timeout(options));
}
async hover(options: channels.ElementHandleHoverOptions & TimeoutOptions = {}): Promise<void> {
- await this._elementChannel.hover({ ...options, timeout: this._frame._timeout(options) }, options.signal);
+ await this._elementChannel.hover({ ...options }, this._frame._timeout(options));
}
async click(options: channels.ElementHandleClickOptions & TimeoutOptions = {}): Promise<void> {
- return await this._elementChannel.click({ ...options, timeout: this._frame._timeout(options) }, options.signal);
+ return await this._elementChannel.click({ ...options }, this._frame._timeout(options));
}
async dblclick(options: channels.ElementHandleDblclickOptions & TimeoutOptions = {}): Promise<void> {
- return await this._elementChannel.dblclick({ ...options, timeout: this._frame._timeout(options) }, options.signal);
+ return await this._elementChannel.dblclick({ ...options }, this._frame._timeout(options));
}
async tap(options: channels.ElementHandleTapOptions & TimeoutOptions = {}): Promise<void> {
- return await this._elementChannel.tap({ ...options, timeout: this._frame._timeout(options) }, options.signal);
+ return await this._elementChannel.tap({ ...options }, this._frame._timeout(options));
}
async selectOption(values: string | api.ElementHandle | SelectOption | string[] | api.ElementHandle[] | SelectOption[] | null, options: SelectOptionOptions = {}): Promise<string[]> {
- const result = await this._elementChannel.selectOption({ ...convertSelectOptionValues(values), ...options, timeout: this._frame._timeout(options) }, options.signal);
+ const result = await this._elementChannel.selectOption({ ...convertSelectOptionValues(values), ...options }, this._frame._timeout(options));
return result.values;
}
async fill(value: string, options: channels.ElementHandleFillOptions & TimeoutOptions = {}): Promise<void> {
- return await this._elementChannel.fill({ value, ...options, timeout: this._frame._timeout(options) }, options.signal);
+ return await this._elementChannel.fill({ value, ...options }, this._frame._timeout(options));
}
async selectText(options: channels.ElementHandleSelectTextOptions & TimeoutOptions = {}): Promise<void> {
- await this._elementChannel.selectText({ ...options, timeout: this._frame._timeout(options) }, options.signal);
+ await this._elementChannel.selectText({ ...options }, this._frame._timeout(options));
}
async setInputFiles(files: string | FilePayload | string[] | FilePayload[], options: channels.ElementHandleSetInputFilesOptions & TimeoutOptions = {}) {
@@ -152,27 +153,27 @@ export class ElementHandle<T extends Node = Node> extends JSHandle<T> implements
if (!frame)
throw new Error('Cannot set input files to detached element');
const converted = await convertInputFiles(files, frame.page().context());
- await this._elementChannel.setInputFiles({ ...converted, ...options, timeout: this._frame._timeout(options) }, options.signal);
+ await this._elementChannel.setInputFiles({ ...converted, ...options }, this._frame._timeout(options));
}
async focus(): Promise<void> {
- await this._elementChannel.focus({}, undefined);
+ await this._elementChannel.focus({}, kNoTimeout);
}
async type(text: string, options: channels.ElementHandleTypeOptions & TimeoutOptions = {}): Promise<void> {
- await this._elementChannel.type({ text, ...options, timeout: this._frame._timeout(options) }, options.signal);
+ await this._elementChannel.type({ text, ...options }, this._frame._timeout(options));
}
async press(key: string, options: channels.ElementHandlePressOptions & TimeoutOptions = {}): Promise<void> {
- await this._elementChannel.press({ key, ...options, timeout: this._frame._timeout(options) }, options.signal);
+ await this._elementChannel.press({ key, ...options }, this._frame._timeout(options));
}
async check(options: channels.ElementHandleCheckOptions & TimeoutOptions = {}) {
- return await this._elementChannel.check({ ...options, timeout: this._frame._timeout(options) }, options.signal);
+ return await this._elementChannel.check({ ...options }, this._frame._timeout(options));
}
async uncheck(options: channels.ElementHandleUncheckOptions & TimeoutOptions = {}) {
- return await this._elementChannel.uncheck({ ...options, timeout: this._frame._timeout(options) }, options.signal);
+ return await this._elementChannel.uncheck({ ...options }, this._frame._timeout(options));
}
async setChecked(checked: boolean, options?: channels.ElementHandleCheckOptions) {
@@ -183,13 +184,13 @@ export class ElementHandle<T extends Node = Node> extends JSHandle<T> implements
}
async boundingBox(): Promise<Rect | null> {
- const value = (await this._elementChannel.boundingBox({}, undefined)).value;
+ const value = (await this._elementChannel.boundingBox({}, kNoTimeout)).value;
return value === undefined ? null : value;
}
async screenshot(options: Omit<channels.ElementHandleScreenshotOptions, 'mask'> & TimeoutOptions & { path?: string, mask?: api.Locator[] } = {}): Promise<Buffer> {
const mask = options.mask as Locator[] | undefined;
- const copy: channels.ElementHandleScreenshotParams = { ...options, mask: undefined, timeout: this._frame._timeout(options) };
+ const copy: channels.ElementHandleScreenshotParams = { ...options, mask: undefined };
if (!copy.type)
copy.type = determineScreenshotType(options);
if (mask) {
@@ -198,7 +199,7 @@ export class ElementHandle<T extends Node = Node> extends JSHandle<T> implements
selector: locator._selector,
}));
}
- const result = await this._elementChannel.screenshot(copy, options.signal);
+ const result = await this._elementChannel.screenshot(copy, this._frame._timeout(options));
if (options.path) {
await mkdirIfNeeded(options.path);
await fs.promises.writeFile(options.path, result.binary);
@@ -207,32 +208,32 @@ export class ElementHandle<T extends Node = Node> extends JSHandle<T> implements
}
async $(selector: string): Promise<ElementHandle<SVGElement | HTMLElement> | null> {
- return ElementHandle.fromNullable((await this._elementChannel.querySelector({ selector }, undefined)).element) as ElementHandle<SVGElement | HTMLElement> | null;
+ return ElementHandle.fromNullable((await this._elementChannel.querySelector({ selector }, kNoTimeout)).element) as ElementHandle<SVGElement | HTMLElement> | null;
}
async $$(selector: string): Promise<ElementHandle<SVGElement | HTMLElement>[]> {
- const result = await this._elementChannel.querySelectorAll({ selector }, undefined);
+ const result = await this._elementChannel.querySelectorAll({ selector }, kNoTimeout);
return result.elements.map(h => ElementHandle.from(h) as ElementHandle<SVGElement | HTMLElement>);
}
async $eval<R, Arg>(selector: string, pageFunction: structs.PageFunctionOn<Element, Arg, R>, arg?: Arg): Promise<R> {
- const result = await this._elementChannel.evalOnSelector({ selector, expression: String(pageFunction), isFunction: typeof pageFunction === 'function', arg: serializeArgument(arg) }, undefined);
+ const result = await this._elementChannel.evalOnSelector({ selector, expression: String(pageFunction), isFunction: typeof pageFunction === 'function', arg: serializeArgument(arg) }, kNoTimeout);
return parseResult(result.value);
}
async $$eval<R, Arg>(selector: string, pageFunction: structs.PageFunctionOn<Element[], Arg, R>, arg?: Arg): Promise<R> {
- const result = await this._elementChannel.evalOnSelectorAll({ selector, expression: String(pageFunction), isFunction: typeof pageFunction === 'function', arg: serializeArgument(arg) }, undefined);
+ const result = await this._elementChannel.evalOnSelectorAll({ selector, expression: String(pageFunction), isFunction: typeof pageFunction === 'function', arg: serializeArgument(arg) }, kNoTimeout);
return parseResult(result.value);
}
async waitForElementState(state: 'visible' | 'hidden' | 'stable' | 'enabled' | 'disabled', options: TimeoutOptions = {}): Promise<void> {
- return await this._elementChannel.waitForElementState({ state, ...options, timeout: this._frame._timeout(options) }, options.signal);
+ return await this._elementChannel.waitForElementState({ state, ...options }, this._frame._timeout(options));
}
waitForSelector(selector: string, options: channels.ElementHandleWaitForSelectorOptions & TimeoutOptions & { state: 'attached' | 'visible' }): Promise<ElementHandle<SVGElement | HTMLElement>>;
waitForSelector(selector: string, options?: channels.ElementHandleWaitForSelectorOptions & TimeoutOptions): Promise<ElementHandle<SVGElement | HTMLElement> | null>;
async waitForSelector(selector: string, options: channels.ElementHandleWaitForSelectorOptions & TimeoutOptions = {}): Promise<ElementHandle<SVGElement | HTMLElement> | null> {
- const result = await this._elementChannel.waitForSelector({ selector, ...options, timeout: this._frame._timeout(options) }, options.signal);
+ const result = await this._elementChannel.waitForSelector({ selector, ...options }, this._frame._timeout(options));
return ElementHandle.fromNullable(result.element) as ElementHandle<SVGElement | HTMLElement> | null;
}
}
@@ -298,7 +299,7 @@ export async function convertInputFiles(files: string | FilePayload | string[] |
lastModifiedMs
};
})),
- }, undefined), { internal: true });
+ }, kNoTimeout), { internal: true });
for (let i = 0; i < files.length; i++) {
const writable = WritableStream.from(writableStreams[i]);
await stream.promises.pipeline(fs.createReadStream(files[i]), writable.stream());
diff --git a/packages/playwright-core/src/client/fetch.ts b/packages/playwright-core/src/client/fetch.ts
index 59a729ae63..7764b6c338 100644
--- a/packages/playwright-core/src/client/fetch.ts
+++ b/packages/playwright-core/src/client/fetch.ts
@@ -27,7 +27,7 @@ import { TargetClosedError, isTargetClosedError } from './errors';
import { RawHeaders } from './network';
import { Tracing } from './tracing';
import { mkdirIfNeeded } from './fileUtils';
-import { TimeoutSettings } from './timeoutSettings';
+import { TimeoutSettings, kNoTimeout } from './timeoutSettings';
import type { Playwright } from './playwright';
import type { ClientCertificate, FilePayload, Headers, RemoteAddr, SecurityDetails, SetStorageState, StorageState, TimeoutOptions } from './types';
@@ -79,7 +79,7 @@ export class APIRequest implements api.APIRequest {
storageState,
tracesDir: this._playwright._defaultLaunchOptions?.tracesDir, // We do not expose tracesDir in the API, so do not allow options to accidentally override it.
clientCertificates: await toClientCertificatesProtocol(options.clientCertificates),
- }, options.signal)).request);
+ }, kNoTimeout)).request);
this._contexts.add(context);
context._request = this;
context._timeoutSettings.setDefaultTimeout(options.timeout ?? this._playwright._defaultContextTimeout);
@@ -114,7 +114,7 @@ export class APIRequestContext extends ChannelOwner<channels.APIRequestContextCh
await this._instrumentation.runBeforeCloseRequestContext(this);
await this.tracing._exportAllHars();
try {
- await this._channel.dispose(options, undefined);
+ await this._channel.dispose(options, kNoTimeout);
} catch (e) {
if (isTargetClosedError(e))
return;
@@ -255,19 +255,18 @@ export class APIRequestContext extends ChannelOwner<channels.APIRequestContextCh
jsonData,
formData,
multipartData,
- timeout: this._timeoutSettings.timeout(options),
failOnStatusCode: options.failOnStatusCode,
ignoreHTTPSErrors: options.ignoreHTTPSErrors,
maxRedirects: options.maxRedirects,
maxRetries: options.maxRetries,
...fixtures
- }, options.signal);
+ }, this._timeoutSettings.timeout(options));
return new APIResponse(this, result.response);
});
}
async storageState(options: { path?: string, indexedDB?: boolean } = {}): Promise<StorageState> {
- const state = await this._channel.storageState({ indexedDB: options.indexedDB }, undefined);
+ const state = await this._channel.storageState({ indexedDB: options.indexedDB }, kNoTimeout);
if (options.path) {
await mkdirIfNeeded(options.path);
await fs.promises.writeFile(options.path, JSON.stringify(state, undefined, 2), 'utf8');
@@ -354,7 +353,7 @@ export class APIResponse implements api.APIResponse {
async body(): Promise<Buffer> {
return await this._request._wrapApiCall(async () => {
try {
- const result = await this._request._channel.fetchResponseBody({ fetchUid: this._fetchUid() }, undefined);
+ const result = await this._request._channel.fetchResponseBody({ fetchUid: this._fetchUid() }, kNoTimeout);
if (result.binary === undefined)
throw new Error('Response has been disposed');
return result.binary;
@@ -381,7 +380,7 @@ export class APIResponse implements api.APIResponse {
}
async dispose(): Promise<void> {
- await this._request._channel.disposeAPIResponse({ fetchUid: this._fetchUid() }, undefined);
+ await this._request._channel.disposeAPIResponse({ fetchUid: this._fetchUid() }, kNoTimeout);
}
private _inspect() {
@@ -394,7 +393,7 @@ export class APIResponse implements api.APIResponse {
}
async _fetchLog(): Promise<string[]> {
- const { log } = await this._request._channel.fetchLog({ fetchUid: this._fetchUid() }, undefined);
+ const { log } = await this._request._channel.fetchLog({ fetchUid: this._fetchUid() }, kNoTimeout);
return log;
}
}
diff --git a/packages/playwright-core/src/client/frame.ts b/packages/playwright-core/src/client/frame.ts
index 31ecc7f73c..6c9de8ecdc 100644
--- a/packages/playwright-core/src/client/frame.ts
+++ b/packages/playwright-core/src/client/frame.ts
@@ -32,7 +32,7 @@ import { FrameLocator, Locator, testIdAttributeName } from './locator';
import * as network from './network';
import { kLifecycleEvents } from './types';
import { Waiter } from './waiter';
-import { TimeoutSettings } from './timeoutSettings';
+import { TimeoutSettings, kNoTimeout } from './timeoutSettings';
import type { LocatorOptions } from './locator';
import type { Page } from './page';
@@ -107,19 +107,19 @@ export class Frame extends ChannelOwner<channels.FrameChannel> implements api.Fr
return this._page!;
}
- _timeout(options?: TimeoutOptions): number {
+ _timeout(options?: TimeoutOptions): channels.TimeoutOptions {
const timeoutSettings = this._page?._timeoutSettings || new TimeoutSettings();
return timeoutSettings.timeout(options || {});
}
- _navigationTimeout(options?: TimeoutOptions): number {
+ _navigationTimeout(options?: TimeoutOptions): channels.TimeoutOptions {
const timeoutSettings = this._page?._timeoutSettings || new TimeoutSettings();
return timeoutSettings.navigationTimeout(options || {});
}
async goto(url: string, options: channels.FrameGotoOptions & TimeoutOptions = {}): Promise<network.Response | null> {
const waitUntil = verifyLoadState('waitUntil', options.waitUntil === undefined ? 'load' : options.waitUntil);
- return network.Response.fromNullable((await this._channel.goto({ url, ...options, waitUntil, timeout: this._navigationTimeout(options) }, options.signal)).response);
+ return network.Response.fromNullable((await this._channel.goto({ url, ...options, waitUntil }, this._navigationTimeout(options))).response);
}
private _setupNavigationWaiter(options: TimeoutOptions): Waiter {
@@ -129,7 +129,7 @@ export class Frame extends ChannelOwner<channels.FrameChannel> implements api.Fr
waiter.rejectOnEvent(this._page!, Events.Page.Close, () => this._page!._closeErrorWithReason());
waiter.rejectOnEvent(this._page!, Events.Page.Crash, new Error('Navigation failed because page crashed!'));
waiter.rejectOnEvent<Frame>(this._page!, Events.Page.FrameDetached, new Error('Navigating frame was detached!'), frame => frame === this);
- const timeout = this._page!._timeoutSettings.navigationTimeout(options);
+ const { timeout } = this._page!._timeoutSettings.navigationTimeout(options);
waiter.rejectOnTimeout(timeout, `Timeout ${timeout}ms exceeded.`);
waiter.rejectOnSignal(options.signal);
return waiter;
@@ -199,29 +199,29 @@ export class Frame extends ChannelOwner<channels.FrameChannel> implements api.Fr
}
async frameElement(): Promise<ElementHandle> {
- return ElementHandle.from((await this._channel.frameElement({}, undefined)).element);
+ return ElementHandle.from((await this._channel.frameElement({}, kNoTimeout)).element);
}
async evaluateHandle<R, Arg>(pageFunction: structs.PageFunction<Arg, R>, arg?: Arg): Promise<structs.SmartHandle<R>> {
assertMaxArguments(arguments.length, 2);
- const result = await this._channel.evaluateExpressionHandle({ expression: String(pageFunction), isFunction: typeof pageFunction === 'function', arg: serializeArgument(arg) }, undefined);
+ const result = await this._channel.evaluateExpressionHandle({ expression: String(pageFunction), isFunction: typeof pageFunction === 'function', arg: serializeArgument(arg) }, kNoTimeout);
return JSHandle.from(result.handle) as any as structs.SmartHandle<R>;
}
async evaluate<R, Arg>(pageFunction: structs.PageFunction<Arg, R>, arg?: Arg): Promise<R> {
assertMaxArguments(arguments.length, 2);
- const result = await this._channel.evaluateExpression({ expression: String(pageFunction), isFunction: typeof pageFunction === 'function', arg: serializeArgument(arg) }, undefined);
+ const result = await this._channel.evaluateExpression({ expression: String(pageFunction), isFunction: typeof pageFunction === 'function', arg: serializeArgument(arg) }, kNoTimeout);
return parseResult(result.value);
}
async _evaluateExposeUtilityScript<R, Arg>(pageFunction: structs.PageFunction<Arg, R>, arg?: Arg): Promise<R> {
assertMaxArguments(arguments.length, 2);
- const result = await this._channel.evaluateExpression({ expression: String(pageFunction), isFunction: typeof pageFunction === 'function', arg: serializeArgument(arg) }, undefined);
+ const result = await this._channel.evaluateExpression({ expression: String(pageFunction), isFunction: typeof pageFunction === 'function', arg: serializeArgument(arg) }, kNoTimeout);
return parseResult(result.value);
}
async $(selector: string, options?: { strict?: boolean }): Promise<ElementHandle<SVGElement | HTMLElement> | null> {
- const result = await this._channel.querySelector({ selector, ...options }, undefined);
+ const result = await this._channel.querySelector({ selector, ...options }, kNoTimeout);
return ElementHandle.fromNullable(result.element) as ElementHandle<SVGElement | HTMLElement> | null;
}
@@ -232,42 +232,42 @@ export class Frame extends ChannelOwner<channels.FrameChannel> implements api.Fr
throw new Error('options.visibility is not supported, did you mean options.state?');
if ((options as any).waitFor && (options as any).waitFor !== 'visible')
throw new Error('options.waitFor is not supported, did you mean options.state?');
- const result = await this._channel.waitForSelector({ selector, ...options, timeout: this._timeout(options) }, options.signal);
+ const result = await this._channel.waitForSelector({ selector, ...options }, this._timeout(options));
return ElementHandle.fromNullable(result.element) as ElementHandle<SVGElement | HTMLElement> | null;
}
async dispatchEvent(selector: string, type: string, eventInit?: any, options: channels.FrameDispatchEventOptions & TimeoutOptions = {}): Promise<void> {
- await this._channel.dispatchEvent({ selector, type, eventInit: serializeArgument(eventInit), ...options, timeout: this._timeout(options) }, options.signal);
+ await this._channel.dispatchEvent({ selector, type, eventInit: serializeArgument(eventInit), ...options }, this._timeout(options));
}
async $eval<R, Arg>(selector: string, pageFunction: structs.PageFunctionOn<Element, Arg, R>, arg?: Arg): Promise<R> {
assertMaxArguments(arguments.length, 3);
- const result = await this._channel.evalOnSelector({ selector, expression: String(pageFunction), isFunction: typeof pageFunction === 'function', arg: serializeArgument(arg) }, undefined);
+ const result = await this._channel.evalOnSelector({ selector, expression: String(pageFunction), isFunction: typeof pageFunction === 'function', arg: serializeArgument(arg) }, kNoTimeout);
return parseResult(result.value);
}
async $$eval<R, Arg>(selector: string, pageFunction: structs.PageFunctionOn<Element[], Arg, R>, arg?: Arg): Promise<R> {
assertMaxArguments(arguments.length, 3);
- const result = await this._channel.evalOnSelectorAll({ selector, expression: String(pageFunction), isFunction: typeof pageFunction === 'function', arg: serializeArgument(arg) }, undefined);
+ const result = await this._channel.evalOnSelectorAll({ selector, expression: String(pageFunction), isFunction: typeof pageFunction === 'function', arg: serializeArgument(arg) }, kNoTimeout);
return parseResult(result.value);
}
async $$(selector: string): Promise<ElementHandle<SVGElement | HTMLElement>[]> {
- const result = await this._channel.querySelectorAll({ selector }, undefined);
+ const result = await this._channel.querySelectorAll({ selector }, kNoTimeout);
return result.elements.map(e => ElementHandle.from(e) as ElementHandle<SVGElement | HTMLElement>);
}
async _queryCount(selector: string): Promise<number> {
- return (await this._channel.queryCount({ selector }, undefined)).value;
+ return (await this._channel.queryCount({ selector }, kNoTimeout)).value;
}
async content(): Promise<string> {
- return (await this._channel.content({}, undefined)).value;
+ return (await this._channel.content({}, kNoTimeout)).value;
}
async setContent(html: string, options: channels.FrameSetContentOptions & TimeoutOptions = {}): Promise<void> {
const waitUntil = verifyLoadState('waitUntil', options.waitUntil === undefined ? 'load' : options.waitUntil);
- await this._channel.setContent({ html, ...options, waitUntil, timeout: this._navigationTimeout(options) }, options.signal);
+ await this._channel.setContent({ html, ...options, waitUntil }, this._navigationTimeout(options));
}
name(): string {
@@ -296,7 +296,7 @@ export class Frame extends ChannelOwner<channels.FrameChannel> implements api.Fr
copy.content = (await fs.promises.readFile(copy.path)).toString();
copy.content = addSourceUrlToScript(copy.content, copy.path);
}
- return ElementHandle.from((await this._channel.addScriptTag({ ...copy }, undefined)).element);
+ return ElementHandle.from((await this._channel.addScriptTag({ ...copy }, kNoTimeout)).element);
}
async addStyleTag(options: { url?: string; path?: string; content?: string; } = {}): Promise<ElementHandle> {
@@ -305,19 +305,19 @@ export class Frame extends ChannelOwner<channels.FrameChannel> implements api.Fr
copy.content = (await fs.promises.readFile(copy.path)).toString();
copy.content += '/*# sourceURL=' + copy.path.replace(/\n/g, '') + '*/';
}
- return ElementHandle.from((await this._channel.addStyleTag({ ...copy }, undefined)).element);
+ return ElementHandle.from((await this._channel.addStyleTag({ ...copy }, kNoTimeout)).element);
}
async click(selector: string, options: channels.FrameClickOptions & TimeoutOptions = {}) {
- return await this._channel.click({ selector, ...options, timeout: this._timeout(options) }, options.signal);
+ return await this._channel.click({ selector, ...options }, this._timeout(options));
}
async dblclick(selector: string, options: channels.FrameDblclickOptions & TimeoutOptions = {}) {
- return await this._channel.dblclick({ selector, ...options, timeout: this._timeout(options) }, options.signal);
+ return await this._channel.dblclick({ selector, ...options }, this._timeout(options));
}
async dragAndDrop(source: string, target: string, options: channels.FrameDragAndDropOptions & TimeoutOptions = {}) {
- return await this._channel.dragAndDrop({ source, target, ...options, timeout: this._timeout(options) }, options.signal);
+ return await this._channel.dragAndDrop({ source, target, ...options }, this._timeout(options));
}
async _drop(selector: string, payload: DropPayload, options: Omit<channels.FrameDropOptions, 'payloads' | 'localPaths' | 'streams' | 'data'> & TimeoutOptions = {}) {
@@ -334,24 +334,23 @@ export class Frame extends ChannelOwner<channels.FrameChannel> implements api.Fr
...fileParams,
data: dataArray,
...options,
- timeout: this._timeout(options),
- }, options.signal);
+ }, this._timeout(options));
}
async tap(selector: string, options: channels.FrameTapOptions & TimeoutOptions = {}) {
- return await this._channel.tap({ selector, ...options, timeout: this._timeout(options) }, options.signal);
+ return await this._channel.tap({ selector, ...options }, this._timeout(options));
}
async fill(selector: string, value: string, options: channels.FrameFillOptions & TimeoutOptions = {}) {
- return await this._channel.fill({ selector, value, ...options, timeout: this._timeout(options) }, options.signal);
+ return await this._channel.fill({ selector, value, ...options }, this._timeout(options));
}
async _highlight(selector: string, style?: string) {
- return await this._channel.highlight({ selector, style }, undefined);
+ return await this._channel.highlight({ selector, style }, kNoTimeout);
}
async _hideHighlight(selector: string) {
- return await this._channel.hideHighlight({ selector }, undefined);
+ return await this._channel.hideHighlight({ selector }, kNoTimeout);
}
locator(selector: string, options?: LocatorOptions): Locator {
@@ -391,82 +390,82 @@ export class Frame extends ChannelOwner<channels.FrameChannel> implements api.Fr
}
async focus(selector: string, options: channels.FrameFocusOptions & TimeoutOptions = {}) {
- await this._channel.focus({ selector, ...options, timeout: this._timeout(options) }, options.signal);
+ await this._channel.focus({ selector, ...options }, this._timeout(options));
}
async textContent(selector: string, options: channels.FrameTextContentOptions & TimeoutOptions = {}): Promise<null|string> {
- const value = (await this._channel.textContent({ selector, ...options, timeout: this._timeout(options) }, options.signal)).value;
+ const value = (await this._channel.textContent({ selector, ...options }, this._timeout(options))).value;
return value === undefined ? null : value;
}
async innerText(selector: string, options: channels.FrameInnerTextOptions & TimeoutOptions = {}): Promise<string> {
- return (await this._channel.innerText({ selector, ...options, timeout: this._timeout(options) }, options.signal)).value;
+ return (await this._channel.innerText({ selector, ...options }, this._timeout(options))).value;
}
async innerHTML(selector: string, options: channels.FrameInnerHTMLOptions & TimeoutOptions = {}): Promise<string> {
- return (await this._channel.innerHTML({ selector, ...options, timeout: this._timeout(options) }, options.signal)).value;
+ return (await this._channel.innerHTML({ selector, ...options }, this._timeout(options))).value;
}
async getAttribute(selector: string, name: string, options: channels.FrameGetAttributeOptions & TimeoutOptions = {}): Promise<string | null> {
- const value = (await this._channel.getAttribute({ selector, name, ...options, timeout: this._timeout(options) }, options.signal)).value;
+ const value = (await this._channel.getAttribute({ selector, name, ...options }, this._timeout(options))).value;
return value === undefined ? null : value;
}
async inputValue(selector: string, options: channels.FrameInputValueOptions & TimeoutOptions = {}): Promise<string> {
- return (await this._channel.inputValue({ selector, ...options, timeout: this._timeout(options) }, options.signal)).value;
+ return (await this._channel.inputValue({ selector, ...options }, this._timeout(options))).value;
}
async isChecked(selector: string, options: channels.FrameIsCheckedOptions & TimeoutOptions = {}): Promise<boolean> {
- return (await this._channel.isChecked({ selector, ...options, timeout: this._timeout(options) }, options.signal)).value;
+ return (await this._channel.isChecked({ selector, ...options }, this._timeout(options))).value;
}
async isDisabled(selector: string, options: channels.FrameIsDisabledOptions & TimeoutOptions = {}): Promise<boolean> {
- return (await this._channel.isDisabled({ selector, ...options, timeout: this._timeout(options) }, options.signal)).value;
+ return (await this._channel.isDisabled({ selector, ...options }, this._timeout(options))).value;
}
async isEditable(selector: string, options: channels.FrameIsEditableOptions & TimeoutOptions = {}): Promise<boolean> {
- return (await this._channel.isEditable({ selector, ...options, timeout: this._timeout(options) }, options.signal)).value;
+ return (await this._channel.isEditable({ selector, ...options }, this._timeout(options))).value;
}
async isEnabled(selector: string, options: channels.FrameIsEnabledOptions & TimeoutOptions = {}): Promise<boolean> {
- return (await this._channel.isEnabled({ selector, ...options, timeout: this._timeout(options) }, options.signal)).value;
+ return (await this._channel.isEnabled({ selector, ...options }, this._timeout(options))).value;
}
async isHidden(selector: string, options: channels.FrameIsHiddenOptions & TimeoutOptions = {}): Promise<boolean> {
- return (await this._channel.isHidden({ selector, ...options }, options.signal)).value;
+ return (await this._channel.isHidden({ selector, ...options }, kNoTimeout)).value;
}
async isVisible(selector: string, options: channels.FrameIsVisibleOptions & TimeoutOptions = {}): Promise<boolean> {
- return (await this._channel.isVisible({ selector, ...options }, options.signal)).value;
+ return (await this._channel.isVisible({ selector, ...options }, kNoTimeout)).value;
}
async hover(selector: string, options: channels.FrameHoverOptions & TimeoutOptions = {}) {
- await this._channel.hover({ selector, ...options, timeout: this._timeout(options) }, options.signal);
+ await this._channel.hover({ selector, ...options }, this._timeout(options));
}
async selectOption(selector: string, values: string | api.ElementHandle | SelectOption | string[] | api.ElementHandle[] | SelectOption[] | null, options: SelectOptionOptions & StrictOptions = {}): Promise<string[]> {
- return (await this._channel.selectOption({ selector, ...convertSelectOptionValues(values), ...options, timeout: this._timeout(options) }, options.signal)).values;
+ return (await this._channel.selectOption({ selector, ...convertSelectOptionValues(values), ...options }, this._timeout(options))).values;
}
async setInputFiles(selector: string, files: string | FilePayload | string[] | FilePayload[], options: channels.FrameSetInputFilesOptions & TimeoutOptions = {}): Promise<void> {
const converted = await convertInputFiles(files, this.page().context());
- await this._channel.setInputFiles({ selector, ...converted, ...options, timeout: this._timeout(options) }, options.signal);
+ await this._channel.setInputFiles({ selector, ...converted, ...options }, this._timeout(options));
}
async type(selector: string, text: string, options: channels.FrameTypeOptions & TimeoutOptions = {}) {
- await this._channel.type({ selector, text, ...options, timeout: this._timeout(options) }, options.signal);
+ await this._channel.type({ selector, text, ...options }, this._timeout(options));
}
async press(selector: string, key: string, options: channels.FramePressOptions & TimeoutOptions = {}) {
- await this._channel.press({ selector, key, ...options, timeout: this._timeout(options) }, options.signal);
+ await this._channel.press({ selector, key, ...options }, this._timeout(options));
}
async check(selector: string, options: channels.FrameCheckOptions & TimeoutOptions = {}) {
- await this._channel.check({ selector, ...options, timeout: this._timeout(options) }, options.signal);
+ await this._channel.check({ selector, ...options }, this._timeout(options));
}
async uncheck(selector: string, options: channels.FrameUncheckOptions & TimeoutOptions = {}) {
- await this._channel.uncheck({ selector, ...options, timeout: this._timeout(options) }, options.signal);
+ await this._channel.uncheck({ selector, ...options }, this._timeout(options));
}
async setChecked(selector: string, checked: boolean, options?: channels.FrameCheckOptions) {
@@ -477,7 +476,7 @@ export class Frame extends ChannelOwner<channels.FrameChannel> implements api.Fr
}
async waitForTimeout(timeout: number) {
- await this._channel.waitForTimeout({ waitTimeout: timeout }, undefined);
+ await this._channel.waitForTimeout({ waitTimeout: timeout }, kNoTimeout);
}
async waitForFunction<R, Arg>(pageFunction: structs.PageFunction<Arg, R>, arg?: Arg, options: WaitForFunctionOptions = {}): Promise<structs.SmartHandle<R>> {
@@ -489,20 +488,20 @@ export class Frame extends ChannelOwner<channels.FrameChannel> implements api.Fr
expression: String(pageFunction),
isFunction: typeof pageFunction === 'function',
arg: serializeArgument(arg),
- timeout: this._timeout(options),
- }, options.signal);
+ }, this._timeout(options));
return JSHandle.from(result.handle!) as any as structs.SmartHandle<R>;
}
async title(): Promise<string> {
- return (await this._channel.title({}, undefined)).value;
+ return (await this._channel.title({}, kNoTimeout)).value;
}
- async _expect(expression: string, options: Omit<channels.FrameExpectParams, 'expression'>, signal: AbortSignal | undefined): Promise<ExpectResult> {
- const params: channels.FrameExpectParams = { expression, ...options, isNot: !!options.isNot };
- params.expectedValue = serializeArgument(options.expectedValue);
+ async _expect(expression: string, options: Omit<channels.FrameExpectParams, 'expression'> & { timeout: number }, signal: AbortSignal | undefined): Promise<ExpectResult> {
+ const { timeout, ...rest } = options;
+ const params: channels.FrameExpectParams = { expression, ...rest, isNot: !!rest.isNot };
+ params.expectedValue = serializeArgument(rest.expectedValue);
try {
- await this._channel.expect(params, signal);
+ await this._channel.expect(params, { signal, timeout });
return { matches: !params.isNot };
} catch (e) {
if (e instanceof AbortError)
diff --git a/packages/playwright-core/src/client/harRouter.ts b/packages/playwright-core/src/client/harRouter.ts
index 173da21afb..5791bf3382 100644
--- a/packages/playwright-core/src/client/harRouter.ts
+++ b/packages/playwright-core/src/client/harRouter.ts
@@ -17,6 +17,7 @@
import { debugLogger } from '@utils/debugLogger';
import { isRegExp, isString } from '@isomorphic/rtti';
+import { kNoTimeout } from './timeoutSettings';
import type { BrowserContext } from './browserContext';
import type { LocalUtils } from './localUtils';
import type { Route } from './network';
@@ -127,7 +128,7 @@ export class HarRouter {
urlRegexSource: isRegExp(urlMatch) ? urlMatch.source : undefined,
urlRegexFlags: isRegExp(urlMatch) ? urlMatch.flags : undefined,
notFound: this._notFoundAction,
- }, undefined);
+ }, kNoTimeout);
this._apiRequestRegistrations.push({ context, registrationId });
}
@@ -137,7 +138,7 @@ export class HarRouter {
dispose() {
for (const { context, registrationId } of this._apiRequestRegistrations)
- context._channel.unrouteAPIRequestsFromHar({ registrationId }, undefined).catch(() => {});
+ context._channel.unrouteAPIRequestsFromHar({ registrationId }, kNoTimeout).catch(() => {});
this._apiRequestRegistrations = [];
this._localUtils.harClose({ harId: this._harId }).catch(() => {});
}
diff --git a/packages/playwright-core/src/client/input.ts b/packages/playwright-core/src/client/input.ts
index d5c2780b5b..8ff99de6be 100644
--- a/packages/playwright-core/src/client/input.ts
+++ b/packages/playwright-core/src/client/input.ts
@@ -15,6 +15,7 @@
* limitations under the License.
*/
+import { kNoTimeout } from './timeoutSettings';
import type { Page } from './page';
import type * as api from '../../types/types';
import type * as channels from './channels';
@@ -27,23 +28,23 @@ export class Keyboard implements api.Keyboard {
}
async down(key: string) {
- await this._page._channel.keyboardDown({ key }, undefined);
+ await this._page._channel.keyboardDown({ key }, kNoTimeout);
}
async up(key: string) {
- await this._page._channel.keyboardUp({ key }, undefined);
+ await this._page._channel.keyboardUp({ key }, kNoTimeout);
}
async insertText(text: string) {
- await this._page._channel.keyboardInsertText({ text }, undefined);
+ await this._page._channel.keyboardInsertText({ text }, kNoTimeout);
}
async type(text: string, options: channels.PageKeyboardTypeOptions = {}) {
- await this._page._channel.keyboardType({ text, ...options }, undefined);
+ await this._page._channel.keyboardType({ text, ...options }, kNoTimeout);
}
async press(key: string, options: channels.PageKeyboardPressOptions = {}) {
- await this._page._channel.keyboardPress({ key, ...options }, undefined);
+ await this._page._channel.keyboardPress({ key, ...options }, kNoTimeout);
}
}
@@ -55,19 +56,19 @@ export class Mouse implements api.Mouse {
}
async move(x: number, y: number, options: { steps?: number } = {}) {
- await this._page._channel.mouseMove({ x, y, ...options }, undefined);
+ await this._page._channel.mouseMove({ x, y, ...options }, kNoTimeout);
}
async down(options: channels.PageMouseDownOptions = {}) {
- await this._page._channel.mouseDown({ ...options }, undefined);
+ await this._page._channel.mouseDown({ ...options }, kNoTimeout);
}
async up(options: channels.PageMouseUpOptions = {}) {
- await this._page._channel.mouseUp(options, undefined);
+ await this._page._channel.mouseUp(options, kNoTimeout);
}
async click(x: number, y: number, options: channels.PageMouseClickOptions = {}) {
- await this._page._channel.mouseClick({ x, y, ...options }, undefined);
+ await this._page._channel.mouseClick({ x, y, ...options }, kNoTimeout);
}
async dblclick(x: number, y: number, options: Omit<channels.PageMouseClickOptions, 'clickCount'> = {}) {
@@ -77,7 +78,7 @@ export class Mouse implements api.Mouse {
}
async wheel(deltaX: number, deltaY: number) {
- await this._page._channel.mouseWheel({ deltaX, deltaY }, undefined);
+ await this._page._channel.mouseWheel({ deltaX, deltaY }, kNoTimeout);
}
}
@@ -89,6 +90,6 @@ export class Touchscreen implements api.Touchscreen {
}
async tap(x: number, y: number) {
- await this._page._channel.touchscreenTap({ x, y }, undefined);
+ await this._page._channel.touchscreenTap({ x, y }, kNoTimeout);
}
}
diff --git a/packages/playwright-core/src/client/jsHandle.ts b/packages/playwright-core/src/client/jsHandle.ts
index 2df73dd2d9..aa9841c2e4 100644
--- a/packages/playwright-core/src/client/jsHandle.ts
+++ b/packages/playwright-core/src/client/jsHandle.ts
@@ -17,6 +17,7 @@
import { parseSerializedValue, serializeValue } from '@protocol/serializers';
import { ChannelOwner } from './channelOwner';
import { isTargetClosedError } from './errors';
+import { kNoTimeout } from './timeoutSettings';
import type * as structs from '../../types/structs';
import type * as api from '../../types/types';
@@ -37,29 +38,29 @@ export class JSHandle<T = any> extends ChannelOwner<channels.JSHandleChannel> im
}
async evaluate<R, Arg>(pageFunction: structs.PageFunctionOn<T, Arg, R>, arg?: Arg): Promise<R> {
- const result = await this._channel.evaluateExpression({ expression: String(pageFunction), isFunction: typeof pageFunction === 'function', arg: serializeArgument(arg) }, undefined);
+ const result = await this._channel.evaluateExpression({ expression: String(pageFunction), isFunction: typeof pageFunction === 'function', arg: serializeArgument(arg) }, kNoTimeout);
return parseResult(result.value);
}
async evaluateHandle<R, Arg>(pageFunction: structs.PageFunctionOn<T, Arg, R>, arg?: Arg): Promise<structs.SmartHandle<R>> {
- const result = await this._channel.evaluateExpressionHandle({ expression: String(pageFunction), isFunction: typeof pageFunction === 'function', arg: serializeArgument(arg) }, undefined);
+ const result = await this._channel.evaluateExpressionHandle({ expression: String(pageFunction), isFunction: typeof pageFunction === 'function', arg: serializeArgument(arg) }, kNoTimeout);
return JSHandle.from(result.handle) as any as structs.SmartHandle<R>;
}
async getProperty(propertyName: string): Promise<JSHandle> {
- const result = await this._channel.getProperty({ name: propertyName }, undefined);
+ const result = await this._channel.getProperty({ name: propertyName }, kNoTimeout);
return JSHandle.from(result.handle);
}
async getProperties(): Promise<Map<string, JSHandle>> {
const map = new Map<string, JSHandle>();
- for (const { name, value } of (await this._channel.getPropertyList({}, undefined)).properties)
+ for (const { name, value } of (await this._channel.getPropertyList({}, kNoTimeout)).properties)
map.set(name, JSHandle.from(value));
return map;
}
async jsonValue(): Promise<T> {
- return parseResult((await this._channel.jsonValue({}, undefined)).value);
+ return parseResult((await this._channel.jsonValue({}, kNoTimeout)).value);
}
asElement(): T extends Node ? api.ElementHandle<T> : null {
@@ -72,7 +73,7 @@ export class JSHandle<T = any> extends ChannelOwner<channels.JSHandleChannel> im
async dispose() {
try {
- await this._channel.dispose({}, undefined);
+ await this._channel.dispose({}, kNoTimeout);
} catch (e) {
if (isTargetClosedError(e))
return;
diff --git a/packages/playwright-core/src/client/localUtils.ts b/packages/playwright-core/src/client/localUtils.ts
index f02be30075..baef6b701b 100644
--- a/packages/playwright-core/src/client/localUtils.ts
+++ b/packages/playwright-core/src/client/localUtils.ts
@@ -15,6 +15,7 @@
*/
import { ChannelOwner } from './channelOwner';
+import { kNoTimeout } from './timeoutSettings';
import type { Size } from './types';
import type * as channels from './channels';
@@ -40,34 +41,34 @@ export class LocalUtils extends ChannelOwner<channels.LocalUtilsChannel> {
}
async zip(params: channels.LocalUtilsZipParams): Promise<void> {
- return await this._channel.zip(params, undefined);
+ return await this._channel.zip(params, kNoTimeout);
}
async harOpen(params: channels.LocalUtilsHarOpenParams): Promise<channels.LocalUtilsHarOpenResult> {
- return await this._channel.harOpen(params, undefined);
+ return await this._channel.harOpen(params, kNoTimeout);
}
async harLookup(params: channels.LocalUtilsHarLookupParams): Promise<channels.LocalUtilsHarLookupResult> {
- return await this._channel.harLookup(params, undefined);
+ return await this._channel.harLookup(params, kNoTimeout);
}
async harClose(params: channels.LocalUtilsHarCloseParams): Promise<void> {
- return await this._channel.harClose(params, undefined);
+ return await this._channel.harClose(params, kNoTimeout);
}
async harUnzip(params: channels.LocalUtilsHarUnzipParams): Promise<void> {
- return await this._channel.harUnzip(params, undefined);
+ return await this._channel.harUnzip(params, kNoTimeout);
}
async tracingStarted(params: channels.LocalUtilsTracingStartedParams): Promise<channels.LocalUtilsTracingStartedResult> {
- return await this._channel.tracingStarted(params, undefined);
+ return await this._channel.tracingStarted(params, kNoTimeout);
}
async traceDiscarded(params: channels.LocalUtilsTraceDiscardedParams): Promise<void> {
- return await this._channel.traceDiscarded(params, undefined);
+ return await this._channel.traceDiscarded(params, kNoTimeout);
}
async addStackToTracingNoReply(params: channels.LocalUtilsAddStackToTracingNoReplyParams): Promise<void> {
- return await this._channel.addStackToTracingNoReply(params, undefined);
+ return await this._channel.addStackToTracingNoReply(params, kNoTimeout);
}
}
diff --git a/packages/playwright-core/src/client/locator.ts b/packages/playwright-core/src/client/locator.ts
index 99244f2295..8794dd0939 100644
--- a/packages/playwright-core/src/client/locator.ts
+++ b/packages/playwright-core/src/client/locator.ts
@@ -24,6 +24,7 @@ import { monotonicTime } from '@isomorphic/time';
import { ElementHandle } from './elementHandle';
import { serializeArgument } from './jsHandle';
import { DisposableStub } from './disposable';
+import { kNoTimeout } from './timeoutSettings';
import type { ExpectResult, Frame } from './frame';
import type { DropPayload, FilePayload, FrameExpectParams, Rect, SelectOption, SelectOptionOptions, TimeoutOptions } from './types';
@@ -78,11 +79,11 @@ export class Locator implements api.Locator {
}
private async _withElement<R>(task: (handle: ElementHandle<SVGElement | HTMLElement>, timeout?: number) => Promise<R>, options: { title: string, internal?: boolean, timeout?: number, signal?: AbortSignal }): Promise<R> {
- const timeout = this._frame._timeout({ timeout: options.timeout });
+ const timeout = this._frame._timeout({ timeout: options.timeout }).timeout;
const deadline = timeout ? monotonicTime() + timeout : 0;
return await this._frame._wrapApiCall<R>(async () => {
- const result = await this._frame._channel.waitForSelector({ selector: this._selector, strict: true, state: 'attached', timeout }, options.signal);
+ const result = await this._frame._channel.waitForSelector({ selector: this._selector, strict: true, state: 'attached' }, { signal: options.signal, timeout });
const handle = ElementHandle.fromNullable(result.element) as ElementHandle<SVGElement | HTMLElement> | null;
if (!handle)
throw new Error(`Could not resolve ${this._selector} to DOM Element`);
@@ -261,7 +262,7 @@ export class Locator implements api.Locator {
}
async blur(options?: TimeoutOptions): Promise<void> {
- await this._frame._channel.blur({ selector: this._selector, strict: true, ...options, timeout: this._frame._timeout(options) }, options?.signal);
+ await this._frame._channel.blur({ selector: this._selector, strict: true, ...options }, this._frame._timeout(options));
}
async count(): Promise<number> {
@@ -269,7 +270,7 @@ export class Locator implements api.Locator {
}
async normalize(): Promise<Locator> {
- const { resolvedSelector } = await this._frame._channel.resolveSelector({ selector: this._selector }, undefined);
+ const { resolvedSelector } = await this._frame._channel.resolveSelector({ selector: this._selector }, kNoTimeout);
return new Locator(this._frame, resolvedSelector);
}
@@ -327,7 +328,7 @@ export class Locator implements api.Locator {
}
async ariaSnapshot(options: TimeoutOptions & { mode?: 'ai' | 'default', depth?: number, boxes?: boolean } = {}): Promise<string> {
- const result = await this._frame._channel.ariaSnapshot({ timeout: this._frame._timeout(options), mode: options.mode, selector: this._selector, depth: options.depth, boxes: options.boxes }, options.signal);
+ const result = await this._frame._channel.ariaSnapshot({ mode: options.mode, selector: this._selector, depth: options.depth, boxes: options.boxes }, this._frame._timeout(options));
return result.snapshot;
}
@@ -389,7 +390,7 @@ export class Locator implements api.Locator {
waitFor(options: channels.FrameWaitForSelectorOptions & TimeoutOptions & { state: 'attached' | 'visible' }): Promise<void>;
waitFor(options?: channels.FrameWaitForSelectorOptions & TimeoutOptions): Promise<void>;
async waitFor(options?: channels.FrameWaitForSelectorOptions & TimeoutOptions): Promise<void> {
- await this._frame._channel.waitForSelector({ selector: this._selector, strict: true, omitReturnValue: true, ...options, timeout: this._frame._timeout(options) }, options?.signal);
+ await this._frame._channel.waitForSelector({ selector: this._selector, strict: true, omitReturnValue: true, ...options }, this._frame._timeout(options));
}
async waitForFunction<R, Arg>(pageFunction: structs.PageFunctionOn<SVGElement | HTMLElement, Arg, R>, arg?: Arg, options?: TimeoutOptions): Promise<void> {
@@ -399,8 +400,7 @@ export class Locator implements api.Locator {
expression: String(pageFunction),
isFunction: typeof pageFunction === 'function',
arg: serializeArgument(arg),
- timeout: this._frame._timeout(options),
- }, options?.signal);
+ }, this._frame._timeout(options));
}
diff --git a/packages/playwright-core/src/client/network.ts b/packages/playwright-core/src/client/network.ts
index 7c33d3a8b6..7c4fb67cbf 100644
--- a/packages/playwright-core/src/client/network.ts
+++ b/packages/playwright-core/src/client/network.ts
@@ -32,10 +32,11 @@ import { APIResponse } from './fetch';
import { Events } from './events';
import { isTargetClosedError } from './errors';
import { ChannelOwner } from './channelOwner';
+import { kNoTimeout } from './timeoutSettings';
import type { BrowserContext } from './browserContext';
import type { Page } from './page';
-import type { Headers, RemoteAddr, SecurityDetails, TimeoutOptions, WaitForEventOptions } from './types';
+import type { Headers, RemoteAddr, SecurityDetails, WaitForEventOptions } from './types';
import type { Serializable } from '../../types/structs';
import type * as api from '../../types/types';
import type { HeadersArray } from '@isomorphic/types';
@@ -179,7 +180,7 @@ export class Request extends ChannelOwner<channels.RequestChannel> implements ap
if (!this._actualHeadersPromise) {
this._actualHeadersPromise = this._wrapApiCall(async () => {
- return new RawHeaders((await this._channel.rawRequestHeaders({}, undefined)).headers);
+ return new RawHeaders((await this._channel.rawRequestHeaders({}, kNoTimeout)).headers);
}, { internal: true });
}
return await this._actualHeadersPromise;
@@ -198,11 +199,11 @@ export class Request extends ChannelOwner<channels.RequestChannel> implements ap
}
async response(): Promise<Response | null> {
- return Response.fromNullable((await this._channel.response({}, undefined)).response);
+ return Response.fromNullable((await this._channel.response({}, kNoTimeout)).response);
}
async _internalResponse(): Promise<Response | null> {
- return Response.fromNullable((await this._channel.response({}, undefined)).response);
+ return Response.fromNullable((await this._channel.response({}, kNoTimeout)).response);
}
existingResponse(): Response | null {
@@ -261,7 +262,7 @@ export class Request extends ChannelOwner<channels.RequestChannel> implements ap
const response = await this.response();
if (!response)
throw new Error('Unable to fetch sizes for failed request');
- return (await response._channel.sizes({}, undefined)).sizes;
+ return (await response._channel.sizes({}, kNoTimeout)).sizes;
}
_setResponseEndTiming(responseEndTiming: number) {
@@ -336,13 +337,13 @@ export class Route extends ChannelOwner<channels.RouteChannel> implements api.Ro
async abort(errorCode?: string) {
await this._handleRoute(async () => {
- await this._raceWithTargetClose(this._channel.abort({ errorCode }, undefined));
+ await this._raceWithTargetClose(this._channel.abort({ errorCode }, kNoTimeout));
});
}
async _redirectNavigationRequest(url: string) {
await this._handleRoute(async () => {
- await this._raceWithTargetClose(this._channel.redirectNavigationRequest({ url }, undefined));
+ await this._raceWithTargetClose(this._channel.redirectNavigationRequest({ url }, kNoTimeout));
});
}
@@ -423,7 +424,7 @@ export class Route extends ChannelOwner<channels.RouteChannel> implements api.Ro
body,
isBase64,
fetchResponseUid
- }, undefined));
+ }, kNoTimeout));
}
async continue(options: FallbackOverrides = {}) {
@@ -452,7 +453,7 @@ export class Route extends ChannelOwner<channels.RouteChannel> implements api.Ro
headers: options.headers ? headersObjectToArray(options.headers) : undefined,
postData: options.postDataBuffer,
isFallback,
- }, undefined));
+ }, kNoTimeout));
}
}
@@ -493,14 +494,14 @@ export class WebSocketRoute extends ChannelOwner<channels.WebSocketRouteChannel>
},
close: async (options: { code?: number, reason?: string } = {}) => {
- await this._channel.closeServer({ ...options, wasClean: true }, undefined).catch(() => {});
+ await this._channel.closeServer({ ...options, wasClean: true }, kNoTimeout).catch(() => {});
},
send: (message: string | Buffer) => {
if (isString(message))
- this._channel.sendToServer({ message, isBase64: false }, undefined).catch(() => {});
+ this._channel.sendToServer({ message, isBase64: false }, kNoTimeout).catch(() => {});
else
- this._channel.sendToServer({ message: message.toString('base64'), isBase64: true }, undefined).catch(() => {});
+ this._channel.sendToServer({ message: message.toString('base64'), isBase64: true }, kNoTimeout).catch(() => {});
},
async [Symbol.asyncDispose]() {
@@ -512,28 +513,28 @@ export class WebSocketRoute extends ChannelOwner<channels.WebSocketRouteChannel>
if (this._onPageMessage)
this._onPageMessage(isBase64 ? Buffer.from(message, 'base64') : message);
else if (this._connected)
- this._channel.sendToServer({ message, isBase64 }, undefined).catch(() => {});
+ this._channel.sendToServer({ message, isBase64 }, kNoTimeout).catch(() => {});
});
this._channel.on('messageFromServer', ({ message, isBase64 }) => {
if (this._onServerMessage)
this._onServerMessage(isBase64 ? Buffer.from(message, 'base64') : message);
else
- this._channel.sendToPage({ message, isBase64 }, undefined).catch(() => {});
+ this._channel.sendToPage({ message, isBase64 }, kNoTimeout).catch(() => {});
});
this._channel.on('closePage', ({ code, reason, wasClean }) => {
if (this._onPageClose)
this._onPageClose(code, reason);
else
- this._channel.closeServer({ code, reason, wasClean }, undefined).catch(() => {});
+ this._channel.closeServer({ code, reason, wasClean }, kNoTimeout).catch(() => {});
});
this._channel.on('closeServer', ({ code, reason, wasClean }) => {
if (this._onServerClose)
this._onServerClose(code, reason);
else
- this._channel.closePage({ code, reason, wasClean }, undefined).catch(() => {});
+ this._channel.closePage({ code, reason, wasClean }, kNoTimeout).catch(() => {});
});
}
@@ -546,22 +547,22 @@ export class WebSocketRoute extends ChannelOwner<channels.WebSocketRouteChannel>
}
async close(options: { code?: number, reason?: string } = {}) {
- await this._channel.closePage({ ...options, wasClean: true }, undefined).catch(() => {});
+ await this._channel.closePage({ ...options, wasClean: true }, kNoTimeout).catch(() => {});
}
connectToServer() {
if (this._connected)
throw new Error('Already connected to the server');
this._connected = true;
- this._channel.connect({}, undefined).catch(() => {});
+ this._channel.connect({}, kNoTimeout).catch(() => {});
return this._server;
}
send(message: string | Buffer) {
if (isString(message))
- this._channel.sendToPage({ message, isBase64: false }, undefined).catch(() => {});
+ this._channel.sendToPage({ message, isBase64: false }, kNoTimeout).catch(() => {});
else
- this._channel.sendToPage({ message: message.toString('base64'), isBase64: true }, undefined).catch(() => {});
+ this._channel.sendToPage({ message: message.toString('base64'), isBase64: true }, kNoTimeout).catch(() => {});
}
onMessage(handler: (message: string | Buffer) => any) {
@@ -581,7 +582,7 @@ export class WebSocketRoute extends ChannelOwner<channels.WebSocketRouteChannel>
return;
// Ensure that websocket is "open" and can send messages without an actual server connection.
// If this happens after the page has been closed, ignore the error.
- await this._channel.ensureOpened({}, undefined).catch(() => {});
+ await this._channel.ensureOpened({}, kNoTimeout).catch(() => {});
}
}
@@ -701,7 +702,7 @@ export class Response extends ChannelOwner<channels.ResponseChannel> implements
async _actualHeaders(): Promise<RawHeaders> {
if (!this._actualHeadersPromise) {
this._actualHeadersPromise = (async () => {
- return new RawHeaders((await this._channel.rawResponseHeaders({}, undefined)).headers);
+ return new RawHeaders((await this._channel.rawResponseHeaders({}, kNoTimeout)).headers);
})();
}
return await this._actualHeadersPromise;
@@ -728,7 +729,7 @@ export class Response extends ChannelOwner<channels.ResponseChannel> implements
}
async body(): Promise<Buffer> {
- return (await this._channel.body({}, undefined)).binary;
+ return (await this._channel.body({}, kNoTimeout)).binary;
}
async text(): Promise<string> {
@@ -750,15 +751,15 @@ export class Response extends ChannelOwner<channels.ResponseChannel> implements
}
async serverAddr(): Promise<RemoteAddr|null> {
- return (await this._channel.serverAddr({}, undefined)).value || null;
+ return (await this._channel.serverAddr({}, kNoTimeout)).value || null;
}
async securityDetails(): Promise<SecurityDetails|null> {
- return (await this._channel.securityDetails({}, undefined)).value || null;
+ return (await this._channel.securityDetails({}, kNoTimeout)).value || null;
}
async httpVersion(): Promise<string> {
- return (await this._channel.httpVersion({}, undefined)).value;
+ return (await this._channel.httpVersion({}, kNoTimeout)).value;
}
}
@@ -803,9 +804,8 @@ export class WebSocket extends ChannelOwner<channels.WebSocketChannel> implement
async waitForEvent(event: string, optionsOrPredicate: WaitForEventOptions = {}): Promise<any> {
return await this._wrapApiCall(async () => {
- const timeout = this._page._timeoutSettings.timeout(typeof optionsOrPredicate === 'function' ? {} : optionsOrPredicate);
+ const { timeout, signal } = this._page._timeoutSettings.timeout(typeof optionsOrPredicate === 'function' ? {} : optionsOrPredicate);
const predicate = typeof optionsOrPredicate === 'function' ? optionsOrPredicate : optionsOrPredicate.predicate;
- const signal = typeof optionsOrPredicate === 'function' ? undefined : (optionsOrPredicate as TimeoutOptions).signal;
const waiter = Waiter.createForEvent(this, event);
waiter.rejectOnTimeout(timeout, `Timeout ${timeout}ms exceeded while waiting for event "${event}"`);
waiter.rejectOnSignal(signal);
diff --git a/packages/playwright-core/src/client/page.ts b/packages/playwright-core/src/client/page.ts
index 1ee49a01dc..1fedf84e23 100644
--- a/packages/playwright-core/src/client/page.ts
+++ b/packages/playwright-core/src/client/page.ts
@@ -45,7 +45,7 @@ import { Video } from './video';
import { Screencast } from './screencast';
import { Waiter } from './waiter';
import { Worker } from './worker';
-import { TimeoutSettings } from './timeoutSettings';
+import { TimeoutSettings, kNoTimeout } from './timeoutSettings';
import { mkdirIfNeeded } from './fileUtils';
import { ConsoleMessage } from './consoleMessage';
import type { BrowserContext } from './browserContext';
@@ -306,16 +306,16 @@ export class Page extends ChannelOwner<channels.PageChannel> implements api.Page
}
async pickLocator(): Promise<Locator> {
- const { selector } = await this._channel.pickLocator({}, undefined);
+ const { selector } = await this._channel.pickLocator({}, kNoTimeout);
return this.locator(selector);
}
async cancelPickLocator(): Promise<void> {
- await this._channel.cancelPickLocator({}, undefined);
+ await this._channel.cancelPickLocator({}, kNoTimeout);
}
async hideHighlight(): Promise<void> {
- await this._channel.hideHighlight({}, undefined);
+ await this._channel.hideHighlight({}, kNoTimeout);
}
async $(selector: string, options?: { strict?: boolean }): Promise<ElementHandle<SVGElement | HTMLElement> | null> {
@@ -360,21 +360,21 @@ export class Page extends ChannelOwner<channels.PageChannel> implements api.Page
}
async exposeFunction(name: string, callback: Function) {
- const result = await this._channel.exposeBinding({ name }, undefined);
+ const result = await this._channel.exposeBinding({ name }, kNoTimeout);
const binding = (source: structs.BindingSource, ...args: any[]) => callback(...args);
this._bindings.set(name, binding);
return DisposableObject.from(result.disposable);
}
async exposeBinding(name: string, callback: (source: structs.BindingSource, ...args: any[]) => any) {
- const result = await this._channel.exposeBinding({ name }, undefined);
+ const result = await this._channel.exposeBinding({ name }, kNoTimeout);
this._bindings.set(name, callback);
return DisposableObject.from(result.disposable);
}
async setExtraHTTPHeaders(headers: Headers) {
validateHeaders(headers);
- await this._channel.setExtraHTTPHeaders({ headers: headersObjectToArray(headers) }, undefined);
+ await this._channel.setExtraHTTPHeaders({ headers: headersObjectToArray(headers) }, kNoTimeout);
}
url(): string {
@@ -395,7 +395,7 @@ export class Page extends ChannelOwner<channels.PageChannel> implements api.Page
async reload(options: channels.PageReloadOptions & TimeoutOptions = {}): Promise<Response | null> {
const waitUntil = verifyLoadState('waitUntil', options.waitUntil === undefined ? 'load' : options.waitUntil);
- return Response.fromNullable((await this._channel.reload({ ...options, waitUntil, timeout: this._timeoutSettings.navigationTimeout(options) }, options.signal)).response);
+ return Response.fromNullable((await this._channel.reload({ ...options, waitUntil }, this._timeoutSettings.navigationTimeout(options))).response);
}
async addLocatorHandler(locator: Locator, handler: (locator: Locator) => any, options: { times?: number, noWaitAfter?: boolean } = {}): Promise<void> {
@@ -403,7 +403,7 @@ export class Page extends ChannelOwner<channels.PageChannel> implements api.Page
throw new Error(`Locator must belong to the main frame of this page`);
if (options.times === 0)
return;
- const { uid } = await this._channel.registerLocatorHandler({ selector: locator._selector, noWaitAfter: options.noWaitAfter }, undefined);
+ const { uid } = await this._channel.registerLocatorHandler({ selector: locator._selector, noWaitAfter: options.noWaitAfter }, kNoTimeout);
this._locatorHandlers.set(uid, { locator, handler, times: options.times });
}
@@ -420,7 +420,7 @@ export class Page extends ChannelOwner<channels.PageChannel> implements api.Page
} finally {
if (remove)
this._locatorHandlers.delete(uid);
- this._channel.resolveLocatorHandlerNoReply({ uid, remove }, undefined).catch(() => {});
+ this._channel.resolveLocatorHandlerNoReply({ uid, remove }, kNoTimeout).catch(() => {});
}
}
@@ -428,7 +428,7 @@ export class Page extends ChannelOwner<channels.PageChannel> implements api.Page
for (const [uid, data] of this._locatorHandlers) {
if (data.locator._equals(locator)) {
this._locatorHandlers.delete(uid);
- await this._channel.unregisterLocatorHandler({ uid }, undefined).catch(() => {});
+ await this._channel.unregisterLocatorHandler({ uid }, kNoTimeout).catch(() => {});
}
}
}
@@ -477,9 +477,8 @@ export class Page extends ChannelOwner<channels.PageChannel> implements api.Page
private async _waitForEvent(event: string, optionsOrPredicate: WaitForEventOptions, logLine?: string): Promise<any> {
return await this._wrapApiCall(async () => {
- const timeout = this._timeoutSettings.timeout(typeof optionsOrPredicate === 'function' ? {} : optionsOrPredicate);
+ const { timeout, signal } = this._timeoutSettings.timeout(typeof optionsOrPredicate === 'function' ? {} : optionsOrPredicate);
const predicate = typeof optionsOrPredicate === 'function' ? optionsOrPredicate : optionsOrPredicate.predicate;
- const signal = typeof optionsOrPredicate === 'function' ? undefined : (optionsOrPredicate as TimeoutOptions).signal;
const waiter = Waiter.createForEvent(this, event);
if (logLine)
waiter.log(logLine);
@@ -497,16 +496,16 @@ export class Page extends ChannelOwner<channels.PageChannel> implements api.Page
async goBack(options: channels.PageGoBackOptions & TimeoutOptions = {}): Promise<Response | null> {
const waitUntil = verifyLoadState('waitUntil', options.waitUntil === undefined ? 'load' : options.waitUntil);
- return Response.fromNullable((await this._channel.goBack({ ...options, waitUntil, timeout: this._timeoutSettings.navigationTimeout(options) }, options.signal)).response);
+ return Response.fromNullable((await this._channel.goBack({ ...options, waitUntil }, this._timeoutSettings.navigationTimeout(options))).response);
}
async goForward(options: channels.PageGoForwardOptions & TimeoutOptions = {}): Promise<Response | null> {
const waitUntil = verifyLoadState('waitUntil', options.waitUntil === undefined ? 'load' : options.waitUntil);
- return Response.fromNullable((await this._channel.goForward({ ...options, waitUntil, timeout: this._timeoutSettings.navigationTimeout(options) }, options.signal)).response);
+ return Response.fromNullable((await this._channel.goForward({ ...options, waitUntil }, this._timeoutSettings.navigationTimeout(options))).response);
}
async requestGC() {
- await this._channel.requestGC({}, undefined);
+ await this._channel.requestGC({}, kNoTimeout);
}
async emulateMedia(options: { media?: 'screen' | 'print' | null, colorScheme?: 'dark' | 'light' | 'no-preference' | null, reducedMotion?: 'reduce' | 'no-preference' | null, forcedColors?: 'active' | 'none' | null, contrast?: 'no-preference' | 'more' | null } = {}) {
@@ -516,12 +515,12 @@ export class Page extends ChannelOwner<channels.PageChannel> implements api.Page
reducedMotion: options.reducedMotion === null ? 'no-override' : options.reducedMotion,
forcedColors: options.forcedColors === null ? 'no-override' : options.forcedColors,
contrast: options.contrast === null ? 'no-override' : options.contrast,
- }, undefined);
+ }, kNoTimeout);
}
async setViewportSize(viewportSize: Size) {
this._viewportSize = viewportSize;
- await this._channel.setViewportSize({ viewportSize }, undefined);
+ await this._channel.setViewportSize({ viewportSize }, kNoTimeout);
}
viewportSize(): Size | null {
@@ -535,7 +534,7 @@ export class Page extends ChannelOwner<channels.PageChannel> implements api.Page
async addInitScript(script: Function | string | { path?: string, content?: string }, arg?: any) {
const source = await evaluationScript(script, arg);
- return DisposableObject.from((await this._channel.addInitScript({ source }, undefined)).disposable);
+ return DisposableObject.from((await this._channel.addInitScript({ source }, kNoTimeout)).disposable);
}
async route(url: URLMatch, handler: RouteHandlerCallback, options: { times?: number } = {}): Promise<DisposableStub> {
@@ -595,17 +594,17 @@ export class Page extends ChannelOwner<channels.PageChannel> implements api.Page
private async _updateInterceptionPatterns(options: { internal: true } | { title: string }) {
const patterns = RouteHandler.prepareInterceptionPatterns(this._routes);
- await this._wrapApiCall(() => this._channel.setNetworkInterceptionPatterns({ patterns }, undefined), options);
+ await this._wrapApiCall(() => this._channel.setNetworkInterceptionPatterns({ patterns }, kNoTimeout), options);
}
private async _updateWebSocketInterceptionPatterns(options: { internal: true } | { title: string }) {
const patterns = WebSocketRouteHandler.prepareInterceptionPatterns(this._webSocketRoutes);
- await this._wrapApiCall(() => this._channel.setWebSocketInterceptionPatterns({ patterns }, undefined), options);
+ await this._wrapApiCall(() => this._channel.setWebSocketInterceptionPatterns({ patterns }, kNoTimeout), options);
}
async screenshot(options: Omit<channels.PageScreenshotOptions, 'mask'> & TimeoutOptions & { path?: string, mask?: api.Locator[] } = {}): Promise<Buffer> {
const mask = options.mask as Locator[] | undefined;
- const copy: channels.PageScreenshotParams = { ...options, mask: undefined, timeout: this._timeoutSettings.timeout(options) };
+ const copy: channels.PageScreenshotParams = { ...options, mask: undefined };
if (!copy.type)
copy.type = determineScreenshotType(options);
if (mask) {
@@ -614,7 +613,7 @@ export class Page extends ChannelOwner<channels.PageChannel> implements api.Page
selector: locator._selector,
}));
}
- const result = await this._channel.screenshot(copy, options.signal);
+ const result = await this._channel.screenshot(copy, this._timeoutSettings.timeout(options));
if (options.path) {
await mkdirIfNeeded(options.path);
await fs.promises.writeFile(options.path, result.binary);
@@ -623,6 +622,7 @@ export class Page extends ChannelOwner<channels.PageChannel> implements api.Page
}
async _expectScreenshot(options: ExpectScreenshotOptions): Promise<{ actual?: Buffer, previous?: Buffer, diff?: Buffer, errorMessage?: string, log?: string[], timedOut?: boolean}> {
+ const { timeout, ...optionsWithoutTimeout } = options;
const mask = options?.mask ? options?.mask.map(locator => ({
frame: (locator as Locator)._frame._channel,
selector: (locator as Locator)._selector,
@@ -633,11 +633,11 @@ export class Page extends ChannelOwner<channels.PageChannel> implements api.Page
} : undefined;
try {
const result = await this._channel.expectScreenshot({
- ...options,
+ ...optionsWithoutTimeout,
isNot: !!options.isNot,
locator,
mask,
- }, undefined);
+ }, { signal: undefined, timeout });
return { actual: result.actual };
} catch (e) {
if (!(e instanceof PlaywrightError))
@@ -652,7 +652,7 @@ export class Page extends ChannelOwner<channels.PageChannel> implements api.Page
}
async bringToFront(): Promise<void> {
- await this._channel.bringToFront({}, undefined);
+ await this._channel.bringToFront({}, kNoTimeout);
}
async [Symbol.asyncDispose]() {
@@ -667,9 +667,9 @@ export class Page extends ChannelOwner<channels.PageChannel> implements api.Page
if (this._ownedContext)
await this._ownedContext.close();
else if (options.runBeforeUnload)
- await this._channel.runBeforeUnload({}, undefined);
+ await this._channel.runBeforeUnload({}, kNoTimeout);
else
- await this._channel.close({ reason: options.reason }, undefined);
+ await this._channel.close({ reason: options.reason }, kNoTimeout);
} catch (e) {
if (isTargetClosedError(e) && !options.runBeforeUnload)
return;
@@ -702,20 +702,20 @@ export class Page extends ChannelOwner<channels.PageChannel> implements api.Page
}
async clearConsoleMessages(): Promise<void> {
- await this._channel.clearConsoleMessages({}, undefined);
+ await this._channel.clearConsoleMessages({}, kNoTimeout);
}
async consoleMessages(options?: { filter?: 'all' | 'since-navigation' }): Promise<ConsoleMessage[]> {
- const { messages } = await this._channel.consoleMessages({ filter: options?.filter }, undefined);
+ const { messages } = await this._channel.consoleMessages({ filter: options?.filter }, kNoTimeout);
return messages.map(message => new ConsoleMessage(message, this, null));
}
async clearPageErrors(): Promise<void> {
- await this._channel.clearPageErrors({}, undefined);
+ await this._channel.clearPageErrors({}, kNoTimeout);
}
async pageErrors(options?: { filter?: 'all' | 'since-navigation' }): Promise<Error[]> {
- const { errors } = await this._channel.pageErrors({ filter: options?.filter }, undefined);
+ const { errors } = await this._channel.pageErrors({ filter: options?.filter }, kNoTimeout);
return errors.map(error => parseError(error));
}
@@ -844,7 +844,7 @@ export class Page extends ChannelOwner<channels.PageChannel> implements api.Page
}
async requests() {
- const { requests } = await this._channel.requests({}, undefined);
+ const { requests } = await this._channel.requests({}, kNoTimeout);
return requests.map(request => Request.from(request));
}
@@ -861,7 +861,7 @@ export class Page extends ChannelOwner<channels.PageChannel> implements api.Page
this._browserContext.setDefaultNavigationTimeout(0);
this._browserContext.setDefaultTimeout(0);
this._instrumentation?.onWillPause({ keepTestTimeout: !!_options?.__testHookKeepTestTimeout });
- await this._closedOrCrashedScope.safeRace(this.context()._channel.pause({}, undefined));
+ await this._closedOrCrashedScope.safeRace(this.context()._channel.pause({}, kNoTimeout));
this._browserContext.setDefaultNavigationTimeout(defaultNavigationTimeout);
this._browserContext.setDefaultTimeout(defaultTimeout);
}
@@ -879,7 +879,7 @@ export class Page extends ChannelOwner<channels.PageChannel> implements api.Page
if (options.margin && typeof options.margin[index] === 'number')
transportOptions.margin![index] = transportOptions.margin![index] + 'px';
}
- const result = await this._channel.pdf(transportOptions, undefined);
+ const result = await this._channel.pdf(transportOptions, kNoTimeout);
if (options.path) {
await fs.promises.mkdir(path.dirname(options.path), { recursive: true });
await fs.promises.writeFile(options.path, result.pdf);
@@ -888,12 +888,12 @@ export class Page extends ChannelOwner<channels.PageChannel> implements api.Page
}
async ariaSnapshot(options: TimeoutOptions & { mode?: 'ai' | 'default', depth?: number, boxes?: boolean } = {}): Promise<string> {
- const result = await this.mainFrame()._channel.ariaSnapshot({ timeout: this._timeoutSettings.timeout(options), mode: options.mode, depth: options.depth, boxes: options.boxes }, options.signal);
+ const result = await this.mainFrame()._channel.ariaSnapshot({ mode: options.mode, depth: options.depth, boxes: options.boxes }, this._timeoutSettings.timeout(options));
return result.snapshot;
}
async _setDockTile(image: Buffer) {
- await this._channel.setDockTile({ image }, undefined);
+ await this._channel.setDockTile({ image }, kNoTimeout);
}
}
@@ -915,9 +915,9 @@ export class BindingCall extends ChannelOwner<channels.BindingCallChannel> {
frame
};
const result = await func(source, ...this._initializer.args.map(parseResult));
- this._channel.resolve({ result: serializeArgument(result) }, undefined).catch(() => {});
+ this._channel.resolve({ result: serializeArgument(result) }, kNoTimeout).catch(() => {});
} catch (e) {
- this._channel.reject({ error: serializeError(e) }, undefined).catch(() => {});
+ this._channel.reject({ error: serializeError(e) }, kNoTimeout).catch(() => {});
}
}
}
diff --git a/packages/playwright-core/src/client/screencast.ts b/packages/playwright-core/src/client/screencast.ts
index 6b838a80ea..162ac25d6c 100644
--- a/packages/playwright-core/src/client/screencast.ts
+++ b/packages/playwright-core/src/client/screencast.ts
@@ -16,6 +16,7 @@
import { Artifact } from './artifact';
import { DisposableStub } from './disposable';
+import { kNoTimeout } from './timeoutSettings';
import type * as api from '../../types/types';
import type { Page } from './page';
@@ -45,7 +46,7 @@ export class Screencast implements api.Screencast {
quality: options.quality,
sendFrames: !!options.onFrame,
record: !!options.path,
- }, undefined);
+ }, kNoTimeout);
if (result.artifact) {
this._artifact = Artifact.from(result.artifact);
this._savePath = options.path;
@@ -57,7 +58,7 @@ export class Screencast implements api.Screencast {
await this._page._wrapApiCall(async () => {
this._started = false;
this._onFrame = null;
- await this._page._channel.screencastStop({}, undefined);
+ await this._page._channel.screencastStop({}, kNoTimeout);
if (this._savePath)
await this._artifact?.saveAs(this._savePath);
this._artifact = undefined;
@@ -66,28 +67,28 @@ export class Screencast implements api.Screencast {
}
async showActions(options?: { duration?: number, position?: 'top-left' | 'top' | 'top-right' | 'bottom-left' | 'bottom' | 'bottom-right', fontSize?: number, cursor?: 'none' | 'pointer' }): Promise<DisposableStub> {
- await this._page._channel.screencastShowActions({ duration: options?.duration, position: options?.position, fontSize: options?.fontSize, cursor: options?.cursor }, undefined);
- return new DisposableStub(() => this._page._channel.screencastHideActions({}, undefined));
+ await this._page._channel.screencastShowActions({ duration: options?.duration, position: options?.position, fontSize: options?.fontSize, cursor: options?.cursor }, kNoTimeout);
+ return new DisposableStub(() => this._page._channel.screencastHideActions({}, kNoTimeout));
}
async hideActions(): Promise<void> {
- await this._page._channel.screencastHideActions({}, undefined);
+ await this._page._channel.screencastHideActions({}, kNoTimeout);
}
async showOverlay(html: string, options?: { duration?: number }): Promise<DisposableStub> {
- const { id } = await this._page._channel.screencastShowOverlay({ html, duration: options?.duration }, undefined);
- return new DisposableStub(() => this._page._channel.screencastRemoveOverlay({ id }, undefined));
+ const { id } = await this._page._channel.screencastShowOverlay({ html, duration: options?.duration }, kNoTimeout);
+ return new DisposableStub(() => this._page._channel.screencastRemoveOverlay({ id }, kNoTimeout));
}
async showChapter(title: string, options?: { description?: string, duration?: number }): Promise<void> {
- await this._page._channel.screencastChapter({ title, ...options }, undefined);
+ await this._page._channel.screencastChapter({ title, ...options }, kNoTimeout);
}
async showOverlays(): Promise<void> {
- await this._page._channel.screencastSetOverlayVisible({ visible: true }, undefined);
+ await this._page._channel.screencastSetOverlayVisible({ visible: true }, kNoTimeout);
}
async hideOverlays(): Promise<void> {
- await this._page._channel.screencastSetOverlayVisible({ visible: false }, undefined);
+ await this._page._channel.screencastSetOverlayVisible({ visible: false }, kNoTimeout);
}
}
diff --git a/packages/playwright-core/src/client/selectors.ts b/packages/playwright-core/src/client/selectors.ts
index 43ce5ca431..e3712fca61 100644
--- a/packages/playwright-core/src/client/selectors.ts
+++ b/packages/playwright-core/src/client/selectors.ts
@@ -16,6 +16,7 @@
import { evaluationScript } from './clientHelper';
import { setTestIdAttribute } from './locator';
+import { kNoTimeout } from './timeoutSettings';
import type { SelectorEngine } from './types';
import type * as api from '../../types/types';
@@ -34,7 +35,7 @@ export class Selectors implements api.Selectors {
const source = await evaluationScript(script, undefined, false);
const selectorEngine: channels.SelectorEngine = { ...options, name, source };
for (const context of this._contextsForSelectors)
- await context._channel.registerSelectorEngine({ selectorEngine }, undefined);
+ await context._channel.registerSelectorEngine({ selectorEngine }, kNoTimeout);
this._selectorEngines.push(selectorEngine);
}
@@ -43,7 +44,7 @@ export class Selectors implements api.Selectors {
setTestIdAttribute(attributeName);
for (const context of this._contextsForSelectors) {
context._options.testIdAttributeName = attributeName;
- context._channel.setTestIdAttributeName({ testIdAttributeName: attributeName }, undefined).catch(() => {});
+ context._channel.setTestIdAttributeName({ testIdAttributeName: attributeName }, kNoTimeout).catch(() => {});
}
}
diff --git a/packages/playwright-core/src/client/stream.ts b/packages/playwright-core/src/client/stream.ts
index eb3a43081b..e3b703035f 100644
--- a/packages/playwright-core/src/client/stream.ts
+++ b/packages/playwright-core/src/client/stream.ts
@@ -17,6 +17,7 @@
import { Readable } from 'stream';
import { ChannelOwner } from './channelOwner';
+import { kNoTimeout } from './timeoutSettings';
import type * as channels from './channels';
@@ -43,7 +44,7 @@ class ReadableStreamImpl extends Readable {
}
override async _read() {
- const result = await this._channel.read({ size: 1024 * 1024 }, undefined);
+ const result = await this._channel.read({ size: 1024 * 1024 }, kNoTimeout);
if (result.binary.byteLength)
this.push(result.binary);
else
@@ -52,7 +53,7 @@ class ReadableStreamImpl extends Readable {
override _destroy(error: Error | null, callback: (error: Error | null | undefined) => void): void {
// Stream might be destroyed after the connection was closed.
- this._channel.close({}, undefined).catch(e => null);
+ this._channel.close({}, kNoTimeout).catch(e => null);
super._destroy(error, callback);
}
}
diff --git a/packages/playwright-core/src/client/timeoutSettings.ts b/packages/playwright-core/src/client/timeoutSettings.ts
index f5c4b4f5cc..637a06f47b 100644
--- a/packages/playwright-core/src/client/timeoutSettings.ts
+++ b/packages/playwright-core/src/client/timeoutSettings.ts
@@ -18,6 +18,13 @@
import { DEFAULT_PLAYWRIGHT_LAUNCH_TIMEOUT, DEFAULT_PLAYWRIGHT_TIMEOUT } from '@isomorphic/time';
import { debugMode } from '@utils/debug';
+import type * as channels from './channels';
+
+type TimeoutInput = { timeout?: number, signal?: AbortSignal };
+
+// Sentinel for internal calls that intentionally opt out of a deadline.
+export const kNoTimeout: channels.TimeoutOptions = { signal: undefined, timeout: 0 };
+
export class TimeoutSettings {
private _parent: TimeoutSettings | undefined;
private _defaultTimeout: number | undefined;
@@ -43,7 +50,19 @@ export class TimeoutSettings {
return this._defaultTimeout;
}
- navigationTimeout(options: { timeout?: number }): number {
+ navigationTimeout(options: TimeoutInput): channels.TimeoutOptions {
+ return { signal: options.signal, timeout: this._navigationTimeout(options) };
+ }
+
+ timeout(options: TimeoutInput): channels.TimeoutOptions {
+ return { signal: options.signal, timeout: this._timeout(options) };
+ }
+
+ launchTimeout(options: TimeoutInput): channels.TimeoutOptions {
+ return { signal: options.signal, timeout: this._launchTimeout(options) };
+ }
+
+ private _navigationTimeout(options: { timeout?: number }): number {
if (typeof options.timeout === 'number')
return options.timeout;
if (this._defaultNavigationTimeout !== undefined)
@@ -53,11 +72,11 @@ export class TimeoutSettings {
if (this._defaultTimeout !== undefined)
return this._defaultTimeout;
if (this._parent)
- return this._parent.navigationTimeout(options);
+ return this._parent._navigationTimeout(options);
return DEFAULT_PLAYWRIGHT_TIMEOUT;
}
- timeout(options: { timeout?: number }): number {
+ private _timeout(options: { timeout?: number }): number {
if (typeof options.timeout === 'number')
return options.timeout;
if (debugMode() === 'inspector')
@@ -65,17 +84,17 @@ export class TimeoutSettings {
if (this._defaultTimeout !== undefined)
return this._defaultTimeout;
if (this._parent)
- return this._parent.timeout(options);
+ return this._parent._timeout(options);
return DEFAULT_PLAYWRIGHT_TIMEOUT;
}
- launchTimeout(options: { timeout?: number }): number {
+ private _launchTimeout(options: { timeout?: number }): number {
if (typeof options.timeout === 'number')
return options.timeout;
if (debugMode() === 'inspector')
return 0;
if (this._parent)
- return this._parent.launchTimeout(options);
+ return this._parent._launchTimeout(options);
return DEFAULT_PLAYWRIGHT_LAUNCH_TIMEOUT;
}
}
diff --git a/packages/playwright-core/src/client/tracing.ts b/packages/playwright-core/src/client/tracing.ts
index 5f09f4c778..e093c926d0 100644
--- a/packages/playwright-core/src/client/tracing.ts
+++ b/packages/playwright-core/src/client/tracing.ts
@@ -18,6 +18,7 @@ import { isRegExp, isString } from '@isomorphic/rtti';
import { Artifact } from './artifact';
import { ChannelOwner } from './channelOwner';
import { DisposableStub } from './disposable';
+import { kNoTimeout } from './timeoutSettings';
import type { Page } from './page';
import type * as api from '../../types/types';
@@ -50,15 +51,15 @@ export class Tracing extends ChannelOwner<channels.TracingChannel> implements ap
snapshots: options.snapshots,
screenshots: options.screenshots,
live: options.live,
- }, undefined);
- const { traceName } = await this._channel.tracingStartChunk({ name: options.name, title: options.title }, undefined);
+ }, kNoTimeout);
+ const { traceName } = await this._channel.tracingStartChunk({ name: options.name, title: options.title }, kNoTimeout);
await this._startCollectingStacks(traceName, this._isLive);
});
}
async startChunk(options: { name?: string, title?: string } = {}) {
await this._wrapApiCall(async () => {
- const { traceName } = await this._channel.tracingStartChunk(options, undefined);
+ const { traceName } = await this._channel.tracingStartChunk(options, kNoTimeout);
await this._startCollectingStacks(traceName, this._isLive);
});
}
@@ -66,12 +67,12 @@ export class Tracing extends ChannelOwner<channels.TracingChannel> implements ap
async group(name: string, options: { location?: { file: string, line?: number, column?: number } } = {}) {
if (options.location)
this._additionalSources.add(options.location.file);
- await this._channel.tracingGroup({ name, location: options.location }, undefined);
+ await this._channel.tracingGroup({ name, location: options.location }, kNoTimeout);
return new DisposableStub(() => this.groupEnd());
}
async groupEnd() {
- await this._channel.tracingGroupEnd({}, undefined);
+ await this._channel.tracingGroupEnd({}, kNoTimeout);
}
private async _startCollectingStacks(traceName: string, live: boolean) {
@@ -92,7 +93,7 @@ export class Tracing extends ChannelOwner<channels.TracingChannel> implements ap
async stop(options: { path?: string } = {}) {
await this._wrapApiCall(async () => {
await this._doStopChunk(options.path);
- await this._channel.tracingStop({}, undefined);
+ await this._channel.tracingStop({}, kNoTimeout);
});
}
@@ -136,7 +137,7 @@ export class Tracing extends ChannelOwner<channels.TracingChannel> implements ap
harPath: isZip ? undefined : har,
resourcesDir: options.resourcesDir,
},
- }, undefined);
+ }, kNoTimeout);
this._harRecorders.set(harId, { path: har, resourcesDir: options.resourcesDir });
return harId;
}
@@ -150,7 +151,7 @@ export class Tracing extends ChannelOwner<channels.TracingChannel> implements ap
const isZip = harParams.path.endsWith('.zip');
if (isLocal) {
- const { entries } = await this._channel.harExport({ harId, mode: 'entries' }, undefined);
+ const { entries } = await this._channel.harExport({ harId, mode: 'entries' }, kNoTimeout);
if (!isZip) {
// Server wrote HAR and resources to the user's chosen paths.
return;
@@ -162,7 +163,7 @@ export class Tracing extends ChannelOwner<channels.TracingChannel> implements ap
return;
}
- const { artifact: artifactChannel } = await this._channel.harExport({ harId, mode: 'archive' }, undefined);
+ const { artifact: artifactChannel } = await this._channel.harExport({ harId, mode: 'archive' }, kNoTimeout);
const artifact = Artifact.from(artifactChannel!);
if (isZip) {
await artifact.saveAs(harParams.path);
@@ -191,7 +192,7 @@ export class Tracing extends ChannelOwner<channels.TracingChannel> implements ap
if (!filePath) {
// Not interested in artifacts.
- await this._channel.tracingStopChunk({ mode: 'discard' }, undefined);
+ await this._channel.tracingStopChunk({ mode: 'discard' }, kNoTimeout);
if (this._stacksId)
await this._connection.localUtils()!.traceDiscarded({ stacksId: this._stacksId });
return;
@@ -204,12 +205,12 @@ export class Tracing extends ChannelOwner<channels.TracingChannel> implements ap
const isLocal = !this._connection.isRemote();
if (isLocal) {
- const result = await this._channel.tracingStopChunk({ mode: 'entries' }, undefined);
+ const result = await this._channel.tracingStopChunk({ mode: 'entries' }, kNoTimeout);
await localUtils.zip({ zipFile: filePath, entries: result.entries!, mode: 'write', stacksId: this._stacksId, includeSources: this._includeSources, additionalSources });
return;
}
- const result = await this._channel.tracingStopChunk({ mode: 'archive' }, undefined);
+ const result = await this._channel.tracingStopChunk({ mode: 'archive' }, kNoTimeout);
// The artifact may be missing if the browser closed while stopping tracing.
if (!result.artifact) {
diff --git a/packages/playwright-core/src/client/types.ts b/packages/playwright-core/src/client/types.ts
index 7dadd12574..dfa07bc012 100644
--- a/packages/playwright-core/src/client/types.ts
+++ b/packages/playwright-core/src/client/types.ts
@@ -147,4 +147,4 @@ export type AnnotateOptions = { duration?: number, position?: AnnotatePosition,
export type RemoteAddr = channels.RemoteAddr;
export type SecurityDetails = channels.SecurityDetails;
-export type FrameExpectParams = Omit<channels.FrameExpectParams, 'selector'|'expression'|'expectedValue'> & { expectedValue?: any };
+export type FrameExpectParams = Omit<channels.FrameExpectParams, 'selector'|'expression'|'expectedValue'> & { expectedValue?: any, timeout: number };
diff --git a/packages/playwright-core/src/client/waiter.ts b/packages/playwright-core/src/client/waiter.ts
index 9d08ccdf43..a20ae8dc61 100644
--- a/packages/playwright-core/src/client/waiter.ts
+++ b/packages/playwright-core/src/client/waiter.ts
@@ -55,7 +55,7 @@ export class Waiter {
const owner = this._channelOwner;
owner._wrapApiCall(async apiZone => {
if (apiZone.internal || apiZone.reported) {
- void owner._connection.sendMessageToServer(owner, '__waitInfo__', info, { internal: true });
+ void owner._connection.sendMessageToServer(owner, '__waitInfo__', info, { internal: true, timeout: 0 });
return;
}
apiZone.reported = true;
@@ -66,7 +66,7 @@ export class Waiter {
if (!apiZone.title)
apiZone.title = options.title;
owner._instrumentation.onApiCallBegin(apiZone, { type: owner._type, method: '__waitInfo__', params: info });
- void owner._connection.sendMessageToServer(owner, '__waitInfo__', info, apiZone);
+ void owner._connection.sendMessageToServer(owner, '__waitInfo__', info, { ...apiZone, timeout: 0 });
}, options).catch(() => {});
}
diff --git a/packages/playwright-core/src/client/webStorage.ts b/packages/playwright-core/src/client/webStorage.ts
index 9a1840276f..240bd3ef56 100644
--- a/packages/playwright-core/src/client/webStorage.ts
+++ b/packages/playwright-core/src/client/webStorage.ts
@@ -14,6 +14,7 @@
* limitations under the License.
*/
+import { kNoTimeout } from './timeoutSettings';
import type { Page } from './page';
import type * as api from '../../types/types';
@@ -27,24 +28,24 @@ export class WebStorage implements api.WebStorage {
}
async items(): Promise<Array<{ name: string, value: string }>> {
- const { items } = await this._page._channel.webStorageItems({ kind: this._kind }, undefined);
+ const { items } = await this._page._channel.webStorageItems({ kind: this._kind }, kNoTimeout);
return items;
}
async getItem(name: string): Promise<string | null> {
- const { value } = await this._page._channel.webStorageGetItem({ kind: this._kind, name }, undefined);
+ const { value } = await this._page._channel.webStorageGetItem({ kind: this._kind, name }, kNoTimeout);
return value ?? null;
}
async setItem(name: string, value: string): Promise<void> {
- await this._page._channel.webStorageSetItem({ kind: this._kind, name, value }, undefined);
+ await this._page._channel.webStorageSetItem({ kind: this._kind, name, value }, kNoTimeout);
}
async removeItem(name: string): Promise<void> {
- await this._page._channel.webStorageRemoveItem({ kind: this._kind, name }, undefined);
+ await this._page._channel.webStorageRemoveItem({ kind: this._kind, name }, kNoTimeout);
}
async clear(): Promise<void> {
- await this._page._channel.webStorageClear({ kind: this._kind }, undefined);
+ await this._page._channel.webStorageClear({ kind: this._kind }, kNoTimeout);
}
}
diff --git a/packages/playwright-core/src/client/worker.ts b/packages/playwright-core/src/client/worker.ts
index 1279c2256b..5b193d6c5b 100644
--- a/packages/playwright-core/src/client/worker.ts
+++ b/packages/playwright-core/src/client/worker.ts
@@ -20,7 +20,7 @@ import { ConsoleMessage } from './consoleMessage';
import { isTargetClosedError, TargetClosedError } from './errors';
import { Events } from './events';
import { JSHandle, assertMaxArguments, parseResult, serializeArgument } from './jsHandle';
-import { TimeoutSettings } from './timeoutSettings';
+import { TimeoutSettings, kNoTimeout } from './timeoutSettings';
import { Waiter } from './waiter';
import type { BrowserContext } from './browserContext';
@@ -28,7 +28,7 @@ import type { Page } from './page';
import type * as structs from '../../types/structs';
import type * as api from '../../types/types';
import type * as channels from './channels';
-import type { TimeoutOptions, WaitForEventOptions } from './types';
+import type { WaitForEventOptions } from './types';
export class Worker extends ChannelOwner<channels.WorkerChannel> implements api.Worker {
@@ -76,22 +76,21 @@ export class Worker extends ChannelOwner<channels.WorkerChannel> implements api.
async evaluate<R, Arg>(pageFunction: structs.PageFunction<Arg, R>, arg?: Arg): Promise<R> {
assertMaxArguments(arguments.length, 2);
- const result = await this._channel.evaluateExpression({ expression: String(pageFunction), isFunction: typeof pageFunction === 'function', arg: serializeArgument(arg) }, undefined);
+ const result = await this._channel.evaluateExpression({ expression: String(pageFunction), isFunction: typeof pageFunction === 'function', arg: serializeArgument(arg) }, kNoTimeout);
return parseResult(result.value);
}
async evaluateHandle<R, Arg>(pageFunction: structs.PageFunction<Arg, R>, arg?: Arg): Promise<structs.SmartHandle<R>> {
assertMaxArguments(arguments.length, 2);
- const result = await this._channel.evaluateExpressionHandle({ expression: String(pageFunction), isFunction: typeof pageFunction === 'function', arg: serializeArgument(arg) }, undefined);
+ const result = await this._channel.evaluateExpressionHandle({ expression: String(pageFunction), isFunction: typeof pageFunction === 'function', arg: serializeArgument(arg) }, kNoTimeout);
return JSHandle.from(result.handle) as any as structs.SmartHandle<R>;
}
async waitForEvent(event: string, optionsOrPredicate: WaitForEventOptions = {}): Promise<any> {
return await this._wrapApiCall(async () => {
const timeoutSettings = this._page?._timeoutSettings ?? this._context?._timeoutSettings ?? new TimeoutSettings();
- const timeout = timeoutSettings.timeout(typeof optionsOrPredicate === 'function' ? {} : optionsOrPredicate);
+ const { timeout, signal } = timeoutSettings.timeout(typeof optionsOrPredicate === 'function' ? {} : optionsOrPredicate);
const predicate = typeof optionsOrPredicate === 'function' ? optionsOrPredicate : optionsOrPredicate.predicate;
- const signal = typeof optionsOrPredicate === 'function' ? undefined : (optionsOrPredicate as TimeoutOptions).signal;
const waiter = Waiter.createForEvent(this, event);
waiter.rejectOnTimeout(timeout, `Timeout ${timeout}ms exceeded while waiting for event "${event}"`);
waiter.rejectOnSignal(signal);
@@ -106,7 +105,7 @@ export class Worker extends ChannelOwner<channels.WorkerChannel> implements api.
async _disconnect(options: { reason?: string } = {}): Promise<void> {
this._closeReason = options.reason;
try {
- await this._channel.disconnect(options, undefined);
+ await this._channel.disconnect(options, kNoTimeout);
} catch (e) {
if (isTargetClosedError(e))
return;
diff --git a/packages/playwright-core/src/client/writableStream.ts b/packages/playwright-core/src/client/writableStream.ts
index 5a128eef0c..f29aa9aa83 100644
--- a/packages/playwright-core/src/client/writableStream.ts
+++ b/packages/playwright-core/src/client/writableStream.ts
@@ -17,6 +17,7 @@
import { Writable } from 'stream';
import { ChannelOwner } from './channelOwner';
+import { kNoTimeout } from './timeoutSettings';
import type * as channels from './channels';
@@ -43,13 +44,13 @@ class WritableStreamImpl extends Writable {
}
override async _write(chunk: Buffer | string, encoding: BufferEncoding, callback: (error?: Error | null) => void) {
- const error = await this._channel.write({ binary: typeof chunk === 'string' ? Buffer.from(chunk) : chunk }, undefined).catch(e => e);
+ const error = await this._channel.write({ binary: typeof chunk === 'string' ? Buffer.from(chunk) : chunk }, kNoTimeout).catch(e => e);
callback(error || null);
}
override async _final(callback: (error?: Error | null) => void) {
// Stream might be destroyed after the connection was closed.
- const error = await this._channel.close({}, undefined).catch(e => e);
+ const error = await this._channel.close({}, kNoTimeout).catch(e => e);
callback(error || null);
}
}
diff --git a/packages/playwright-core/src/server/channels.d.ts b/packages/playwright-core/src/server/channels.d.ts
index 9d55ce6535..62c59f0116 100644
--- a/packages/playwright-core/src/server/channels.d.ts
+++ b/packages/playwright-core/src/server/channels.d.ts
@@ -238,7 +238,6 @@ export type AndroidDeviceWebViewRemovedEvent = {
export type AndroidDeviceWaitParams = {
androidSelector: AndroidSelector,
state?: 'gone',
- timeout: number,
};
export type AndroidDeviceWaitOptions = {
state?: 'gone',
@@ -247,7 +246,6 @@ export type AndroidDeviceWaitResult = void;
export type AndroidDeviceFillParams = {
androidSelector: AndroidSelector,
text: string,
- timeout: number,
};
export type AndroidDeviceFillOptions = {
@@ -256,7 +254,6 @@ export type AndroidDeviceFillResult = void;
export type AndroidDeviceTapParams = {
androidSelector: AndroidSelector,
duration?: number,
- timeout: number,
};
export type AndroidDeviceTapOptions = {
duration?: number,
@@ -266,7 +263,6 @@ export type AndroidDeviceDragParams = {
androidSelector: AndroidSelector,
dest: Point,
speed?: number,
- timeout: number,
};
export type AndroidDeviceDragOptions = {
speed?: number,
@@ -276,7 +272,6 @@ export type AndroidDeviceFlingParams = {
androidSelector: AndroidSelector,
direction: 'up' | 'down' | 'left' | 'right',
speed?: number,
- timeout: number,
};
export type AndroidDeviceFlingOptions = {
speed?: number,
@@ -284,7 +279,6 @@ export type AndroidDeviceFlingOptions = {
export type AndroidDeviceFlingResult = void;
export type AndroidDeviceLongTapParams = {
androidSelector: AndroidSelector,
- timeout: number,
};
export type AndroidDeviceLongTapOptions = {
@@ -294,7 +288,6 @@ export type AndroidDevicePinchCloseParams = {
androidSelector: AndroidSelector,
percent: number,
speed?: number,
- timeout: number,
};
export type AndroidDevicePinchCloseOptions = {
speed?: number,
@@ -304,7 +297,6 @@ export type AndroidDevicePinchOpenParams = {
androidSelector: AndroidSelector,
percent: number,
speed?: number,
- timeout: number,
};
export type AndroidDevicePinchOpenOptions = {
speed?: number,
@@ -315,7 +307,6 @@ export type AndroidDeviceScrollParams = {
direction: 'up' | 'down' | 'left' | 'right',
percent: number,
speed?: number,
- timeout: number,
};
export type AndroidDeviceScrollOptions = {
speed?: number,
@@ -326,7 +317,6 @@ export type AndroidDeviceSwipeParams = {
direction: 'up' | 'down' | 'left' | 'right',
percent: number,
speed?: number,
- timeout: number,
};
export type AndroidDeviceSwipeOptions = {
speed?: number,
@@ -610,7 +600,6 @@ export type APIRequestContextFetchParams = {
jsonData?: string,
formData?: NameValue[],
multipartData?: FormField[],
- timeout: number,
failOnStatusCode?: boolean,
ignoreHTTPSErrors?: boolean,
maxRedirects?: number,
@@ -1795,7 +1784,6 @@ export type BrowserTypeLaunchParams = {
handleSIGINT?: boolean,
handleSIGTERM?: boolean,
handleSIGHUP?: boolean,
- timeout: number,
env?: NameValue[],
headless?: boolean,
proxy?: {
@@ -1849,7 +1837,6 @@ export type BrowserTypeLaunchPersistentContextParams = {
handleSIGINT?: boolean,
handleSIGTERM?: boolean,
handleSIGHUP?: boolean,
- timeout: number,
env?: NameValue[],
headless?: boolean,
proxy?: {
@@ -2024,7 +2011,6 @@ export type BrowserTypeConnectOverCDPParams = {
endpointURL?: string,
headers?: NameValue[],
slowMo?: number,
- timeout: number,
isLocal?: boolean,
noDefaults?: boolean,
artifactsDir?: string,
@@ -2045,7 +2031,6 @@ export type BrowserTypeConnectOverCDPResult = {
};
export type BrowserTypeConnectToWorkerParams = {
endpoint: string,
- timeout: number,
};
export type BrowserTypeConnectToWorkerOptions = {
@@ -2086,7 +2071,6 @@ export type ElectronLaunchParams = {
chromiumSandbox?: boolean,
cwd?: string,
env?: NameValue[],
- timeout: number,
acceptDownloads?: 'accept' | 'deny' | 'internal-browser-default',
bypassCSP?: boolean,
colorScheme?: 'dark' | 'light' | 'no-preference' | 'no-override',
@@ -2376,7 +2360,6 @@ export type FrameAriaSnapshotParams = {
selector?: string,
depth?: number,
boxes?: boolean,
- timeout: number,
};
export type FrameAriaSnapshotOptions = {
mode?: 'ai' | 'default',
@@ -2390,7 +2373,6 @@ export type FrameAriaSnapshotResult = {
export type FrameBlurParams = {
selector: string,
strict?: boolean,
- timeout: number,
};
export type FrameBlurOptions = {
strict?: boolean,
@@ -2402,7 +2384,6 @@ export type FrameCheckParams = {
force?: boolean,
scroll?: 'auto' | 'none',
position?: Point,
- timeout: number,
trial?: boolean,
};
export type FrameCheckOptions = {
@@ -2424,7 +2405,6 @@ export type FrameClickParams = {
delay?: number,
button?: 'left' | 'right' | 'middle',
clickCount?: number,
- timeout: number,
trial?: boolean,
steps?: number,
};
@@ -2452,7 +2432,6 @@ export type FrameDragAndDropParams = {
target: string,
force?: boolean,
scroll?: 'auto' | 'none',
- timeout: number,
trial?: boolean,
sourcePosition?: Point,
targetPosition?: Point,
@@ -2484,7 +2463,6 @@ export type FrameDropParams = {
mimeType: string,
value: string,
}[],
- timeout: number,
};
export type FrameDropOptions = {
strict?: boolean,
@@ -2511,7 +2489,6 @@ export type FrameDblclickParams = {
position?: Point,
delay?: number,
button?: 'left' | 'right' | 'middle',
- timeout: number,
trial?: boolean,
steps?: number,
};
@@ -2532,7 +2509,6 @@ export type FrameDispatchEventParams = {
strict?: boolean,
type: string,
eventInit: SerializedArgument,
- timeout: number,
};
export type FrameDispatchEventOptions = {
strict?: boolean,
@@ -2565,7 +2541,6 @@ export type FrameFillParams = {
strict?: boolean,
value: string,
force?: boolean,
- timeout: number,
};
export type FrameFillOptions = {
strict?: boolean,
@@ -2575,7 +2550,6 @@ export type FrameFillResult = void;
export type FrameFocusParams = {
selector: string,
strict?: boolean,
- timeout: number,
};
export type FrameFocusOptions = {
strict?: boolean,
@@ -2614,7 +2588,6 @@ export type FrameGetAttributeParams = {
selector: string,
strict?: boolean,
name: string,
- timeout: number,
};
export type FrameGetAttributeOptions = {
strict?: boolean,
@@ -2624,7 +2597,6 @@ export type FrameGetAttributeResult = {
};
export type FrameGotoParams = {
url: string,
- timeout: number,
waitUntil?: LifecycleEvent,
referer?: string,
};
@@ -2642,7 +2614,6 @@ export type FrameHoverParams = {
scroll?: 'auto' | 'none',
modifiers?: ('Alt' | 'Control' | 'ControlOrMeta' | 'Meta' | 'Shift')[],
position?: Point,
- timeout: number,
trial?: boolean,
};
export type FrameHoverOptions = {
@@ -2657,7 +2628,6 @@ export type FrameHoverResult = void;
export type FrameInnerHTMLParams = {
selector: string,
strict?: boolean,
- timeout: number,
};
export type FrameInnerHTMLOptions = {
strict?: boolean,
@@ -2668,7 +2638,6 @@ export type FrameInnerHTMLResult = {
export type FrameInnerTextParams = {
selector: string,
strict?: boolean,
- timeout: number,
};
export type FrameInnerTextOptions = {
strict?: boolean,
@@ -2679,7 +2648,6 @@ export type FrameInnerTextResult = {
export type FrameInputValueParams = {
selector: string,
strict?: boolean,
- timeout: number,
};
export type FrameInputValueOptions = {
strict?: boolean,
@@ -2690,7 +2658,6 @@ export type FrameInputValueResult = {
export type FrameIsCheckedParams = {
selector: string,
strict?: boolean,
- timeout: number,
};
export type FrameIsCheckedOptions = {
strict?: boolean,
@@ -2701,7 +2668,6 @@ export type FrameIsCheckedResult = {
export type FrameIsDisabledParams = {
selector: string,
strict?: boolean,
- timeout: number,
};
export type FrameIsDisabledOptions = {
strict?: boolean,
@@ -2712,7 +2678,6 @@ export type FrameIsDisabledResult = {
export type FrameIsEnabledParams = {
selector: string,
strict?: boolean,
- timeout: number,
};
export type FrameIsEnabledOptions = {
strict?: boolean,
@@ -2743,7 +2708,6 @@ export type FrameIsVisibleResult = {
export type FrameIsEditableParams = {
selector: string,
strict?: boolean,
- timeout: number,
};
export type FrameIsEditableOptions = {
strict?: boolean,
@@ -2757,7 +2721,6 @@ export type FramePressParams = {
key: string,
delay?: number,
noWaitAfter?: boolean,
- timeout: number,
};
export type FramePressOptions = {
strict?: boolean,
@@ -2804,7 +2767,6 @@ export type FrameSelectOptionParams = {
index?: number,
}[],
force?: boolean,
- timeout: number,
};
export type FrameSelectOptionOptions = {
strict?: boolean,
@@ -2822,7 +2784,6 @@ export type FrameSelectOptionResult = {
};
export type FrameSetContentParams = {
html: string,
- timeout: number,
waitUntil?: LifecycleEvent,
};
export type FrameSetContentOptions = {
@@ -2841,7 +2802,6 @@ export type FrameSetInputFilesParams = {
directoryStream?: WritableStreamChannel,
localPaths?: string[],
streams?: WritableStreamChannel[],
- timeout: number,
};
export type FrameSetInputFilesOptions = {
strict?: boolean,
@@ -2863,7 +2823,6 @@ export type FrameTapParams = {
scroll?: 'auto' | 'none',
modifiers?: ('Alt' | 'Control' | 'ControlOrMeta' | 'Meta' | 'Shift')[],
position?: Point,
- timeout: number,
trial?: boolean,
};
export type FrameTapOptions = {
@@ -2878,7 +2837,6 @@ export type FrameTapResult = void;
export type FrameTextContentParams = {
selector: string,
strict?: boolean,
- timeout: number,
};
export type FrameTextContentOptions = {
strict?: boolean,
@@ -2896,7 +2854,6 @@ export type FrameTypeParams = {
strict?: boolean,
text: string,
delay?: number,
- timeout: number,
};
export type FrameTypeOptions = {
strict?: boolean,
@@ -2909,7 +2866,6 @@ export type FrameUncheckParams = {
force?: boolean,
scroll?: 'auto' | 'none',
position?: Point,
- timeout: number,
trial?: boolean,
};
export type FrameUncheckOptions = {
@@ -2931,7 +2887,6 @@ export type FrameWaitForFunctionParams = {
expression: string,
isFunction?: boolean,
arg: SerializedArgument,
- timeout: number,
pollingInterval?: number,
selector?: string,
strict?: boolean,
@@ -2948,7 +2903,6 @@ export type FrameWaitForFunctionResult = {
export type FrameWaitForSelectorParams = {
selector: string,
strict?: boolean,
- timeout: number,
state?: 'attached' | 'detached' | 'visible' | 'hidden',
omitReturnValue?: boolean,
};
@@ -2970,7 +2924,6 @@ export type FrameExpectParams = {
expectedValue?: SerializedArgument,
useInnerText?: boolean,
isNot: boolean,
- timeout: number,
};
export type FrameExpectOptions = {
selector?: string,
@@ -3145,7 +3098,6 @@ export type ElementHandleCheckParams = {
force?: boolean,
scroll?: 'auto' | 'none',
position?: Point,
- timeout: number,
trial?: boolean,
};
export type ElementHandleCheckOptions = {
@@ -3164,7 +3116,6 @@ export type ElementHandleClickParams = {
delay?: number,
button?: 'left' | 'right' | 'middle',
clickCount?: number,
- timeout: number,
trial?: boolean,
steps?: number,
};
@@ -3193,7 +3144,6 @@ export type ElementHandleDblclickParams = {
position?: Point,
delay?: number,
button?: 'left' | 'right' | 'middle',
- timeout: number,
trial?: boolean,
steps?: number,
};
@@ -3219,7 +3169,6 @@ export type ElementHandleDispatchEventResult = void;
export type ElementHandleFillParams = {
value: string,
force?: boolean,
- timeout: number,
};
export type ElementHandleFillOptions = {
force?: boolean,
@@ -3242,7 +3191,6 @@ export type ElementHandleHoverParams = {
scroll?: 'auto' | 'none',
modifiers?: ('Alt' | 'Control' | 'ControlOrMeta' | 'Meta' | 'Shift')[],
position?: Point,
- timeout: number,
trial?: boolean,
};
export type ElementHandleHoverOptions = {
@@ -3306,7 +3254,6 @@ export type ElementHandleOwnerFrameResult = {
export type ElementHandlePressParams = {
key: string,
delay?: number,
- timeout: number,
noWaitAfter?: boolean,
};
export type ElementHandlePressOptions = {
@@ -3334,7 +3281,6 @@ export type ElementHandleQuerySelectorAllResult = {
elements: ElementHandleChannel[],
};
export type ElementHandleScreenshotParams = {
- timeout: number,
type?: 'png' | 'jpeg' | 'webp',
quality?: number,
omitBackground?: boolean,
@@ -3365,12 +3311,8 @@ export type ElementHandleScreenshotOptions = {
export type ElementHandleScreenshotResult = {
binary: Binary,
};
-export type ElementHandleScrollIntoViewIfNeededParams = {
- timeout: number,
-};
-export type ElementHandleScrollIntoViewIfNeededOptions = {
-
-};
+export type ElementHandleScrollIntoViewIfNeededParams = {};
+export type ElementHandleScrollIntoViewIfNeededOptions = {};
export type ElementHandleScrollIntoViewIfNeededResult = void;
export type ElementHandleSelectOptionParams = {
elements?: ElementHandleChannel[],
@@ -3381,7 +3323,6 @@ export type ElementHandleSelectOptionParams = {
index?: number,
}[],
force?: boolean,
- timeout: number,
};
export type ElementHandleSelectOptionOptions = {
elements?: ElementHandleChannel[],
@@ -3398,7 +3339,6 @@ export type ElementHandleSelectOptionResult = {
};
export type ElementHandleSelectTextParams = {
force?: boolean,
- timeout: number,
};
export type ElementHandleSelectTextOptions = {
force?: boolean,
@@ -3414,7 +3354,6 @@ export type ElementHandleSetInputFilesParams = {
directoryStream?: WritableStreamChannel,
localPaths?: string[],
streams?: WritableStreamChannel[],
- timeout: number,
};
export type ElementHandleSetInputFilesOptions = {
payloads?: {
@@ -3433,7 +3372,6 @@ export type ElementHandleTapParams = {
scroll?: 'auto' | 'none',
modifiers?: ('Alt' | 'Control' | 'ControlOrMeta' | 'Meta' | 'Shift')[],
position?: Point,
- timeout: number,
trial?: boolean,
};
export type ElementHandleTapOptions = {
@@ -3452,7 +3390,6 @@ export type ElementHandleTextContentResult = {
export type ElementHandleTypeParams = {
text: string,
delay?: number,
- timeout: number,
};
export type ElementHandleTypeOptions = {
delay?: number,
@@ -3462,7 +3399,6 @@ export type ElementHandleUncheckParams = {
force?: boolean,
scroll?: 'auto' | 'none',
position?: Point,
- timeout: number,
trial?: boolean,
};
export type ElementHandleUncheckOptions = {
@@ -3474,7 +3410,6 @@ export type ElementHandleUncheckOptions = {
export type ElementHandleUncheckResult = void;
export type ElementHandleWaitForElementStateParams = {
state: 'visible' | 'hidden' | 'stable' | 'enabled' | 'disabled' | 'editable',
- timeout: number,
};
export type ElementHandleWaitForElementStateOptions = {
@@ -3483,7 +3418,6 @@ export type ElementHandleWaitForElementStateResult = void;
export type ElementHandleWaitForSelectorParams = {
selector: string,
strict?: boolean,
- timeout: number,
state?: 'attached' | 'detached' | 'visible' | 'hidden',
};
export type ElementHandleWaitForSelectorOptions = {
@@ -3596,7 +3530,6 @@ export type LocalUtilsConnectParams = {
headers?: any,
exposeNetwork?: string,
slowMo?: number,
- timeout: number,
socksProxyRedirectPortForTest?: number,
};
export type LocalUtilsConnectOptions = {
@@ -4124,7 +4057,6 @@ export type PageExposeBindingResult = {
disposable: DisposableChannel,
};
export type PageGoBackParams = {
- timeout: number,
waitUntil?: LifecycleEvent,
};
export type PageGoBackOptions = {
@@ -4134,7 +4066,6 @@ export type PageGoBackResult = {
response?: ResponseChannel,
};
export type PageGoForwardParams = {
- timeout: number,
waitUntil?: LifecycleEvent,
};
export type PageGoForwardOptions = {
@@ -4172,7 +4103,6 @@ export type PageUnregisterLocatorHandlerOptions = {
};
export type PageUnregisterLocatorHandlerResult = void;
export type PageReloadParams = {
- timeout: number,
waitUntil?: LifecycleEvent,
};
export type PageReloadOptions = {
@@ -4183,7 +4113,6 @@ export type PageReloadResult = {
};
export type PageExpectScreenshotParams = {
expected?: Binary,
- timeout: number,
isNot: boolean,
locator?: {
frame: FrameChannel,
@@ -4243,7 +4172,6 @@ export type PageExpectScreenshotErrorDetails = {
log?: string[],
};
export type PageScreenshotParams = {
- timeout: number,
type?: 'png' | 'jpeg' | 'webp',
quality?: number,
fullPage?: boolean,
diff --git a/packages/playwright-core/src/server/dispatchers/dispatcher.ts b/packages/playwright-core/src/server/dispatchers/dispatcher.ts
index 3bb60565fa..9215be6d89 100644
--- a/packages/playwright-core/src/server/dispatchers/dispatcher.ts
+++ b/packages/playwright-core/src/server/dispatchers/dispatcher.ts
@@ -358,6 +358,11 @@ export class DispatcherConnection {
params: params || {},
log: [],
};
+
+ // TODO(skn0tt): promote to top-level metadata instead of smuggling through params.
+ if (validMetadata.timeout)
+ callMetadata.params = { ...callMetadata.params, timeout: validMetadata.timeout };
+
const controller = dispatcher.createProgressController(callMetadata);
this._activeProgressControllers.set(callMetadata.id, controller);
@@ -367,7 +372,7 @@ export class DispatcherConnection {
// If the dispatcher has been disposed while running the instrumentation call, error out.
if (this._dispatcherByGuid.get(guid) !== dispatcher)
throw new TargetClosedError(sdkObject.closeReason());
- const result = await controller.run(progress => (dispatcher as any)[method](validParams, progress), validParams?.timeout);
+ const result = await controller.run(progress => (dispatcher as any)[method](validParams, progress), validMetadata.timeout);
const validator = findValidator(dispatcher._type, method, 'Result');
response.result = validator(result, '', this._validatorToWireContext());
callMetadata.result = result;
diff --git a/packages/playwright-core/src/server/dispatchers/frameDispatcher.ts b/packages/playwright-core/src/server/dispatchers/frameDispatcher.ts
index 12aea64c8e..67593bde88 100644
--- a/packages/playwright-core/src/server/dispatchers/frameDispatcher.ts
+++ b/packages/playwright-core/src/server/dispatchers/frameDispatcher.ts
@@ -276,7 +276,7 @@ export class FrameDispatcher extends Dispatcher<Frame, channels.FrameChannel, Br
}
async expect(params: channels.FrameExpectParams, progress: Progress): Promise<channels.FrameExpectResult> {
- progress.log(`${renderTitleForCall(progress.metadata)}${params.timeout ? ` with timeout ${params.timeout}ms` : ''}`);
+ progress.log(`${renderTitleForCall(progress.metadata)}${progress.timeout ? ` with timeout ${progress.timeout}ms` : ''}`);
const expectedValue = params.expectedValue ? parseArgument(params.expectedValue) : undefined;
try {
await this._frame.expect(progress, params.selector, { ...params, expectedValue });
diff --git a/packages/playwright-core/src/server/dispatchers/pageDispatcher.ts b/packages/playwright-core/src/server/dispatchers/pageDispatcher.ts
index 55f51723d2..b9e4ba8750 100644
--- a/packages/playwright-core/src/server/dispatchers/pageDispatcher.ts
+++ b/packages/playwright-core/src/server/dispatchers/pageDispatcher.ts
@@ -233,7 +233,7 @@ export class PageDispatcher extends Dispatcher<Page, channels.PageChannel, Brows
frame: (params.locator.frame as FrameDispatcher)._object,
selector: params.locator.selector,
} : undefined;
- progress.log(`${renderTitleForCall(progress.metadata)}${params.timeout ? ` with timeout ${params.timeout}ms` : ''}`);
+ progress.log(`${renderTitleForCall(progress.metadata)}${progress.timeout ? ` with timeout ${progress.timeout}ms` : ''}`);
return await this._page.expectScreenshot(progress, {
...params,
locator,
diff --git a/packages/playwright-core/src/server/page.ts b/packages/playwright-core/src/server/page.ts
index 70c512667d..e2b72ef2fc 100644
--- a/packages/playwright-core/src/server/page.ts
+++ b/packages/playwright-core/src/server/page.ts
@@ -120,7 +120,6 @@ type EmulatedMedia = {
};
type ExpectScreenshotOptions = ImageComparatorOptions & ScreenshotOptions & {
- timeout: number,
expected?: Buffer,
isNot?: boolean,
locator?: {
diff --git a/packages/playwright-core/src/server/socksInterceptor.ts b/packages/playwright-core/src/server/socksInterceptor.ts
index d964068c50..dc9e5eacc0 100644
--- a/packages/playwright-core/src/server/socksInterceptor.ts
+++ b/packages/playwright-core/src/server/socksInterceptor.ts
@@ -44,17 +44,17 @@ export class SocksInterceptor {
this._ids.add(id);
const validator = findValidator('SocksSupport', prop, 'Params');
params = validator(params, '', { tChannelImpl: tChannelForSocks, binary: 'toBase64', isUnderTest });
- transport.send({ id, guid: this._socksSupportObjectGuid, method: prop, params, metadata: { stack: [], apiName: '', internal: true } } as any);
+ transport.send({ id, guid: this._socksSupportObjectGuid, method: prop, params, metadata: { stack: [], apiName: '', internal: true, timeout: 0 } } as any);
} catch (e) {
}
};
},
}) as channels.SocksSupportChannel & EventEmitter;
- this._handler.on(socks.SocksProxyHandler.Events.SocksConnected, (payload: socks.SocksSocketConnectedPayload) => this._channel.socksConnected(payload, undefined));
- this._handler.on(socks.SocksProxyHandler.Events.SocksData, (payload: socks.SocksSocketDataPayload) => this._channel.socksData(payload, undefined));
- this._handler.on(socks.SocksProxyHandler.Events.SocksError, (payload: socks.SocksSocketErrorPayload) => this._channel.socksError(payload, undefined));
- this._handler.on(socks.SocksProxyHandler.Events.SocksFailed, (payload: socks.SocksSocketFailedPayload) => this._channel.socksFailed(payload, undefined));
- this._handler.on(socks.SocksProxyHandler.Events.SocksEnd, (payload: socks.SocksSocketEndPayload) => this._channel.socksEnd(payload, undefined));
+ this._handler.on(socks.SocksProxyHandler.Events.SocksConnected, (payload: socks.SocksSocketConnectedPayload) => this._channel.socksConnected(payload, { signal: undefined, timeout: 0 }));
+ this._handler.on(socks.SocksProxyHandler.Events.SocksData, (payload: socks.SocksSocketDataPayload) => this._channel.socksData(payload, { signal: undefined, timeout: 0 }));
+ this._handler.on(socks.SocksProxyHandler.Events.SocksError, (payload: socks.SocksSocketErrorPayload) => this._channel.socksError(payload, { signal: undefined, timeout: 0 }));
+ this._handler.on(socks.SocksProxyHandler.Events.SocksFailed, (payload: socks.SocksSocketFailedPayload) => this._channel.socksFailed(payload, { signal: undefined, timeout: 0 }));
+ this._handler.on(socks.SocksProxyHandler.Events.SocksEnd, (payload: socks.SocksSocketEndPayload) => this._channel.socksEnd(payload, { signal: undefined, timeout: 0 }));
this._channel.on('socksRequested', payload => this._handler.socketRequested(payload));
this._channel.on('socksClosed', payload => this._handler.socketClosed(payload));
this._channel.on('socksData', payload => this._handler.sendSocketData(payload));
diff --git a/packages/protocol/spec/android.yml b/packages/protocol/spec/android.yml
index 5c627b675d..7d5c498c90 100644
--- a/packages/protocol/spec/android.yml
+++ b/packages/protocol/spec/android.yml
@@ -62,21 +62,18 @@ AndroidDevice:
type: enum?
literals:
- gone
- timeout: float
fill:
title: Fill "{text}"
parameters:
androidSelector: AndroidSelector
text: string
- timeout: float
tap:
title: Tap
parameters:
androidSelector: AndroidSelector
duration: float?
- timeout: float
drag:
title: Drag
@@ -84,7 +81,6 @@ AndroidDevice:
androidSelector: AndroidSelector
dest: Point
speed: float?
- timeout: float
fling:
title: Fling
@@ -98,13 +94,11 @@ AndroidDevice:
- left
- right
speed: float?
- timeout: float
longTap:
title: Long tap
parameters:
androidSelector: AndroidSelector
- timeout: float
pinchClose:
title: Pinch close
@@ -112,7 +106,6 @@ AndroidDevice:
androidSelector: AndroidSelector
percent: float
speed: float?
- timeout: float
pinchOpen:
title: Pinch open
@@ -120,7 +113,6 @@ AndroidDevice:
androidSelector: AndroidSelector
percent: float
speed: float?
- timeout: float
scroll:
title: Scroll
@@ -135,7 +127,6 @@ AndroidDevice:
- right
percent: float
speed: float?
- timeout: float
swipe:
title: Swipe
@@ -150,7 +141,6 @@ AndroidDevice:
- right
percent: float
speed: float?
- timeout: float
info:
internal: true
diff --git a/packages/protocol/spec/api.yml b/packages/protocol/spec/api.yml
index 6e8ff2281d..e975594a6a 100644
--- a/packages/protocol/spec/api.yml
+++ b/packages/protocol/spec/api.yml
@@ -40,7 +40,6 @@ APIRequestContext:
multipartData:
type: array?
items: FormField
- timeout: float
failOnStatusCode: boolean?
ignoreHTTPSErrors: boolean?
maxRedirects: int?
diff --git a/packages/protocol/spec/browserType.yml b/packages/protocol/spec/browserType.yml
index 7c4247a884..a50d1d2001 100644
--- a/packages/protocol/spec/browserType.yml
+++ b/packages/protocol/spec/browserType.yml
@@ -48,7 +48,6 @@ BrowserType:
type: array?
items: NameValue
slowMo: float?
- timeout: float
isLocal: boolean?
noDefaults: boolean?
artifactsDir: string?
@@ -61,6 +60,5 @@ BrowserType:
title: Connect to worker
parameters:
endpoint: string
- timeout: float
returns:
worker: Worker
diff --git a/packages/protocol/spec/core.yml b/packages/protocol/spec/core.yml
index b97078ea76..f29b82f56d 100644
--- a/packages/protocol/spec/core.yml
+++ b/packages/protocol/spec/core.yml
@@ -25,6 +25,7 @@ Metadata:
internal: boolean?
# Test runner step id.
stepId: string?
+ timeout: float?
ClientSideCallMetadata:
type: object
diff --git a/packages/protocol/spec/electron.yml b/packages/protocol/spec/electron.yml
index c25b36becc..877b407746 100644
--- a/packages/protocol/spec/electron.yml
+++ b/packages/protocol/spec/electron.yml
@@ -28,7 +28,6 @@ Electron:
env:
type: array?
items: NameValue
- timeout: float
acceptDownloads:
type: enum?
literals:
diff --git a/packages/protocol/spec/frame.yml b/packages/protocol/spec/frame.yml
index 849ba14302..421530f52a 100644
--- a/packages/protocol/spec/frame.yml
+++ b/packages/protocol/spec/frame.yml
@@ -87,7 +87,6 @@ Frame:
selector: string?
depth: int?
boxes: boolean?
- timeout: float
returns:
snapshot: string
@@ -96,7 +95,6 @@ Frame:
parameters:
selector: string
strict: boolean?
- timeout: float
flags:
slowMo: true
snapshot: true
@@ -114,7 +112,6 @@ Frame:
- auto
- none
position: Point?
- timeout: float
trial: boolean?
flags:
slowMo: true
@@ -154,7 +151,6 @@ Frame:
- right
- middle
clickCount: int?
- timeout: float
trial: boolean?
steps: int?
flags:
@@ -183,7 +179,6 @@ Frame:
literals:
- auto
- none
- timeout: float
trial: boolean?
sourcePosition: Point?
targetPosition: Point?
@@ -224,7 +219,6 @@ Frame:
properties:
mimeType: string
value: string
- timeout: float
flags:
slowMo: true
snapshot: true
@@ -261,7 +255,6 @@ Frame:
- left
- right
- middle
- timeout: float
trial: boolean?
steps: int?
flags:
@@ -278,7 +271,6 @@ Frame:
strict: boolean?
type: string
eventInit: SerializedArgument
- timeout: float
flags:
slowMo: true
snapshot: true
@@ -315,7 +307,6 @@ Frame:
strict: boolean?
value: string
force: boolean?
- timeout: float
flags:
slowMo: true
snapshot: true
@@ -328,7 +319,6 @@ Frame:
parameters:
selector: string
strict: boolean?
- timeout: float
flags:
slowMo: true
snapshot: true
@@ -365,7 +355,6 @@ Frame:
selector: string
strict: boolean?
name: string
- timeout: float
returns:
value: string?
flags:
@@ -376,7 +365,6 @@ Frame:
title: Navigate to "{url}"
parameters:
url: string
- timeout: float
waitUntil: LifecycleEvent?
referer: string?
returns:
@@ -408,7 +396,6 @@ Frame:
- Meta
- Shift
position: Point?
- timeout: float
trial: boolean?
flags:
slowMo: true
@@ -423,7 +410,6 @@ Frame:
parameters:
selector: string
strict: boolean?
- timeout: float
returns:
value: string
flags:
@@ -436,7 +422,6 @@ Frame:
parameters:
selector: string
strict: boolean?
- timeout: float
returns:
value: string
flags:
@@ -449,7 +434,6 @@ Frame:
parameters:
selector: string
strict: boolean?
- timeout: float
returns:
value: string
flags:
@@ -462,7 +446,6 @@ Frame:
parameters:
selector: string
strict: boolean?
- timeout: float
returns:
value: boolean
flags:
@@ -475,7 +458,6 @@ Frame:
parameters:
selector: string
strict: boolean?
- timeout: float
returns:
value: boolean
flags:
@@ -488,7 +470,6 @@ Frame:
parameters:
selector: string
strict: boolean?
- timeout: float
returns:
value: boolean
flags:
@@ -527,7 +508,6 @@ Frame:
parameters:
selector: string
strict: boolean?
- timeout: float
returns:
value: boolean
flags:
@@ -542,7 +522,6 @@ Frame:
key: string
delay: float?
noWaitAfter: boolean?
- timeout: float
flags:
slowMo: true
snapshot: true
@@ -599,7 +578,6 @@ Frame:
label: string?
index: int?
force: boolean?
- timeout: float
returns:
values:
type: array
@@ -615,7 +593,6 @@ Frame:
title: Set content
parameters:
html: string
- timeout: float
waitUntil: LifecycleEvent?
flags:
snapshot: true
@@ -643,7 +620,6 @@ Frame:
streams:
type: array?
items: WritableStream
- timeout: float
flags:
slowMo: true
snapshot: true
@@ -673,7 +649,6 @@ Frame:
- Meta
- Shift
position: Point?
- timeout: float
trial: boolean?
flags:
slowMo: true
@@ -688,7 +663,6 @@ Frame:
parameters:
selector: string
strict: boolean?
- timeout: float
returns:
value: string?
flags:
@@ -708,7 +682,6 @@ Frame:
strict: boolean?
text: string
delay: float?
- timeout: float
flags:
slowMo: true
snapshot: true
@@ -728,7 +701,6 @@ Frame:
- auto
- none
position: Point?
- timeout: float
trial: boolean?
flags:
slowMo: true
@@ -750,7 +722,6 @@ Frame:
expression: string
isFunction: boolean?
arg: SerializedArgument
- timeout: float
# When present, polls on interval. Otherwise, polls on raf.
pollingInterval: float?
# When present, first argument is the matched element.
@@ -768,7 +739,6 @@ Frame:
parameters:
selector: string
strict: boolean?
- timeout: float
state:
type: enum?
literals:
@@ -800,7 +770,6 @@ Frame:
expectedValue: SerializedArgument?
useInnerText: boolean?
isNot: boolean
- timeout: float
errorDetails:
received:
type: object?
diff --git a/packages/protocol/spec/handles.yml b/packages/protocol/spec/handles.yml
index 8818c936d1..fb38ee8a18 100644
--- a/packages/protocol/spec/handles.yml
+++ b/packages/protocol/spec/handles.yml
@@ -131,7 +131,6 @@ ElementHandle:
- auto
- none
position: Point?
- timeout: float
trial: boolean?
flags:
slowMo: true
@@ -169,7 +168,6 @@ ElementHandle:
- right
- middle
clickCount: int?
- timeout: float
trial: boolean?
steps: int?
flags:
@@ -212,7 +210,6 @@ ElementHandle:
- left
- right
- middle
- timeout: float
trial: boolean?
steps: int?
flags:
@@ -237,7 +234,6 @@ ElementHandle:
parameters:
value: string
force: boolean?
- timeout: float
flags:
slowMo: true
snapshot: true
@@ -283,7 +279,6 @@ ElementHandle:
- Meta
- Shift
position: Point?
- timeout: float
trial: boolean?
flags:
slowMo: true
@@ -384,7 +379,6 @@ ElementHandle:
parameters:
key: string
delay: float?
- timeout: float
noWaitAfter: boolean?
flags:
slowMo: true
@@ -417,7 +411,6 @@ ElementHandle:
screenshot:
title: Screenshot
parameters:
- timeout: float
type:
type: enum?
literals:
@@ -434,8 +427,6 @@ ElementHandle:
scrollIntoViewIfNeeded:
title: Scroll into view
- parameters:
- timeout: float
flags:
slowMo: true
snapshot: true
@@ -457,7 +448,6 @@ ElementHandle:
label: string?
index: int?
force: boolean?
- timeout: float
returns:
values:
type: array
@@ -473,7 +463,6 @@ ElementHandle:
title: Select text
parameters:
force: boolean?
- timeout: float
flags:
slowMo: true
snapshot: true
@@ -499,7 +488,6 @@ ElementHandle:
streams:
type: array?
items: WritableStream
- timeout: float
flags:
slowMo: true
snapshot: true
@@ -527,7 +515,6 @@ ElementHandle:
- Meta
- Shift
position: Point?
- timeout: float
trial: boolean?
flags:
slowMo: true
@@ -550,7 +537,6 @@ ElementHandle:
parameters:
text: string
delay: float?
- timeout: float
flags:
slowMo: true
snapshot: true
@@ -568,7 +554,6 @@ ElementHandle:
- auto
- none
position: Point?
- timeout: float
trial: boolean?
flags:
slowMo: true
@@ -589,7 +574,6 @@ ElementHandle:
- enabled
- disabled
- editable
- timeout: float
flags:
snapshot: true
pause: true
@@ -599,7 +583,6 @@ ElementHandle:
parameters:
selector: string
strict: boolean?
- timeout: float
state:
type: enum?
literals:
diff --git a/packages/protocol/spec/localUtils.yml b/packages/protocol/spec/localUtils.yml
index 4381f8319d..6d5eb8a8a4 100644
--- a/packages/protocol/spec/localUtils.yml
+++ b/packages/protocol/spec/localUtils.yml
@@ -120,7 +120,6 @@ LocalUtils:
headers: json?
exposeNetwork: string?
slowMo: float?
- timeout: float
socksProxyRedirectPortForTest: int?
returns:
pipe: JsonPipe
diff --git a/packages/protocol/spec/mixins.yml b/packages/protocol/spec/mixins.yml
index c950b7f2b6..36c197654b 100644
--- a/packages/protocol/spec/mixins.yml
+++ b/packages/protocol/spec/mixins.yml
@@ -76,7 +76,6 @@ LaunchOptions:
handleSIGINT: boolean?
handleSIGTERM: boolean?
handleSIGHUP: boolean?
- timeout: float
env:
type: array?
items: NameValue
diff --git a/packages/protocol/spec/page.yml b/packages/protocol/spec/page.yml
index 66426950d9..722870100e 100644
--- a/packages/protocol/spec/page.yml
+++ b/packages/protocol/spec/page.yml
@@ -113,7 +113,6 @@ Page:
goBack:
title: Go back
parameters:
- timeout: float
waitUntil: LifecycleEvent?
returns:
response: Response?
@@ -125,7 +124,6 @@ Page:
goForward:
title: Go forward
parameters:
- timeout: float
waitUntil: LifecycleEvent?
returns:
response: Response?
@@ -160,7 +158,6 @@ Page:
reload:
title: Reload
parameters:
- timeout: float
waitUntil: LifecycleEvent?
returns:
response: Response?
@@ -173,7 +170,6 @@ Page:
title: Expect screenshot
parameters:
expected: binary?
- timeout: float
isNot: boolean
locator:
type: object?
@@ -210,7 +206,6 @@ Page:
screenshot:
title: Screenshot
parameters:
- timeout: float
type:
type: enum?
literals:
diff --git a/packages/protocol/src/structs.d.ts b/packages/protocol/src/structs.d.ts
index a44c990626..f9b4623c3e 100644
--- a/packages/protocol/src/structs.d.ts
+++ b/packages/protocol/src/structs.d.ts
@@ -90,6 +90,7 @@ export type Metadata = {
title?: string,
internal?: boolean,
stepId?: string,
+ timeout?: number,
};
export type ClientSideCallMetadata = {
diff --git a/packages/protocol/src/validator.ts b/packages/protocol/src/validator.ts
index 6e102e9cfb..c6f3f894f3 100644
--- a/packages/protocol/src/validator.ts
+++ b/packages/protocol/src/validator.ts
@@ -54,52 +54,44 @@ scheme.AndroidDeviceWebViewRemovedEvent = tObject({
scheme.AndroidDeviceWaitParams = tObject({
androidSelector: tType('AndroidSelector'),
state: tOptional(tEnum(['gone'])),
- timeout: tFloat,
});
scheme.AndroidDeviceWaitResult = tOptional(tObject({}));
scheme.AndroidDeviceFillParams = tObject({
androidSelector: tType('AndroidSelector'),
text: tString,
- timeout: tFloat,
});
scheme.AndroidDeviceFillResult = tOptional(tObject({}));
scheme.AndroidDeviceTapParams = tObject({
androidSelector: tType('AndroidSelector'),
duration: tOptional(tFloat),
- timeout: tFloat,
});
scheme.AndroidDeviceTapResult = tOptional(tObject({}));
scheme.AndroidDeviceDragParams = tObject({
androidSelector: tType('AndroidSelector'),
dest: tType('Point'),
speed: tOptional(tFloat),
- timeout: tFloat,
});
scheme.AndroidDeviceDragResult = tOptional(tObject({}));
scheme.AndroidDeviceFlingParams = tObject({
androidSelector: tType('AndroidSelector'),
direction: tEnum(['up', 'down', 'left', 'right']),
speed: tOptional(tFloat),
- timeout: tFloat,
});
scheme.AndroidDeviceFlingResult = tOptional(tObject({}));
scheme.AndroidDeviceLongTapParams = tObject({
androidSelector: tType('AndroidSelector'),
- timeout: tFloat,
});
scheme.AndroidDeviceLongTapResult = tOptional(tObject({}));
scheme.AndroidDevicePinchCloseParams = tObject({
androidSelector: tType('AndroidSelector'),
percent: tFloat,
speed: tOptional(tFloat),
- timeout: tFloat,
});
scheme.AndroidDevicePinchCloseResult = tOptional(tObject({}));
scheme.AndroidDevicePinchOpenParams = tObject({
androidSelector: tType('AndroidSelector'),
percent: tFloat,
speed: tOptional(tFloat),
- timeout: tFloat,
});
scheme.AndroidDevicePinchOpenResult = tOptional(tObject({}));
scheme.AndroidDeviceScrollParams = tObject({
@@ -107,7 +99,6 @@ scheme.AndroidDeviceScrollParams = tObject({
direction: tEnum(['up', 'down', 'left', 'right']),
percent: tFloat,
speed: tOptional(tFloat),
- timeout: tFloat,
});
scheme.AndroidDeviceScrollResult = tOptional(tObject({}));
scheme.AndroidDeviceSwipeParams = tObject({
@@ -115,7 +106,6 @@ scheme.AndroidDeviceSwipeParams = tObject({
direction: tEnum(['up', 'down', 'left', 'right']),
percent: tFloat,
speed: tOptional(tFloat),
- timeout: tFloat,
});
scheme.AndroidDeviceSwipeResult = tOptional(tObject({}));
scheme.AndroidDeviceInfoParams = tObject({
@@ -317,7 +307,6 @@ scheme.APIRequestContextFetchParams = tObject({
jsonData: tOptional(tString),
formData: tOptional(tArray(tType('NameValue'))),
multipartData: tOptional(tArray(tType('FormField'))),
- timeout: tFloat,
failOnStatusCode: tOptional(tBoolean),
ignoreHTTPSErrors: tOptional(tBoolean),
maxRedirects: tOptional(tInt),
@@ -988,7 +977,6 @@ scheme.BrowserTypeLaunchParams = tObject({
handleSIGINT: tOptional(tBoolean),
handleSIGTERM: tOptional(tBoolean),
handleSIGHUP: tOptional(tBoolean),
- timeout: tFloat,
env: tOptional(tArray(tType('NameValue'))),
headless: tOptional(tBoolean),
proxy: tOptional(tObject({
@@ -1017,7 +1005,6 @@ scheme.BrowserTypeLaunchPersistentContextParams = tObject({
handleSIGINT: tOptional(tBoolean),
handleSIGTERM: tOptional(tBoolean),
handleSIGHUP: tOptional(tBoolean),
- timeout: tFloat,
env: tOptional(tArray(tType('NameValue'))),
headless: tOptional(tBoolean),
proxy: tOptional(tObject({
@@ -1105,7 +1092,6 @@ scheme.BrowserTypeConnectOverCDPParams = tObject({
endpointURL: tOptional(tString),
headers: tOptional(tArray(tType('NameValue'))),
slowMo: tOptional(tFloat),
- timeout: tFloat,
isLocal: tOptional(tBoolean),
noDefaults: tOptional(tBoolean),
artifactsDir: tOptional(tString),
@@ -1117,7 +1103,6 @@ scheme.BrowserTypeConnectOverCDPResult = tObject({
});
scheme.BrowserTypeConnectToWorkerParams = tObject({
endpoint: tString,
- timeout: tFloat,
});
scheme.BrowserTypeConnectToWorkerResult = tObject({
worker: tChannel(['Worker']),
@@ -1131,6 +1116,7 @@ scheme.Metadata = tObject({
title: tOptional(tString),
internal: tOptional(tBoolean),
stepId: tOptional(tString),
+ timeout: tOptional(tFloat),
});
scheme.ClientSideCallMetadata = tObject({
id: tInt,
@@ -1154,7 +1140,6 @@ scheme.ElectronLaunchParams = tObject({
chromiumSandbox: tOptional(tBoolean),
cwd: tOptional(tString),
env: tOptional(tArray(tType('NameValue'))),
- timeout: tFloat,
acceptDownloads: tOptional(tEnum(['accept', 'deny', 'internal-browser-default'])),
bypassCSP: tOptional(tBoolean),
colorScheme: tOptional(tEnum(['dark', 'light', 'no-preference', 'no-override'])),
@@ -1294,7 +1279,6 @@ scheme.FrameAriaSnapshotParams = tObject({
selector: tOptional(tString),
depth: tOptional(tInt),
boxes: tOptional(tBoolean),
- timeout: tFloat,
});
scheme.FrameAriaSnapshotResult = tObject({
snapshot: tString,
@@ -1302,7 +1286,6 @@ scheme.FrameAriaSnapshotResult = tObject({
scheme.FrameBlurParams = tObject({
selector: tString,
strict: tOptional(tBoolean),
- timeout: tFloat,
});
scheme.FrameBlurResult = tOptional(tObject({}));
scheme.FrameCheckParams = tObject({
@@ -1311,7 +1294,6 @@ scheme.FrameCheckParams = tObject({
force: tOptional(tBoolean),
scroll: tOptional(tEnum(['auto', 'none'])),
position: tOptional(tType('Point')),
- timeout: tFloat,
trial: tOptional(tBoolean),
});
scheme.FrameCheckResult = tOptional(tObject({}));
@@ -1326,7 +1308,6 @@ scheme.FrameClickParams = tObject({
delay: tOptional(tFloat),
button: tOptional(tEnum(['left', 'right', 'middle'])),
clickCount: tOptional(tInt),
- timeout: tFloat,
trial: tOptional(tBoolean),
steps: tOptional(tInt),
});
@@ -1340,7 +1321,6 @@ scheme.FrameDragAndDropParams = tObject({
target: tString,
force: tOptional(tBoolean),
scroll: tOptional(tEnum(['auto', 'none'])),
- timeout: tFloat,
trial: tOptional(tBoolean),
sourcePosition: tOptional(tType('Point')),
targetPosition: tOptional(tType('Point')),
@@ -1363,7 +1343,6 @@ scheme.FrameDropParams = tObject({
mimeType: tString,
value: tString,
}))),
- timeout: tFloat,
});
scheme.FrameDropResult = tOptional(tObject({}));
scheme.FrameDblclickParams = tObject({
@@ -1375,7 +1354,6 @@ scheme.FrameDblclickParams = tObject({
position: tOptional(tType('Point')),
delay: tOptional(tFloat),
button: tOptional(tEnum(['left', 'right', 'middle'])),
- timeout: tFloat,
trial: tOptional(tBoolean),
steps: tOptional(tInt),
});
@@ -1385,7 +1363,6 @@ scheme.FrameDispatchEventParams = tObject({
strict: tOptional(tBoolean),
type: tString,
eventInit: tType('SerializedArgument'),
- timeout: tFloat,
});
scheme.FrameDispatchEventResult = tOptional(tObject({}));
scheme.FrameEvaluateExpressionParams = tObject({
@@ -1409,13 +1386,11 @@ scheme.FrameFillParams = tObject({
strict: tOptional(tBoolean),
value: tString,
force: tOptional(tBoolean),
- timeout: tFloat,
});
scheme.FrameFillResult = tOptional(tObject({}));
scheme.FrameFocusParams = tObject({
selector: tString,
strict: tOptional(tBoolean),
- timeout: tFloat,
});
scheme.FrameFocusResult = tOptional(tObject({}));
scheme.FrameFrameElementParams = tOptional(tObject({}));
@@ -1441,14 +1416,12 @@ scheme.FrameGetAttributeParams = tObject({
selector: tString,
strict: tOptional(tBoolean),
name: tString,
- timeout: tFloat,
});
scheme.FrameGetAttributeResult = tObject({
value: tOptional(tString),
});
scheme.FrameGotoParams = tObject({
url: tString,
- timeout: tFloat,
waitUntil: tOptional(tType('LifecycleEvent')),
referer: tOptional(tString),
});
@@ -1462,14 +1435,12 @@ scheme.FrameHoverParams = tObject({
scroll: tOptional(tEnum(['auto', 'none'])),
modifiers: tOptional(tArray(tEnum(['Alt', 'Control', 'ControlOrMeta', 'Meta', 'Shift']))),
position: tOptional(tType('Point')),
- timeout: tFloat,
trial: tOptional(tBoolean),
});
scheme.FrameHoverResult = tOptional(tObject({}));
scheme.FrameInnerHTMLParams = tObject({
selector: tString,
strict: tOptional(tBoolean),
- timeout: tFloat,
});
scheme.FrameInnerHTMLResult = tObject({
value: tString,
@@ -1477,7 +1448,6 @@ scheme.FrameInnerHTMLResult = tObject({
scheme.FrameInnerTextParams = tObject({
selector: tString,
strict: tOptional(tBoolean),
- timeout: tFloat,
});
scheme.FrameInnerTextResult = tObject({
value: tString,
@@ -1485,7 +1455,6 @@ scheme.FrameInnerTextResult = tObject({
scheme.FrameInputValueParams = tObject({
selector: tString,
strict: tOptional(tBoolean),
- timeout: tFloat,
});
scheme.FrameInputValueResult = tObject({
value: tString,
@@ -1493,7 +1462,6 @@ scheme.FrameInputValueResult = tObject({
scheme.FrameIsCheckedParams = tObject({
selector: tString,
strict: tOptional(tBoolean),
- timeout: tFloat,
});
scheme.FrameIsCheckedResult = tObject({
value: tBoolean,
@@ -1501,7 +1469,6 @@ scheme.FrameIsCheckedResult = tObject({
scheme.FrameIsDisabledParams = tObject({
selector: tString,
strict: tOptional(tBoolean),
- timeout: tFloat,
});
scheme.FrameIsDisabledResult = tObject({
value: tBoolean,
@@ -1509,7 +1476,6 @@ scheme.FrameIsDisabledResult = tObject({
scheme.FrameIsEnabledParams = tObject({
selector: tString,
strict: tOptional(tBoolean),
- timeout: tFloat,
});
scheme.FrameIsEnabledResult = tObject({
value: tBoolean,
@@ -1531,7 +1497,6 @@ scheme.FrameIsVisibleResult = tObject({
scheme.FrameIsEditableParams = tObject({
selector: tString,
strict: tOptional(tBoolean),
- timeout: tFloat,
});
scheme.FrameIsEditableResult = tObject({
value: tBoolean,
@@ -1542,7 +1507,6 @@ scheme.FramePressParams = tObject({
key: tString,
delay: tOptional(tFloat),
noWaitAfter: tOptional(tBoolean),
- timeout: tFloat,
});
scheme.FramePressResult = tOptional(tObject({}));
scheme.FrameQuerySelectorParams = tObject({
@@ -1575,14 +1539,12 @@ scheme.FrameSelectOptionParams = tObject({
index: tOptional(tInt),
}))),
force: tOptional(tBoolean),
- timeout: tFloat,
});
scheme.FrameSelectOptionResult = tObject({
values: tArray(tString),
});
scheme.FrameSetContentParams = tObject({
html: tString,
- timeout: tFloat,
waitUntil: tOptional(tType('LifecycleEvent')),
});
scheme.FrameSetContentResult = tOptional(tObject({}));
@@ -1598,7 +1560,6 @@ scheme.FrameSetInputFilesParams = tObject({
directoryStream: tOptional(tChannel(['WritableStream'])),
localPaths: tOptional(tArray(tString)),
streams: tOptional(tArray(tChannel(['WritableStream']))),
- timeout: tFloat,
});
scheme.FrameSetInputFilesResult = tOptional(tObject({}));
scheme.FrameTapParams = tObject({
@@ -1608,14 +1569,12 @@ scheme.FrameTapParams = tObject({
scroll: tOptional(tEnum(['auto', 'none'])),
modifiers: tOptional(tArray(tEnum(['Alt', 'Control', 'ControlOrMeta', 'Meta', 'Shift']))),
position: tOptional(tType('Point')),
- timeout: tFloat,
trial: tOptional(tBoolean),
});
scheme.FrameTapResult = tOptional(tObject({}));
scheme.FrameTextContentParams = tObject({
selector: tString,
strict: tOptional(tBoolean),
- timeout: tFloat,
});
scheme.FrameTextContentResult = tObject({
value: tOptional(tString),
@@ -1629,7 +1588,6 @@ scheme.FrameTypeParams = tObject({
strict: tOptional(tBoolean),
text: tString,
delay: tOptional(tFloat),
- timeout: tFloat,
});
scheme.FrameTypeResult = tOptional(tObject({}));
scheme.FrameUncheckParams = tObject({
@@ -1638,7 +1596,6 @@ scheme.FrameUncheckParams = tObject({
force: tOptional(tBoolean),
scroll: tOptional(tEnum(['auto', 'none'])),
position: tOptional(tType('Point')),
- timeout: tFloat,
trial: tOptional(tBoolean),
});
scheme.FrameUncheckResult = tOptional(tObject({}));
@@ -1650,7 +1607,6 @@ scheme.FrameWaitForFunctionParams = tObject({
expression: tString,
isFunction: tOptional(tBoolean),
arg: tType('SerializedArgument'),
- timeout: tFloat,
pollingInterval: tOptional(tFloat),
selector: tOptional(tString),
strict: tOptional(tBoolean),
@@ -1661,7 +1617,6 @@ scheme.FrameWaitForFunctionResult = tObject({
scheme.FrameWaitForSelectorParams = tObject({
selector: tString,
strict: tOptional(tBoolean),
- timeout: tFloat,
state: tOptional(tEnum(['attached', 'detached', 'visible', 'hidden'])),
omitReturnValue: tOptional(tBoolean),
});
@@ -1678,7 +1633,6 @@ scheme.FrameExpectParams = tObject({
expectedValue: tOptional(tType('SerializedArgument')),
useInnerText: tOptional(tBoolean),
isNot: tBoolean,
- timeout: tFloat,
});
scheme.FrameExpectResult = tOptional(tObject({}));
scheme.FrameExpectErrorDetails = tObject({
@@ -1773,7 +1727,6 @@ scheme.ElementHandleCheckParams = tObject({
force: tOptional(tBoolean),
scroll: tOptional(tEnum(['auto', 'none'])),
position: tOptional(tType('Point')),
- timeout: tFloat,
trial: tOptional(tBoolean),
});
scheme.ElementHandleCheckResult = tOptional(tObject({}));
@@ -1786,7 +1739,6 @@ scheme.ElementHandleClickParams = tObject({
delay: tOptional(tFloat),
button: tOptional(tEnum(['left', 'right', 'middle'])),
clickCount: tOptional(tInt),
- timeout: tFloat,
trial: tOptional(tBoolean),
steps: tOptional(tInt),
});
@@ -1802,7 +1754,6 @@ scheme.ElementHandleDblclickParams = tObject({
position: tOptional(tType('Point')),
delay: tOptional(tFloat),
button: tOptional(tEnum(['left', 'right', 'middle'])),
- timeout: tFloat,
trial: tOptional(tBoolean),
steps: tOptional(tInt),
});
@@ -1815,7 +1766,6 @@ scheme.ElementHandleDispatchEventResult = tOptional(tObject({}));
scheme.ElementHandleFillParams = tObject({
value: tString,
force: tOptional(tBoolean),
- timeout: tFloat,
});
scheme.ElementHandleFillResult = tOptional(tObject({}));
scheme.ElementHandleFocusParams = tOptional(tObject({}));
@@ -1831,7 +1781,6 @@ scheme.ElementHandleHoverParams = tObject({
scroll: tOptional(tEnum(['auto', 'none'])),
modifiers: tOptional(tArray(tEnum(['Alt', 'Control', 'ControlOrMeta', 'Meta', 'Shift']))),
position: tOptional(tType('Point')),
- timeout: tFloat,
trial: tOptional(tBoolean),
});
scheme.ElementHandleHoverResult = tOptional(tObject({}));
@@ -1878,7 +1827,6 @@ scheme.ElementHandleOwnerFrameResult = tObject({
scheme.ElementHandlePressParams = tObject({
key: tString,
delay: tOptional(tFloat),
- timeout: tFloat,
noWaitAfter: tOptional(tBoolean),
});
scheme.ElementHandlePressResult = tOptional(tObject({}));
@@ -1896,7 +1844,6 @@ scheme.ElementHandleQuerySelectorAllResult = tObject({
elements: tArray(tChannel(['ElementHandle'])),
});
scheme.ElementHandleScreenshotParams = tObject({
- timeout: tFloat,
type: tOptional(tEnum(['png', 'jpeg', 'webp'])),
quality: tOptional(tInt),
omitBackground: tOptional(tBoolean),
@@ -1913,9 +1860,7 @@ scheme.ElementHandleScreenshotParams = tObject({
scheme.ElementHandleScreenshotResult = tObject({
binary: tBinary,
});
-scheme.ElementHandleScrollIntoViewIfNeededParams = tObject({
- timeout: tFloat,
-});
+scheme.ElementHandleScrollIntoViewIfNeededParams = tOptional(tObject({}));
scheme.ElementHandleScrollIntoViewIfNeededResult = tOptional(tObject({}));
scheme.ElementHandleSelectOptionParams = tObject({
elements: tOptional(tArray(tChannel(['ElementHandle']))),
@@ -1926,14 +1871,12 @@ scheme.ElementHandleSelectOptionParams = tObject({
index: tOptional(tInt),
}))),
force: tOptional(tBoolean),
- timeout: tFloat,
});
scheme.ElementHandleSelectOptionResult = tObject({
values: tArray(tString),
});
scheme.ElementHandleSelectTextParams = tObject({
force: tOptional(tBoolean),
- timeout: tFloat,
});
scheme.ElementHandleSelectTextResult = tOptional(tObject({}));
scheme.ElementHandleSetInputFilesParams = tObject({
@@ -1946,7 +1889,6 @@ scheme.ElementHandleSetInputFilesParams = tObject({
directoryStream: tOptional(tChannel(['WritableStream'])),
localPaths: tOptional(tArray(tString)),
streams: tOptional(tArray(tChannel(['WritableStream']))),
- timeout: tFloat,
});
scheme.ElementHandleSetInputFilesResult = tOptional(tObject({}));
scheme.ElementHandleTapParams = tObject({
@@ -1954,7 +1896,6 @@ scheme.ElementHandleTapParams = tObject({
scroll: tOptional(tEnum(['auto', 'none'])),
modifiers: tOptional(tArray(tEnum(['Alt', 'Control', 'ControlOrMeta', 'Meta', 'Shift']))),
position: tOptional(tType('Point')),
- timeout: tFloat,
trial: tOptional(tBoolean),
});
scheme.ElementHandleTapResult = tOptional(tObject({}));
@@ -1965,26 +1906,22 @@ scheme.ElementHandleTextContentResult = tObject({
scheme.ElementHandleTypeParams = tObject({
text: tString,
delay: tOptional(tFloat),
- timeout: tFloat,
});
scheme.ElementHandleTypeResult = tOptional(tObject({}));
scheme.ElementHandleUncheckParams = tObject({
force: tOptional(tBoolean),
scroll: tOptional(tEnum(['auto', 'none'])),
position: tOptional(tType('Point')),
- timeout: tFloat,
trial: tOptional(tBoolean),
});
scheme.ElementHandleUncheckResult = tOptional(tObject({}));
scheme.ElementHandleWaitForElementStateParams = tObject({
state: tEnum(['visible', 'hidden', 'stable', 'enabled', 'disabled', 'editable']),
- timeout: tFloat,
});
scheme.ElementHandleWaitForElementStateResult = tOptional(tObject({}));
scheme.ElementHandleWaitForSelectorParams = tObject({
selector: tString,
strict: tOptional(tBoolean),
- timeout: tFloat,
state: tOptional(tEnum(['attached', 'detached', 'visible', 'hidden'])),
});
scheme.ElementHandleWaitForSelectorResult = tObject({
@@ -2057,7 +1994,6 @@ scheme.LocalUtilsConnectParams = tObject({
headers: tOptional(tAny),
exposeNetwork: tOptional(tString),
slowMo: tOptional(tFloat),
- timeout: tFloat,
socksProxyRedirectPortForTest: tOptional(tInt),
});
scheme.LocalUtilsConnectResult = tObject({
@@ -2385,14 +2321,12 @@ scheme.PageExposeBindingResult = tObject({
disposable: tChannel(['Disposable']),
});
scheme.PageGoBackParams = tObject({
- timeout: tFloat,
waitUntil: tOptional(tType('LifecycleEvent')),
});
scheme.PageGoBackResult = tObject({
response: tOptional(tChannel(['Response'])),
});
scheme.PageGoForwardParams = tObject({
- timeout: tFloat,
waitUntil: tOptional(tType('LifecycleEvent')),
});
scheme.PageGoForwardResult = tObject({
@@ -2417,7 +2351,6 @@ scheme.PageUnregisterLocatorHandlerParams = tObject({
});
scheme.PageUnregisterLocatorHandlerResult = tOptional(tObject({}));
scheme.PageReloadParams = tObject({
- timeout: tFloat,
waitUntil: tOptional(tType('LifecycleEvent')),
});
scheme.PageReloadResult = tObject({
@@ -2425,7 +2358,6 @@ scheme.PageReloadResult = tObject({
});
scheme.PageExpectScreenshotParams = tObject({
expected: tOptional(tBinary),
- timeout: tFloat,
isNot: tBoolean,
locator: tOptional(tObject({
frame: tChannel(['Frame']),
@@ -2461,7 +2393,6 @@ scheme.PageExpectScreenshotErrorDetails = tObject({
log: tOptional(tArray(tString)),
});
scheme.PageScreenshotParams = tObject({
- timeout: tFloat,
type: tOptional(tEnum(['png', 'jpeg', 'webp'])),
quality: tOptional(tInt),
fullPage: tOptional(tBoolean),
diff --git a/utils/generate_channels.js b/utils/generate_channels.js
index 8b3d08e3ad..b0b44bb846 100755
--- a/utils/generate_channels.js
+++ b/utils/generate_channels.js
@@ -133,7 +133,9 @@ import type { Progress } from './progress';
` : '') + `
import type { Binary, Channel, ${structNames.join(', ')} } from '@protocol/structs';
export type { Binary, Channel, ${structNames.join(', ')} } from '@protocol/structs';
-`];
+` + (target === 'Dispatcher' ? '' : `
+export type TimeoutOptions = { signal: AbortSignal | undefined, timeout: number };
+`)];
}
const validator_ts = [
@@ -360,7 +362,7 @@ function generateChannels(target) {
for (const derived of derivedClasses.get(channelName) || [])
addScheme(`${derived}${titleCase(methodName)}ErrorDetails`, `tType('${errorDetailsName}')`);
}
- channels_ts.push(` ${methodName}(params: ${paramsName}, ${isDispatcher ? `progress: Progress` : `signal: AbortSignal | undefined`}): Promise<${resultName}>;`);
+ channels_ts.push(` ${methodName}(params: ${paramsName}, ${isDispatcher ? `progress: Progress` : `options: TimeoutOptions`}): Promise<${resultName}>;`);
}
channels_ts.push(`}`);