From 2a98800ac0520482dfcea9a2aea010e4c75bb7ba Mon Sep 17 00:00:00 2001 From: Pavel Feldman Date: Fri, 19 Nov 2021 10:12:48 -0800 Subject: [PATCH] chore: drop wrapApiCall (1) (#10428) --- packages/playwright-core/src/client/frame.ts | 238 ++++++------------- packages/playwright-core/src/client/page.ts | 188 ++++++--------- 2 files changed, 154 insertions(+), 272 deletions(-) diff --git a/packages/playwright-core/src/client/frame.ts b/packages/playwright-core/src/client/frame.ts index cc053be23a..3bc312a0d1 100644 --- a/packages/playwright-core/src/client/frame.ts +++ b/packages/playwright-core/src/client/frame.ts @@ -88,14 +88,12 @@ export class Frame extends ChannelOwner implements api.Fr } async goto(url: string, options: channels.FrameGotoOptions = {}): Promise { - return this._wrapApiCall(async (channel: channels.FrameChannel) => { - const waitUntil = verifyLoadState('waitUntil', options.waitUntil === undefined ? 'load' : options.waitUntil); - return network.Response.fromNullable((await channel.goto({ url, ...options, waitUntil })).response); - }); + const waitUntil = verifyLoadState('waitUntil', options.waitUntil === undefined ? 'load' : options.waitUntil); + return network.Response.fromNullable((await this._channel.goto({ url, ...options, waitUntil })).response); } - private _setupNavigationWaiter(channel: channels.EventTargetChannel, options: { timeout?: number }): Waiter { - const waiter = new Waiter(channel, ''); + private _setupNavigationWaiter(options: { timeout?: number }): Waiter { + const waiter = new Waiter(this._page!._channel, ''); if (this._page!.isClosed()) waiter.rejectImmediately(new Error('Navigation failed because page was closed!')); waiter.rejectOnEvent(this._page!, Events.Page.Close, new Error('Navigation failed because page was closed!')); @@ -109,7 +107,7 @@ export class Frame extends ChannelOwner implements api.Fr async waitForNavigation(options: WaitForNavigationOptions = {}): Promise { return this._page!._wrapApiCall(async (channel: channels.PageChannel) => { const waitUntil = verifyLoadState('waitUntil', options.waitUntil === undefined ? 'load' : options.waitUntil); - const waiter = this._setupNavigationWaiter(channel, options); + const waiter = this._setupNavigationWaiter(options); const toUrl = typeof options.url === 'string' ? ` to "${options.url}"` : ''; waiter.log(`waiting for navigation${toUrl} until "${waitUntil}"`); @@ -146,7 +144,7 @@ export class Frame extends ChannelOwner implements api.Fr if (this._loadStates.has(state)) return; return this._page!._wrapApiCall(async (channel: channels.PageChannel) => { - const waiter = this._setupNavigationWaiter(channel, options); + const waiter = this._setupNavigationWaiter(options); await waiter.waitForEvent(this._eventEmitter, 'loadstate', s => { waiter.log(` "${s}" event fired`); return s === state; @@ -163,87 +161,65 @@ export class Frame extends ChannelOwner implements api.Fr } async frameElement(): Promise { - return this._wrapApiCall(async (channel: channels.FrameChannel) => { - return ElementHandle.from((await channel.frameElement()).element); - }); + return ElementHandle.from((await this._channel.frameElement()).element); } async evaluateHandle(pageFunction: structs.PageFunction, arg?: Arg): Promise> { assertMaxArguments(arguments.length, 2); - return this._wrapApiCall(async (channel: channels.FrameChannel) => { - const result = await channel.evaluateExpressionHandle({ expression: String(pageFunction), isFunction: typeof pageFunction === 'function', arg: serializeArgument(arg) }); - return JSHandle.from(result.handle) as any as structs.SmartHandle; - }); + const result = await this._channel.evaluateExpressionHandle({ expression: String(pageFunction), isFunction: typeof pageFunction === 'function', arg: serializeArgument(arg) }); + return JSHandle.from(result.handle) as any as structs.SmartHandle; } async evaluate(pageFunction: structs.PageFunction, arg?: Arg): Promise { assertMaxArguments(arguments.length, 2); - return this._wrapApiCall(async (channel: channels.FrameChannel) => { - const result = await channel.evaluateExpression({ expression: String(pageFunction), isFunction: typeof pageFunction === 'function', arg: serializeArgument(arg) }); - return parseResult(result.value); - }); + const result = await this._channel.evaluateExpression({ expression: String(pageFunction), isFunction: typeof pageFunction === 'function', arg: serializeArgument(arg) }); + return parseResult(result.value); } async $(selector: string, options?: { strict?: boolean }): Promise | null> { - return this._wrapApiCall(async (channel: channels.FrameChannel) => { - const result = await channel.querySelector({ selector, ...options }); - return ElementHandle.fromNullable(result.element) as ElementHandle | null; - }); + const result = await this._channel.querySelector({ selector, ...options }); + return ElementHandle.fromNullable(result.element) as ElementHandle | null; } waitForSelector(selector: string, options: channels.FrameWaitForSelectorOptions & { state: 'attached' | 'visible' }): Promise>; waitForSelector(selector: string, options?: channels.FrameWaitForSelectorOptions): Promise | null>; async waitForSelector(selector: string, options: channels.FrameWaitForSelectorOptions = {}): Promise | null> { - return this._wrapApiCall(async (channel: channels.FrameChannel) => { - if ((options as any).visibility) - 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 channel.waitForSelector({ selector, ...options }); - return ElementHandle.fromNullable(result.element) as ElementHandle | null; - }); + if ((options as any).visibility) + 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 }); + return ElementHandle.fromNullable(result.element) as ElementHandle | null; } async dispatchEvent(selector: string, type: string, eventInit?: any, options: channels.FrameDispatchEventOptions = {}): Promise { - return this._wrapApiCall(async (channel: channels.FrameChannel) => { - await channel.dispatchEvent({ selector, type, eventInit: serializeArgument(eventInit), ...options }); - }); + await this._channel.dispatchEvent({ selector, type, eventInit: serializeArgument(eventInit), ...options }); } async $eval(selector: string, pageFunction: structs.PageFunctionOn, arg?: Arg): Promise { assertMaxArguments(arguments.length, 3); - return this._wrapApiCall(async (channel: channels.FrameChannel) => { - const result = await channel.evalOnSelector({ selector, expression: String(pageFunction), isFunction: typeof pageFunction === 'function', arg: serializeArgument(arg) }); - return parseResult(result.value); - }); + const result = await this._channel.evalOnSelector({ selector, expression: String(pageFunction), isFunction: typeof pageFunction === 'function', arg: serializeArgument(arg) }); + return parseResult(result.value); } async $$eval(selector: string, pageFunction: structs.PageFunctionOn, arg?: Arg): Promise { assertMaxArguments(arguments.length, 3); - return this._wrapApiCall(async (channel: channels.FrameChannel) => { - const result = await channel.evalOnSelectorAll({ selector, expression: String(pageFunction), isFunction: typeof pageFunction === 'function', arg: serializeArgument(arg) }); - return parseResult(result.value); - }); + const result = await this._channel.evalOnSelectorAll({ selector, expression: String(pageFunction), isFunction: typeof pageFunction === 'function', arg: serializeArgument(arg) }); + return parseResult(result.value); } async $$(selector: string): Promise[]> { - return this._wrapApiCall(async (channel: channels.FrameChannel) => { - const result = await channel.querySelectorAll({ selector }); - return result.elements.map(e => ElementHandle.from(e) as ElementHandle); - }); + const result = await this._channel.querySelectorAll({ selector }); + return result.elements.map(e => ElementHandle.from(e) as ElementHandle); } async content(): Promise { - return this._wrapApiCall(async (channel: channels.FrameChannel) => { - return (await channel.content()).value; - }); + return (await this._channel.content()).value; } async setContent(html: string, options: channels.FrameSetContentOptions = {}): Promise { - return this._wrapApiCall(async (channel: channels.FrameChannel) => { - const waitUntil = verifyLoadState('waitUntil', options.waitUntil === undefined ? 'load' : options.waitUntil); - await channel.setContent({ html, ...options, waitUntil }); - }); + const waitUntil = verifyLoadState('waitUntil', options.waitUntil === undefined ? 'load' : options.waitUntil); + await this._channel.setContent({ html, ...options, waitUntil }); } name(): string { @@ -267,55 +243,41 @@ export class Frame extends ChannelOwner implements api.Fr } async addScriptTag(options: { url?: string, path?: string, content?: string, type?: string } = {}): Promise { - return this._wrapApiCall(async (channel: channels.FrameChannel) => { - const copy = { ...options }; - if (copy.path) { - copy.content = (await fs.promises.readFile(copy.path)).toString(); - copy.content += '//# sourceURL=' + copy.path.replace(/\n/g, ''); - } - return ElementHandle.from((await channel.addScriptTag({ ...copy })).element); - }); + const copy = { ...options }; + if (copy.path) { + copy.content = (await fs.promises.readFile(copy.path)).toString(); + copy.content += '//# sourceURL=' + copy.path.replace(/\n/g, ''); + } + return ElementHandle.from((await this._channel.addScriptTag({ ...copy })).element); } async addStyleTag(options: { url?: string; path?: string; content?: string; } = {}): Promise { - return this._wrapApiCall(async (channel: channels.FrameChannel) => { - const copy = { ...options }; - if (copy.path) { - copy.content = (await fs.promises.readFile(copy.path)).toString(); - copy.content += '/*# sourceURL=' + copy.path.replace(/\n/g, '') + '*/'; - } - return ElementHandle.from((await channel.addStyleTag({ ...copy })).element); - }); + const copy = { ...options }; + if (copy.path) { + 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 })).element); } async click(selector: string, options: channels.FrameClickOptions = {}) { - return this._wrapApiCall(async (channel: channels.FrameChannel) => { - return await channel.click({ selector, ...options }); - }); + return await this._channel.click({ selector, ...options }); } async dblclick(selector: string, options: channels.FrameDblclickOptions = {}) { - return this._wrapApiCall(async (channel: channels.FrameChannel) => { - return await channel.dblclick({ selector, ...options }); - }); + return await this._channel.dblclick({ selector, ...options }); } async dragAndDrop(source: string, target: string, options: channels.FrameDragAndDropOptions = {}) { - return this._wrapApiCall(async (channel: channels.FrameChannel) => { - return await channel.dragAndDrop({ source, target, ...options }); - }); + return await this._channel.dragAndDrop({ source, target, ...options }); } async tap(selector: string, options: channels.FrameTapOptions = {}) { - return this._wrapApiCall(async (channel: channels.FrameChannel) => { - return await channel.tap({ selector, ...options }); - }); + return await this._channel.tap({ selector, ...options }); } async fill(selector: string, value: string, options: channels.FrameFillOptions = {}) { - return this._wrapApiCall(async (channel: channels.FrameChannel) => { - return await channel.fill({ selector, value, ...options }); - }); + return await this._channel.fill({ selector, value, ...options }); } locator(selector: string): Locator { @@ -327,119 +289,81 @@ export class Frame extends ChannelOwner implements api.Fr } async focus(selector: string, options: channels.FrameFocusOptions = {}) { - return this._wrapApiCall(async (channel: channels.FrameChannel) => { - await channel.focus({ selector, ...options }); - }); + await this._channel.focus({ selector, ...options }); } async textContent(selector: string, options: channels.FrameTextContentOptions = {}): Promise { - return this._wrapApiCall(async (channel: channels.FrameChannel) => { - const value = (await channel.textContent({ selector, ...options })).value; - return value === undefined ? null : value; - }); + const value = (await this._channel.textContent({ selector, ...options })).value; + return value === undefined ? null : value; } async innerText(selector: string, options: channels.FrameInnerTextOptions = {}): Promise { - return this._wrapApiCall(async (channel: channels.FrameChannel) => { - return (await channel.innerText({ selector, ...options })).value; - }); + return (await this._channel.innerText({ selector, ...options })).value; } async innerHTML(selector: string, options: channels.FrameInnerHTMLOptions = {}): Promise { - return this._wrapApiCall(async (channel: channels.FrameChannel) => { - return (await channel.innerHTML({ selector, ...options })).value; - }); + return (await this._channel.innerHTML({ selector, ...options })).value; } async getAttribute(selector: string, name: string, options: channels.FrameGetAttributeOptions = {}): Promise { - return this._wrapApiCall(async (channel: channels.FrameChannel) => { - const value = (await channel.getAttribute({ selector, name, ...options })).value; - return value === undefined ? null : value; - }); + const value = (await this._channel.getAttribute({ selector, name, ...options })).value; + return value === undefined ? null : value; } async inputValue(selector: string, options: channels.FrameInputValueOptions = {}): Promise { - return this._wrapApiCall(async (channel: channels.FrameChannel) => { - return (await channel.inputValue({ selector, ...options })).value; - }); + return (await this._channel.inputValue({ selector, ...options })).value; } async isChecked(selector: string, options: channels.FrameIsCheckedOptions = {}): Promise { - return this._wrapApiCall(async (channel: channels.FrameChannel) => { - return (await channel.isChecked({ selector, ...options })).value; - }); + return (await this._channel.isChecked({ selector, ...options })).value; } async isDisabled(selector: string, options: channels.FrameIsDisabledOptions = {}): Promise { - return this._wrapApiCall(async (channel: channels.FrameChannel) => { - return (await channel.isDisabled({ selector, ...options })).value; - }); + return (await this._channel.isDisabled({ selector, ...options })).value; } async isEditable(selector: string, options: channels.FrameIsEditableOptions = {}): Promise { - return this._wrapApiCall(async (channel: channels.FrameChannel) => { - return (await channel.isEditable({ selector, ...options })).value; - }); + return (await this._channel.isEditable({ selector, ...options })).value; } async isEnabled(selector: string, options: channels.FrameIsEnabledOptions = {}): Promise { - return this._wrapApiCall(async (channel: channels.FrameChannel) => { - return (await channel.isEnabled({ selector, ...options })).value; - }); + return (await this._channel.isEnabled({ selector, ...options })).value; } async isHidden(selector: string, options: channels.FrameIsHiddenOptions = {}): Promise { - return this._wrapApiCall(async (channel: channels.FrameChannel) => { - return (await channel.isHidden({ selector, ...options })).value; - }); + return (await this._channel.isHidden({ selector, ...options })).value; } async isVisible(selector: string, options: channels.FrameIsVisibleOptions = {}): Promise { - return this._wrapApiCall(async (channel: channels.FrameChannel) => { - return (await channel.isVisible({ selector, ...options })).value; - }); + return (await this._channel.isVisible({ selector, ...options })).value; } async hover(selector: string, options: channels.FrameHoverOptions = {}) { - return this._wrapApiCall(async (channel: channels.FrameChannel) => { - await channel.hover({ selector, ...options }); - }); + await this._channel.hover({ selector, ...options }); } async selectOption(selector: string, values: string | api.ElementHandle | SelectOption | string[] | api.ElementHandle[] | SelectOption[] | null, options: SelectOptionOptions & StrictOptions = {}): Promise { - return this._wrapApiCall(async (channel: channels.FrameChannel) => { - return (await channel.selectOption({ selector, ...convertSelectOptionValues(values), ...options })).values; - }); + return (await this._channel.selectOption({ selector, ...convertSelectOptionValues(values), ...options })).values; } async setInputFiles(selector: string, files: string | FilePayload | string[] | FilePayload[], options: channels.FrameSetInputFilesOptions = {}): Promise { - return this._wrapApiCall(async (channel: channels.FrameChannel) => { - await channel.setInputFiles({ selector, files: await convertInputFiles(files), ...options }); - }); + await this._channel.setInputFiles({ selector, files: await convertInputFiles(files), ...options }); } async type(selector: string, text: string, options: channels.FrameTypeOptions = {}) { - return this._wrapApiCall(async (channel: channels.FrameChannel) => { - await channel.type({ selector, text, ...options }); - }); + await this._channel.type({ selector, text, ...options }); } async press(selector: string, key: string, options: channels.FramePressOptions = {}) { - return this._wrapApiCall(async (channel: channels.FrameChannel) => { - await channel.press({ selector, key, ...options }); - }); + await this._channel.press({ selector, key, ...options }); } async check(selector: string, options: channels.FrameCheckOptions = {}) { - return this._wrapApiCall(async (channel: channels.FrameChannel) => { - await channel.check({ selector, ...options }); - }); + await this._channel.check({ selector, ...options }); } async uncheck(selector: string, options: channels.FrameUncheckOptions = {}) { - return this._wrapApiCall(async (channel: channels.FrameChannel) => { - await channel.uncheck({ selector, ...options }); - }); + await this._channel.uncheck({ selector, ...options }); } async setChecked(selector: string, checked: boolean, options?: channels.FrameCheckOptions) { @@ -450,30 +374,24 @@ export class Frame extends ChannelOwner implements api.Fr } async waitForTimeout(timeout: number) { - return this._wrapApiCall(async (channel: channels.FrameChannel) => { - await channel.waitForTimeout({ timeout }); - }); + await this._channel.waitForTimeout({ timeout }); } async waitForFunction(pageFunction: structs.PageFunction, arg?: Arg, options: WaitForFunctionOptions = {}): Promise> { - return this._wrapApiCall(async (channel: channels.FrameChannel) => { - if (typeof options.polling === 'string') - assert(options.polling === 'raf', 'Unknown polling option: ' + options.polling); - const result = await channel.waitForFunction({ - ...options, - pollingInterval: options.polling === 'raf' ? undefined : options.polling, - expression: String(pageFunction), - isFunction: typeof pageFunction === 'function', - arg: serializeArgument(arg), - }); - return JSHandle.from(result.handle) as any as structs.SmartHandle; + if (typeof options.polling === 'string') + assert(options.polling === 'raf', 'Unknown polling option: ' + options.polling); + const result = await this._channel.waitForFunction({ + ...options, + pollingInterval: options.polling === 'raf' ? undefined : options.polling, + expression: String(pageFunction), + isFunction: typeof pageFunction === 'function', + arg: serializeArgument(arg), }); + return JSHandle.from(result.handle) as any as structs.SmartHandle; } async title(): Promise { - return this._wrapApiCall(async (channel: channels.FrameChannel) => { - return (await channel.title()).value; - }); + return (await this._channel.title()).value; } } diff --git a/packages/playwright-core/src/client/page.ts b/packages/playwright-core/src/client/page.ts index aaefcb16fd..a25376c82b 100644 --- a/packages/playwright-core/src/client/page.ts +++ b/packages/playwright-core/src/client/page.ts @@ -303,25 +303,19 @@ export class Page extends ChannelOwner implements api.Page } async exposeFunction(name: string, callback: Function) { - return this._wrapApiCall(async (channel: channels.PageChannel) => { - await channel.exposeBinding({ name }); - const binding = (source: structs.BindingSource, ...args: any[]) => callback(...args); - this._bindings.set(name, binding); - }); + await this._channel.exposeBinding({ name }); + const binding = (source: structs.BindingSource, ...args: any[]) => callback(...args); + this._bindings.set(name, binding); } async exposeBinding(name: string, callback: (source: structs.BindingSource, ...args: any[]) => any, options: { handle?: boolean } = {}) { - return this._wrapApiCall(async (channel: channels.PageChannel) => { - await channel.exposeBinding({ name, needsHandle: options.handle }); - this._bindings.set(name, callback); - }); + await this._channel.exposeBinding({ name, needsHandle: options.handle }); + this._bindings.set(name, callback); } async setExtraHTTPHeaders(headers: Headers) { - return this._wrapApiCall(async (channel: channels.PageChannel) => { - validateHeaders(headers); - await channel.setExtraHTTPHeaders({ headers: headersObjectToArray(headers) }); - }); + validateHeaders(headers); + await this._channel.setExtraHTTPHeaders({ headers: headersObjectToArray(headers) }); } url(): string { @@ -341,10 +335,8 @@ export class Page extends ChannelOwner implements api.Page } async reload(options: channels.PageReloadOptions = {}): Promise { - return this._wrapApiCall(async (channel: channels.PageChannel) => { - const waitUntil = verifyLoadState('waitUntil', options.waitUntil === undefined ? 'load' : options.waitUntil); - return Response.fromNullable((await channel.reload({ ...options, waitUntil })).response); - }); + const waitUntil = verifyLoadState('waitUntil', options.waitUntil === undefined ? 'load' : options.waitUntil); + return Response.fromNullable((await this._channel.reload({ ...options, waitUntil })).response); } async waitForLoadState(state?: LifecycleEvent, options?: { timeout?: number }): Promise { @@ -360,35 +352,29 @@ export class Page extends ChannelOwner implements api.Page } async waitForRequest(urlOrPredicate: string | RegExp | ((r: Request) => boolean | Promise), options: { timeout?: number } = {}): Promise { - return this._wrapApiCall(async (channel: channels.PageChannel) => { - const predicate = (request: Request) => { - if (isString(urlOrPredicate) || isRegExp(urlOrPredicate)) - return urlMatches(this._browserContext._options.baseURL, request.url(), urlOrPredicate); - return urlOrPredicate(request); - }; - const trimmedUrl = trimUrl(urlOrPredicate); - const logLine = trimmedUrl ? `waiting for request ${trimmedUrl}` : undefined; - return this._waitForEvent(channel, Events.Page.Request, { predicate, timeout: options.timeout }, logLine); - }); + const predicate = (request: Request) => { + if (isString(urlOrPredicate) || isRegExp(urlOrPredicate)) + return urlMatches(this._browserContext._options.baseURL, request.url(), urlOrPredicate); + return urlOrPredicate(request); + }; + const trimmedUrl = trimUrl(urlOrPredicate); + const logLine = trimmedUrl ? `waiting for request ${trimmedUrl}` : undefined; + return this._waitForEvent(this._channel, Events.Page.Request, { predicate, timeout: options.timeout }, logLine); } async waitForResponse(urlOrPredicate: string | RegExp | ((r: Response) => boolean | Promise), options: { timeout?: number } = {}): Promise { - return this._wrapApiCall(async (channel: channels.PageChannel) => { - const predicate = (response: Response) => { - if (isString(urlOrPredicate) || isRegExp(urlOrPredicate)) - return urlMatches(this._browserContext._options.baseURL, response.url(), urlOrPredicate); - return urlOrPredicate(response); - }; - const trimmedUrl = trimUrl(urlOrPredicate); - const logLine = trimmedUrl ? `waiting for response ${trimmedUrl}` : undefined; - return this._waitForEvent(channel, Events.Page.Response, { predicate, timeout: options.timeout }, logLine); - }); + const predicate = (response: Response) => { + if (isString(urlOrPredicate) || isRegExp(urlOrPredicate)) + return urlMatches(this._browserContext._options.baseURL, response.url(), urlOrPredicate); + return urlOrPredicate(response); + }; + const trimmedUrl = trimUrl(urlOrPredicate); + const logLine = trimmedUrl ? `waiting for response ${trimmedUrl}` : undefined; + return this._waitForEvent(this._channel, Events.Page.Response, { predicate, timeout: options.timeout }, logLine); } async waitForEvent(event: string, optionsOrPredicate: WaitForEventOptions = {}): Promise { - return this._wrapApiCall(async channel => { - return this._waitForEvent(channel, event, optionsOrPredicate, `waiting for event "${event}"`); - }); + return this._waitForEvent(this._channel, event, optionsOrPredicate, `waiting for event "${event}"`); } private async _waitForEvent(channel: channels.EventTargetChannel, event: string, optionsOrPredicate: WaitForEventOptions, logLine?: string): Promise { @@ -408,35 +394,27 @@ export class Page extends ChannelOwner implements api.Page } async goBack(options: channels.PageGoBackOptions = {}): Promise { - return this._wrapApiCall(async (channel: channels.PageChannel) => { - const waitUntil = verifyLoadState('waitUntil', options.waitUntil === undefined ? 'load' : options.waitUntil); - return Response.fromNullable((await channel.goBack({ ...options, waitUntil })).response); - }); + const waitUntil = verifyLoadState('waitUntil', options.waitUntil === undefined ? 'load' : options.waitUntil); + return Response.fromNullable((await this._channel.goBack({ ...options, waitUntil })).response); } async goForward(options: channels.PageGoForwardOptions = {}): Promise { - return this._wrapApiCall(async (channel: channels.PageChannel) => { - const waitUntil = verifyLoadState('waitUntil', options.waitUntil === undefined ? 'load' : options.waitUntil); - return Response.fromNullable((await channel.goForward({ ...options, waitUntil })).response); - }); + const waitUntil = verifyLoadState('waitUntil', options.waitUntil === undefined ? 'load' : options.waitUntil); + return Response.fromNullable((await this._channel.goForward({ ...options, waitUntil })).response); } async emulateMedia(options: { media?: 'screen' | 'print' | null, colorScheme?: 'dark' | 'light' | 'no-preference' | null, reducedMotion?: 'reduce' | 'no-preference' | null, forcedColors?: 'active' | 'none' | null } = {}) { - return this._wrapApiCall(async (channel: channels.PageChannel) => { - await channel.emulateMedia({ - media: options.media === null ? 'null' : options.media, - colorScheme: options.colorScheme === null ? 'null' : options.colorScheme, - reducedMotion: options.reducedMotion === null ? 'null' : options.reducedMotion, - forcedColors: options.forcedColors === null ? 'null' : options.forcedColors, - }); + await this._channel.emulateMedia({ + media: options.media === null ? 'null' : options.media, + colorScheme: options.colorScheme === null ? 'null' : options.colorScheme, + reducedMotion: options.reducedMotion === null ? 'null' : options.reducedMotion, + forcedColors: options.forcedColors === null ? 'null' : options.forcedColors, }); } async setViewportSize(viewportSize: Size) { - return this._wrapApiCall(async (channel: channels.PageChannel) => { - this._viewportSize = viewportSize; - await channel.setViewportSize({ viewportSize }); - }); + this._viewportSize = viewportSize; + await this._channel.setViewportSize({ viewportSize }); } viewportSize(): Size | null { @@ -449,26 +427,20 @@ export class Page extends ChannelOwner implements api.Page } async addInitScript(script: Function | string | { path?: string, content?: string }, arg?: any) { - return this._wrapApiCall(async (channel: channels.PageChannel) => { - const source = await evaluationScript(script, arg); - await channel.addInitScript({ source }); - }); + const source = await evaluationScript(script, arg); + await this._channel.addInitScript({ source }); } async route(url: URLMatch, handler: RouteHandlerCallback, options: { times?: number } = {}): Promise { - return this._wrapApiCall(async (channel: channels.PageChannel) => { - this._routes.unshift(new RouteHandler(this._browserContext._options.baseURL, url, handler, options.times)); - if (this._routes.length === 1) - await channel.setNetworkInterceptionEnabled({ enabled: true }); - }); + this._routes.unshift(new RouteHandler(this._browserContext._options.baseURL, url, handler, options.times)); + if (this._routes.length === 1) + await this._channel.setNetworkInterceptionEnabled({ enabled: true }); } async unroute(url: URLMatch, handler?: RouteHandlerCallback): Promise { - return this._wrapApiCall(async (channel: channels.PageChannel) => { - this._routes = this._routes.filter(route => route.url !== url || (handler && route.handler !== handler)); - if (!this._routes.length) - await this._disableInterception(channel); - }); + this._routes = this._routes.filter(route => route.url !== url || (handler && route.handler !== handler)); + if (!this._routes.length) + await this._disableInterception(this._channel); } private async _disableInterception(channel: channels.PageChannel) { @@ -476,18 +448,16 @@ export class Page extends ChannelOwner implements api.Page } async screenshot(options: channels.PageScreenshotOptions & { path?: string } = {}): Promise { - return this._wrapApiCall(async (channel: channels.PageChannel) => { - const copy = { ...options }; - if (!copy.type) - copy.type = determineScreenshotType(options); - const result = await channel.screenshot(copy); - const buffer = Buffer.from(result.binary, 'base64'); - if (options.path) { - await mkdirIfNeeded(options.path); - await fs.promises.writeFile(options.path, buffer); - } - return buffer; - }); + const copy = { ...options }; + if (!copy.type) + copy.type = determineScreenshotType(options); + const result = await this._channel.screenshot(copy); + const buffer = Buffer.from(result.binary, 'base64'); + if (options.path) { + await mkdirIfNeeded(options.path); + await fs.promises.writeFile(options.path, buffer); + } + return buffer; } async title(): Promise { @@ -495,9 +465,7 @@ export class Page extends ChannelOwner implements api.Page } async bringToFront(): Promise { - return this._wrapApiCall(async (channel: channels.PageChannel) => { - await channel.bringToFront(); - }); + await this._channel.bringToFront(); } async close(options: { runBeforeUnload?: boolean } = { runBeforeUnload: undefined }) { @@ -668,33 +636,29 @@ export class Page extends ChannelOwner implements api.Page } async pause() { - return this.context()._wrapApiCall(async (channel: channels.BrowserContextChannel) => { - await channel.pause(); - }); + await this.context()._channel.pause(); } async pdf(options: PDFOptions = {}): Promise { - return this._wrapApiCall(async (channel: channels.PageChannel) => { - const transportOptions: channels.PagePdfParams = { ...options } as channels.PagePdfParams; - if (transportOptions.margin) - transportOptions.margin = { ...transportOptions.margin }; - if (typeof options.width === 'number') - transportOptions.width = options.width + 'px'; - if (typeof options.height === 'number') - transportOptions.height = options.height + 'px'; - for (const margin of ['top', 'right', 'bottom', 'left']) { - const index = margin as 'top' | 'right' | 'bottom' | 'left'; - if (options.margin && typeof options.margin[index] === 'number') - transportOptions.margin![index] = transportOptions.margin![index] + 'px'; - } - const result = await channel.pdf(transportOptions); - const buffer = Buffer.from(result.pdf, 'base64'); - if (options.path) { - await fs.promises.mkdir(path.dirname(options.path), { recursive: true }); - await fs.promises.writeFile(options.path, buffer); - } - return buffer; - }); + const transportOptions: channels.PagePdfParams = { ...options } as channels.PagePdfParams; + if (transportOptions.margin) + transportOptions.margin = { ...transportOptions.margin }; + if (typeof options.width === 'number') + transportOptions.width = options.width + 'px'; + if (typeof options.height === 'number') + transportOptions.height = options.height + 'px'; + for (const margin of ['top', 'right', 'bottom', 'left']) { + const index = margin as 'top' | 'right' | 'bottom' | 'left'; + if (options.margin && typeof options.margin[index] === 'number') + transportOptions.margin![index] = transportOptions.margin![index] + 'px'; + } + const result = await this._channel.pdf(transportOptions); + const buffer = Buffer.from(result.pdf, 'base64'); + if (options.path) { + await fs.promises.mkdir(path.dirname(options.path), { recursive: true }); + await fs.promises.writeFile(options.path, buffer); + } + return buffer; } }