/** * @license * Copyright 2017 Google Inc. * SPDX-License-Identifier: Apache-2.0 */ import type {Protocol} from 'devtools-protocol'; import { concat, distinctUntilChanged, EMPTY, filter, first, firstValueFrom, from, map, merge, mergeMap, mergeScan, of, raceWith, ReplaySubject, startWith, switchMap, take, takeUntil, timer, type Observable, } from '../../third_party/rxjs/rxjs.js'; import type {HTTPRequest} from '../api/HTTPRequest.js'; import type {HTTPResponse} from '../api/HTTPResponse.js'; import type {Accessibility} from '../cdp/Accessibility.js'; import type {Coverage} from '../cdp/Coverage.js'; import type {NetworkConditions} from '../cdp/NetworkManager.js'; import type {Tracing} from '../cdp/Tracing.js'; import type {WebMCP} from '../cdp/WebMCP.js'; import type {ConsoleMessage} from '../common/ConsoleMessage.js'; import type { Cookie, CookieParam, DeleteCookiesRequest, } from '../common/Cookie.js'; import type {Device} from '../common/Device.js'; import {TargetCloseError} from '../common/Errors.js'; import { EventEmitter, type EventsWithWildcard, type EventType, type Handler, } from '../common/EventEmitter.js'; import type {FileChooser} from '../common/FileChooser.js'; import type {PDFOptions} from '../common/PDFOptions.js'; import {TimeoutSettings} from '../common/TimeoutSettings.js'; import type { Awaitable, AwaitablePredicate, EvaluateFunc, EvaluateFuncWith, HandleFor, NodeFor, } from '../common/types.js'; import { debugError, fromEmitterEvent, filterAsync, isString, NETWORK_IDLE_TIME, timeout, withSourcePuppeteerURLIfNone, fromAbortSignal, } from '../common/util.js'; import type {Viewport} from '../common/Viewport.js'; import {environment} from '../environment.js'; import type {ScreenRecorder} from '../node/ScreenRecorder.js'; import {guarded} from '../util/decorators.js'; import { AsyncDisposableStack, asyncDisposeSymbol, DisposableStack, disposeSymbol, } from '../util/disposable.js'; import {stringToTypedArray} from '../util/encoding.js'; import type {BluetoothEmulation} from './BluetoothEmulation.js'; import type {Browser, WindowId} from './Browser.js'; import type {BrowserContext} from './BrowserContext.js'; import type {CDPSession} from './CDPSession.js'; import type {DeviceRequestPrompt} from './DeviceRequestPrompt.js'; import type {Dialog} from './Dialog.js'; import type { BoundingBox, ClickOptions, ElementHandle, } from './ElementHandle.js'; import type {Extension} from './Extension.js'; import type { Frame, FrameAddScriptTagOptions, FrameAddStyleTagOptions, FrameWaitForFunctionOptions, GoToOptions, WaitForOptions, } from './Frame.js'; import type { Keyboard, KeyboardTypeOptions, Mouse, Touchscreen, } from './Input.js'; import type {Issue} from './Issue.js'; import type {JSHandle} from './JSHandle.js'; import { FunctionLocator, Locator, NodeLocator, type AwaitedLocator, } from './locators/locators.js'; import type {Realm} from './Realm.js'; import type {Target} from './Target.js'; import type {WebWorker} from './WebWorker.js'; /** * @public */ export interface Metrics { Timestamp?: number; Documents?: number; Frames?: number; JSEventListeners?: number; Nodes?: number; LayoutCount?: number; RecalcStyleCount?: number; LayoutDuration?: number; RecalcStyleDuration?: number; ScriptDuration?: number; TaskDuration?: number; JSHeapUsedSize?: number; JSHeapTotalSize?: number; } /** * @public */ export interface Credentials { username: string; password: string; } /** * @public */ export interface WaitForNetworkIdleOptions extends WaitTimeoutOptions { /** * Time (in milliseconds) the network should be idle. * * @defaultValue `500` */ idleTime?: number; /** * Maximum number concurrent of network connections to be considered inactive. * * @defaultValue `0` */ concurrency?: number; } /** * @public */ export interface WaitTimeoutOptions { /** * Maximum wait time in milliseconds. Pass 0 to disable the timeout. * * The default value can be changed by using the * {@link Page.setDefaultTimeout} method. * * @defaultValue `30_000` */ timeout?: number; /** * A signal object that allows you to cancel a waitFor call. */ signal?: AbortSignal; } /** * @public */ export interface WaitForSelectorOptions { /** * Wait for the selected element to be present in DOM and to be visible. See * {@link ElementHandle.isVisible} for the definition of element visibility. * * @defaultValue `false` */ visible?: boolean; /** * Wait for the selected element to not be found in the DOM or to be hidden. * See {@link ElementHandle.isHidden} for the definition of element * invisibility. * * @defaultValue `false` */ hidden?: boolean; /** * Maximum time to wait in milliseconds. Pass `0` to disable timeout. * * The default value can be changed by using {@link Page.setDefaultTimeout} * * @defaultValue `30_000` (30 seconds) */ timeout?: number; /** * A signal object that allows you to cancel a waitForSelector call. */ signal?: AbortSignal; } /** * @public */ export interface GeolocationOptions { /** * Latitude between `-90` and `90`. */ longitude: number; /** * Longitude between `-180` and `180`. */ latitude: number; /** * Optional non-negative accuracy value. */ accuracy?: number; } /** * A media feature to emulate. * * @public */ export interface MediaFeature { /** * A name of the feature, for example, 'prefers-reduced-motion'. */ name: string; /** * A value for the feature, for example, 'reduce'. */ value: string; } /** * @public */ export interface ScreenshotClip extends BoundingBox { /** * @defaultValue `1` */ scale?: number; } /** * @public */ export type ImageFormat = 'png' | 'jpeg' | 'webp'; /** * @public */ export type VideoFormat = 'webm' | 'gif' | 'mp4'; /** * @public */ export interface ScreenshotOptions { /** * @defaultValue `false` */ optimizeForSpeed?: boolean; /** * @defaultValue `'png'` */ type?: ImageFormat; /** * Quality of the image, between 0-100. Not applicable to `png` images. */ quality?: number; /** * Capture the screenshot from the surface, rather than the view. * * @defaultValue `true` */ fromSurface?: boolean; /** * When `true`, takes a screenshot of the full page. * * @defaultValue `false` */ fullPage?: boolean; /** * Hides default white background and allows capturing screenshots with transparency. * * @defaultValue `false` */ omitBackground?: boolean; /** * The file path to save the image to. The screenshot type will be inferred * from file extension. If path is a relative path, then it is resolved * relative to current working directory. If no path is provided, the image * won't be saved to the disk. */ path?: string; /** * Specifies the region of the page/element to clip. */ clip?: ScreenshotClip; /** * Encoding of the image. * * @defaultValue `'binary'` */ encoding?: 'base64' | 'binary'; /** * Capture the screenshot beyond the viewport. * * @defaultValue `false` if there is no `clip`. `true` otherwise. */ captureBeyondViewport?: boolean; } /** * @public * @experimental */ export interface ScreencastOptions { /** * File path to save the screencast to. */ path?: `${string}.${VideoFormat}`; /** * Specifies whether to overwrite output file, * or exit immediately if it already exists. * * @defaultValue `true` */ overwrite?: boolean; /** * Specifies the output file format. * * @defaultValue `'webm'` */ format?: VideoFormat; /** * Specifies the region of the viewport to crop. */ crop?: BoundingBox; /** * Scales the output video. * * For example, `0.5` will shrink the width and height of the output video by * half. `2` will double the width and height of the output video. * * @defaultValue `1` */ scale?: number; /** * Specifies the speed to record at. * * For example, `0.5` will slowdown the output video by 50%. `2` will double the * speed of the output video. * * @defaultValue `1` */ speed?: number; /** * Specifies the frame rate in frames per second. * * @defaultValue `30` (`20` for GIF) */ fps?: number; /** * Specifies the number of times to loop playback, from `0` to `Infinity`. * A value of `0` or `undefined` will disable looping. * * @defaultValue `undefined` */ loop?: number; /** * Specifies the delay between iterations of a loop, in ms. * `-1` is a special value to re-use the previous delay. * * @defaultValue `-1` */ delay?: number; /** * Specifies the recording * {@link https://trac.ffmpeg.org/wiki/Encode/VP9#constantq | quality} * Constant Rate Factor between `0`–`63`. Lower values mean better quality. * * @defaultValue `30` */ quality?: number; /** * Specifies the maximum number of * {@link https://ffmpeg.org/ffmpeg-filters.html#palettegen | palette} * colors to quantize, with GIF limited to `256`. * Restrict the palette to only necessary colors to reduce output file size. * * @defaultValue `256` */ colors?: number; /** * Path to the {@link https://ffmpeg.org/ | ffmpeg}. * * Required if `ffmpeg` is not in your PATH. * * @defaultValue `'ffmpeg'` */ ffmpegPath?: string; } /** * @public */ export interface QueryOptions { /** * Whether to run the query in isolation. When returning many elements * from {@link Page.$$} or similar methods, it might be useful to turn * off the isolation to improve performance. By default, the querying * code will be executed in a separate sandbox realm. * * @defaultValue `true` */ isolate: boolean; } /** * All the events that a page instance may emit. * * @public */ export const enum PageEvent { /** * Emitted when the page closes. */ Close = 'close', /** * Emitted when JavaScript within the page calls one of console API methods, * e.g. `console.log` or `console.dir`. Also emitted if the page throws an * error or a warning. * * @remarks * A `console` event provides a {@link ConsoleMessage} representing the * console message that was logged. * * @example * An example of handling `console` event: * * ```ts * page.on('console', msg => { * for (let i = 0; i < msg.args().length; ++i) * console.log(`${i}: ${msg.args()[i]}`); * }); * page.evaluate(() => console.log('hello', 5, {foo: 'bar'})); * ``` */ Console = 'console', /** * Emitted when a JavaScript dialog appears, such as `alert`, `prompt`, * `confirm` or `beforeunload`. Puppeteer can respond to the dialog via * {@link Dialog.accept} or {@link Dialog.dismiss}. */ Dialog = 'dialog', /** * Emitted when the JavaScript * {@link https://developer.mozilla.org/en-US/docs/Web/Events/DOMContentLoaded | DOMContentLoaded } * event is dispatched. */ DOMContentLoaded = 'domcontentloaded', /** * Emitted when a DevTools issue is reported. * @experimental */ Issue = 'issue', /** * Emitted when the page crashes. Will contain an `Error`. */ Error = 'error', /** Emitted when a frame is attached. Will contain a {@link Frame}. */ FrameAttached = 'frameattached', /** Emitted when a frame is detached. Will contain a {@link Frame}. */ FrameDetached = 'framedetached', /** * Emitted when a frame is navigated to a new URL. Will contain a * {@link Frame}. */ FrameNavigated = 'framenavigated', /** * Emitted when the JavaScript * {@link https://developer.mozilla.org/en-US/docs/Web/Events/load | load} * event is dispatched. */ Load = 'load', /** * Emitted when the JavaScript code makes a call to `console.timeStamp`. For * the list of metrics see {@link Page.metrics | page.metrics}. * * @remarks * Contains an object with two properties: * * - `title`: the title passed to `console.timeStamp` * - `metrics`: object containing metrics as key/value pairs. The values will * be `number`s. */ Metrics = 'metrics', /** * Emitted when an uncaught exception happens within the page. Contains an * `Error` or data of type unknown. */ PageError = 'pageerror', /** * Emitted when the page opens a new tab or window. * * Contains a {@link Page} corresponding to the popup window. * * @example * * ```ts * const [popup] = await Promise.all([ * new Promise(resolve => page.once('popup', resolve)), * page.click('a[target=_blank]'), * ]); * ``` * * ```ts * const [popup] = await Promise.all([ * new Promise(resolve => page.once('popup', resolve)), * page.evaluate(() => window.open('https://example.com')), * ]); * ``` */ Popup = 'popup', /** * Emitted when a page issues a request and contains a {@link HTTPRequest}. * * @remarks * The object is readonly. See {@link Page.setRequestInterception} for * intercepting and mutating requests. */ Request = 'request', /** * Emitted when a request ended up loading from cache. Contains a * {@link HTTPRequest}. * * @remarks * For certain requests, might contain undefined. * {@link https://crbug.com/750469} */ RequestServedFromCache = 'requestservedfromcache', /** * Emitted when a request fails, for example by timing out. * * Contains a {@link HTTPRequest}. * * @remarks * HTTP Error responses, such as 404 or 503, are still successful responses * from HTTP standpoint, so request will complete with `requestfinished` event * and not with `requestfailed`. */ RequestFailed = 'requestfailed', /** * Emitted when a request finishes successfully. Contains a * {@link HTTPRequest}. */ RequestFinished = 'requestfinished', /** * Emitted when a response is received. Contains a {@link HTTPResponse}. */ Response = 'response', /** * Emitted when a dedicated * {@link https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API | WebWorker} * is spawned by the page. */ WorkerCreated = 'workercreated', /** * Emitted when a dedicated * {@link https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API | WebWorker} * is destroyed by the page. */ WorkerDestroyed = 'workerdestroyed', } /** * Denotes the objects received by callback functions for page events. * * See {@link PageEvent} for more detail on the events and when they are * emitted. * * @public */ export interface PageEvents extends Record { [PageEvent.Close]: undefined; [PageEvent.Console]: ConsoleMessage; [PageEvent.Dialog]: Dialog; [PageEvent.DOMContentLoaded]: undefined; [PageEvent.Issue]: Issue; [PageEvent.Error]: Error; [PageEvent.FrameAttached]: Frame; [PageEvent.FrameDetached]: Frame; [PageEvent.FrameNavigated]: Frame; [PageEvent.Load]: undefined; [PageEvent.Metrics]: {title: string; metrics: Metrics}; [PageEvent.PageError]: Error | unknown; [PageEvent.Popup]: Page | null; [PageEvent.Request]: HTTPRequest; [PageEvent.Response]: HTTPResponse; [PageEvent.RequestFailed]: HTTPRequest; [PageEvent.RequestFinished]: HTTPRequest; [PageEvent.RequestServedFromCache]: HTTPRequest; [PageEvent.WorkerCreated]: WebWorker; [PageEvent.WorkerDestroyed]: WebWorker; } /** * @public */ export interface NewDocumentScriptEvaluation { identifier: string; } /** * @internal */ export function setDefaultScreenshotOptions(options: ScreenshotOptions): void { options.optimizeForSpeed ??= false; options.type ??= 'png'; options.fromSurface ??= true; options.fullPage ??= false; options.omitBackground ??= false; options.encoding ??= 'binary'; options.captureBeyondViewport ??= true; } /** * @public */ export interface ReloadOptions extends WaitForOptions { /** * If set to true, the browser caches are ignored for the page reload. * * @defaultValue true * @public */ ignoreCache?: boolean; } /** * Options for {@link Page.captureHeapSnapshot}. * * @public */ export interface HeapSnapshotOptions { /** * The file path to save the heap snapshot to. */ path: string; } /** * Page provides methods to interact with a single tab or * {@link https://developer.chrome.com/extensions/background_pages | extension background page} * in the browser. * * :::note * * One Browser instance might have multiple Page instances. * * ::: * * @example * This example creates a page, navigates it to a URL, and then saves a screenshot: * * ```ts * import puppeteer from 'puppeteer'; * * const browser = await puppeteer.launch(); * const page = await browser.newPage(); * await page.goto('https://example.com'); * await page.screenshot({path: 'screenshot.png'}); * await browser.close(); * ``` * * The Page class extends from Puppeteer's {@link EventEmitter} class and will * emit various events which are documented in the {@link PageEvent} enum. * * @example * This example logs a message for a single page `load` event: * * ```ts * page.once('load', () => console.log('Page loaded!')); * ``` * * To unsubscribe from events use the {@link EventEmitter.off} method: * * ```ts * function logRequest(interceptedRequest) { * console.log('A request was made:', interceptedRequest.url()); * } * page.on('request', logRequest); * // Sometime later... * page.off('request', logRequest); * ``` * * @public */ export abstract class Page extends EventEmitter { /** * @internal */ _isDragging = false; /** * @internal */ _timeoutSettings = new TimeoutSettings(); /** * Internal API to get an implementation-specific identifier * for the tab. In Chrome, it is a tab target id. If unknown, * returns an empty string. * * @internal */ _tabId = ''; #requestHandlers = new WeakMap, Handler>(); #inflight$ = new ReplaySubject(1); /** * @internal */ constructor() { super(); fromEmitterEvent(this, PageEvent.Request) .pipe( mergeMap(originalRequest => { return concat( of(1), merge( fromEmitterEvent(this, PageEvent.RequestFailed), fromEmitterEvent(this, PageEvent.RequestFinished), fromEmitterEvent(this, PageEvent.Response).pipe( map(response => { return response.request(); }), ), ).pipe( filter(request => { return request.id === originalRequest.id; }), take(1), map(() => { return -1; }), ), ); }), mergeScan((acc, addend) => { return of(acc + addend); }, 0), takeUntil(fromEmitterEvent(this, PageEvent.Close)), startWith(0), ) .subscribe(this.#inflight$); } /** * `true` if the service worker are being bypassed, `false` otherwise. */ abstract isServiceWorkerBypassed(): boolean; /** * `true` if drag events are being intercepted, `false` otherwise. * * @deprecated We no longer support intercepting drag payloads. Use the new * drag APIs found on {@link ElementHandle} to drag (or just use the * {@link Page.mouse}). */ abstract isDragInterceptionEnabled(): boolean; /** * `true` if the page has JavaScript enabled, `false` otherwise. */ abstract isJavaScriptEnabled(): boolean; /** * Listen to page events. * * @remarks * This method exists to define event typings and handle proper wireup of * cooperative request interception. Actual event listening and dispatching is * delegated to {@link EventEmitter}. * * @internal */ override on>( type: K, handler: (event: EventsWithWildcard[K]) => void, ): this { if (type !== PageEvent.Request) { return super.on(type, handler); } let wrapper = this.#requestHandlers.get( handler as (event: PageEvents[PageEvent.Request]) => void, ); if (wrapper === undefined) { wrapper = (event: HTTPRequest) => { event.enqueueInterceptAction(() => { return handler(event as EventsWithWildcard[K]); }); }; this.#requestHandlers.set( handler as (event: PageEvents[PageEvent.Request]) => void, wrapper, ); } return super.on( type, wrapper as (event: EventsWithWildcard[K]) => void, ); } /** * @internal */ override off>( type: K, handler: (event: EventsWithWildcard[K]) => void, ): this { if (type === PageEvent.Request) { handler = (this.#requestHandlers.get( handler as ( event: EventsWithWildcard[PageEvent.Request], ) => void, ) as (event: EventsWithWildcard[K]) => void) || handler; } return super.off(type, handler); } /** * This method is typically coupled with an action that triggers file * choosing. * * :::caution * * This must be called before the file chooser is launched. It will not return * a currently active file chooser. * * ::: * * :::caution * * Interception of file dialogs triggered via DOM APIs such as * window.showOpenFilePicker is currently not supported. * * ::: * * @remarks * In the "headful" browser, this method results in the native file picker * dialog `not showing up` for the user. * * @example * The following example clicks a button that issues a file chooser * and then responds with `/tmp/myfile.pdf` as if a user has selected this file. * * ```ts * const [fileChooser] = await Promise.all([ * page.waitForFileChooser(), * page.click('#upload-file-button'), * // some button that triggers file selection * ]); * await fileChooser.accept(['/tmp/myfile.pdf']); * ``` */ abstract waitForFileChooser( options?: WaitTimeoutOptions, ): Promise; /** * Sets the page's geolocation. * * @remarks * Consider using {@link BrowserContext.overridePermissions} to grant * permissions for the page to read its geolocation. * * @example * * ```ts * await page.setGeolocation({latitude: 59.95, longitude: 30.31667}); * ``` */ abstract setGeolocation(options: GeolocationOptions): Promise; /** * A target this page was created from. * * @deprecated Use {@link Page.createCDPSession} directly. */ abstract target(): Target; /** * Get the browser the page belongs to. */ abstract browser(): Browser; /** * Get the browser context that the page belongs to. */ abstract browserContext(): BrowserContext; /** * The page's main frame. */ abstract mainFrame(): Frame; /** * Creates a Chrome Devtools Protocol session attached to the page. */ abstract createCDPSession(): Promise; /** * {@inheritDoc Keyboard} */ abstract get keyboard(): Keyboard; /** * {@inheritDoc Touchscreen} */ abstract get touchscreen(): Touchscreen; /** * {@inheritDoc Coverage} */ abstract get coverage(): Coverage; /** * {@inheritDoc Tracing} */ abstract get tracing(): Tracing; /** * Experimental API for {@link https://github.com/webmachinelearning/webmcp * | WebMCP}. Requires Chrome 149+ with the * `--enable-features=WebMCPTesting,DevToolsWebMCPSupport` flags enabled. * * @experimental */ abstract get webmcp(): WebMCP; /** * {@inheritDoc Accessibility} */ get accessibility(): Accessibility { return this.mainFrame().accessibility; } /** * An array of all frames attached to the page. */ abstract frames(): Frame[]; /** * All of the dedicated {@link * https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API | * WebWorkers} associated with the page. * * @remarks * This does not contain ServiceWorkers */ abstract workers(): WebWorker[]; /** * Activating request interception enables {@link HTTPRequest.abort}, * {@link HTTPRequest.continue} and {@link HTTPRequest.respond} methods. This * provides the capability to modify network requests that are made by a page. * * Once request interception is enabled, every request will stall unless it's * continued, responded or aborted; or completed using the browser cache. * * See the * {@link https://pptr.dev/guides/network-interception|Request interception guide} * for more details. * * @example * An example of a naïve request interceptor that aborts all image requests: * * ```ts * import puppeteer from 'puppeteer'; * const browser = await puppeteer.launch(); * const page = await browser.newPage(); * await page.setRequestInterception(true); * page.on('request', interceptedRequest => { * if ( * interceptedRequest.url().endsWith('.png') || * interceptedRequest.url().endsWith('.jpg') * ) * interceptedRequest.abort(); * else interceptedRequest.continue(); * }); * await page.goto('https://example.com'); * await browser.close(); * ``` * * @param value - Whether to enable request interception. */ abstract setRequestInterception(value: boolean): Promise; /** * Toggles ignoring of service worker for each request. * * @param bypass - Whether to bypass service worker and load from network. */ abstract setBypassServiceWorker(bypass: boolean): Promise; /** * @param enabled - Whether to enable drag interception. * * @deprecated We no longer support intercepting drag payloads. Use the new * drag APIs found on {@link ElementHandle} to drag (or just use the * {@link Page.mouse}). */ abstract setDragInterception(enabled: boolean): Promise; /** * Emulates the offline mode. * * It does not change the download/upload/latency parameters set by * {@link Page.emulateNetworkConditions} * * @param enabled - When `true`, enables offline mode for the page. */ abstract setOfflineMode(enabled: boolean): Promise; /** * This does not affect WebSockets and WebRTC PeerConnections (see * https://crbug.com/563644). To set the page offline, you can use * {@link Page.setOfflineMode}. * * A list of predefined network conditions can be used by importing * {@link PredefinedNetworkConditions}. * * @example * * ```ts * import {PredefinedNetworkConditions} from 'puppeteer'; * const slow3G = PredefinedNetworkConditions['Slow 3G']; * * const browser = await puppeteer.launch(); * const page = await browser.newPage(); * await page.emulateNetworkConditions(slow3G); * await page.goto('https://www.google.com'); * // other actions... * await browser.close(); * ``` * * @param networkConditions - Passing `null` disables network condition * emulation. */ abstract emulateNetworkConditions( networkConditions: NetworkConditions | null, ): Promise; /** * This setting will change the default maximum navigation time for the * following methods and related shortcuts: * * - {@link Page.goBack | page.goBack(options)} * * - {@link Page.goForward | page.goForward(options)} * * - {@link Page.goto | page.goto(url,options)} * * - {@link Page.reload | page.reload(options)} * * - {@link Page.setContent | page.setContent(html,options)} * * - {@link Page.waitForNavigation | page.waitForNavigation(options)} * @param timeout - Maximum navigation time in milliseconds. */ abstract setDefaultNavigationTimeout(timeout: number): void; /** * @param timeout - Maximum time in milliseconds. */ abstract setDefaultTimeout(timeout: number): void; /** * Maximum time in milliseconds. */ abstract getDefaultTimeout(): number; /** * Maximum navigation time in milliseconds. */ abstract getDefaultNavigationTimeout(): number; /** * Creates a locator for the provided selector. See {@link Locator} for * details and supported actions. * * @param selector - * {@link https://pptr.dev/guides/page-interactions#selectors | selector} * to query the page for. * {@link https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_Selectors | CSS selectors} * can be passed as-is and a * {@link https://pptr.dev/guides/page-interactions#non-css-selectors | Puppeteer-specific selector syntax} * allows querying by * {@link https://pptr.dev/guides/page-interactions#text-selectors--p-text | text}, * {@link https://pptr.dev/guides/page-interactions#aria-selectors--p-aria | a11y role and name}, * and * {@link https://pptr.dev/guides/page-interactions#xpath-selectors--p-xpath | xpath} * and * {@link https://pptr.dev/guides/page-interactions#querying-elements-in-shadow-dom | combining these queries across shadow roots}. * Alternatively, you can specify the selector type using a * {@link https://pptr.dev/guides/page-interactions#prefixed-selector-syntax | prefix}. */ locator( selector: Selector, ): Locator>; /** * Creates a locator for the provided function. See {@link Locator} for * details and supported actions. * * @param selector - * {@link https://pptr.dev/guides/page-interactions#selectors | selector} * to query the page for. * {@link https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_Selectors | CSS selectors} * can be passed as-is and a * {@link https://pptr.dev/guides/page-interactions#non-css-selectors | Puppeteer-specific selector syntax} * allows querying by * {@link https://pptr.dev/guides/page-interactions#text-selectors--p-text | text}, * {@link https://pptr.dev/guides/page-interactions#aria-selectors--p-aria | a11y role and name}, * and * {@link https://pptr.dev/guides/page-interactions#xpath-selectors--p-xpath | xpath} * and * {@link https://pptr.dev/guides/page-interactions#querying-elements-in-shadow-dom | combining these queries across shadow roots}. * Alternatively, you can specify the selector type using a * {@link https://pptr.dev/guides/page-interactions#prefixed-selector-syntax | prefix}. */ locator(func: () => Awaitable): Locator; locator( input: Selector | (() => Awaitable), ): Locator> | Locator | Locator { if (typeof input === 'string') { return NodeLocator.create(this, input); } else { return FunctionLocator.create(this, input); } } /** * A shortcut for {@link Locator.race} that does not require static imports. * * @internal */ locatorRace( locators: Locators, ): Locator> { return Locator.race(locators); } /** * Finds the first element that matches the selector. If no element matches * the selector, the return value resolves to `null`. * * @param selector - * {@link https://pptr.dev/guides/page-interactions#selectors | selector} * to query the page for. * {@link https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_Selectors | CSS selectors} * can be passed as-is and a * {@link https://pptr.dev/guides/page-interactions#non-css-selectors | Puppeteer-specific selector syntax} * allows querying by * {@link https://pptr.dev/guides/page-interactions#text-selectors--p-text | text}, * {@link https://pptr.dev/guides/page-interactions#aria-selectors--p-aria | a11y role and name}, * and * {@link https://pptr.dev/guides/page-interactions#xpath-selectors--p-xpath | xpath} * and * {@link https://pptr.dev/guides/page-interactions#querying-elements-in-shadow-dom | combining these queries across shadow roots}. * Alternatively, you can specify the selector type using a * {@link https://pptr.dev/guides/page-interactions#prefixed-selector-syntax | prefix}. * * @remarks * * Shortcut for {@link Frame.$ | Page.mainFrame().$(selector) }. */ async $( selector: Selector, ): Promise> | null> { return await this.mainFrame().$(selector); } /** * Finds elements on the page that match the selector. If no elements * match the selector, the return value resolves to `[]`. * * @param selector - * {@link https://pptr.dev/guides/page-interactions#selectors | selector} * to query the page for. * {@link https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_Selectors | CSS selectors} * can be passed as-is and a * {@link https://pptr.dev/guides/page-interactions#non-css-selectors | Puppeteer-specific selector syntax} * allows querying by * {@link https://pptr.dev/guides/page-interactions#text-selectors--p-text | text}, * {@link https://pptr.dev/guides/page-interactions#aria-selectors--p-aria | a11y role and name}, * and * {@link https://pptr.dev/guides/page-interactions#xpath-selectors--p-xpath | xpath} * and * {@link https://pptr.dev/guides/page-interactions#querying-elements-in-shadow-dom | combining these queries across shadow roots}. * Alternatively, you can specify the selector type using a * {@link https://pptr.dev/guides/page-interactions#prefixed-selector-syntax | prefix}. * * @remarks * * Shortcut for {@link Frame.$$ | Page.mainFrame().$$(selector) }. */ async $$( selector: Selector, options?: QueryOptions, ): Promise>>> { return await this.mainFrame().$$(selector, options); } /** * @remarks * * The only difference between {@link Page.evaluate | page.evaluate} and * `page.evaluateHandle` is that `evaluateHandle` will return the value * wrapped in an in-page object. * * If the function passed to `page.evaluateHandle` returns a Promise, the * function will wait for the promise to resolve and return its value. * * You can pass a string instead of a function (although functions are * recommended as they are easier to debug and use with TypeScript): * * @example * * ```ts * const aHandle = await page.evaluateHandle('document'); * ``` * * @example * {@link JSHandle} instances can be passed as arguments to the `pageFunction`: * * ```ts * const aHandle = await page.evaluateHandle(() => document.body); * const resultHandle = await page.evaluateHandle( * body => body.innerHTML, * aHandle, * ); * console.log(await resultHandle.jsonValue()); * await resultHandle.dispose(); * ``` * * Most of the time this function returns a {@link JSHandle}, * but if `pageFunction` returns a reference to an element, * you instead get an {@link ElementHandle} back: * * @example * * ```ts * const button = await page.evaluateHandle(() => * document.querySelector('button'), * ); * // can call `click` because `button` is an `ElementHandle` * await button.click(); * ``` * * The TypeScript definitions assume that `evaluateHandle` returns * a `JSHandle`, but if you know it's going to return an * `ElementHandle`, pass it as the generic argument: * * ```ts * const button = await page.evaluateHandle(...); * ``` * * @param pageFunction - a function that is run within the page * @param args - arguments to be passed to the pageFunction */ async evaluateHandle< Params extends unknown[], Func extends EvaluateFunc = EvaluateFunc, >( pageFunction: Func | string, ...args: Params ): Promise>>> { pageFunction = withSourcePuppeteerURLIfNone( this.evaluateHandle.name, pageFunction, ); return await this.mainFrame().evaluateHandle(pageFunction, ...args); } /** * This method iterates the JavaScript heap and finds all objects with the * given prototype. * * @example * * ```ts * // Create a Map object * await page.evaluate(() => (window.map = new Map())); * // Get a handle to the Map object prototype * const mapPrototype = await page.evaluateHandle(() => Map.prototype); * // Query all map instances into an array * const mapInstances = await page.queryObjects(mapPrototype); * // Count amount of map objects in heap * const count = await page.evaluate(maps => maps.length, mapInstances); * await mapInstances.dispose(); * await mapPrototype.dispose(); * ``` * * @param prototypeHandle - a handle to the object prototype. * @returns Promise which resolves to a handle to an array of objects with * this prototype. */ abstract queryObjects( prototypeHandle: JSHandle, ): Promise>; /** * This method finds the first element within the page that matches the selector * and passes the result as the first argument to the `pageFunction`. * * @remarks * * If no element is found matching `selector`, the method will throw an error. * * If `pageFunction` returns a promise `$eval` will wait for the promise to * resolve and then return its value. * * @example * * ```ts * const searchValue = await page.$eval('#search', el => el.value); * const preloadHref = await page.$eval('link[rel=preload]', el => el.href); * const html = await page.$eval('.main-container', el => el.outerHTML); * ``` * * If you are using TypeScript, you may have to provide an explicit type to the * first argument of the `pageFunction`. * By default it is typed as `Element`, but you may need to provide a more * specific sub-type: * * @example * * ```ts * // if you don't provide HTMLInputElement here, TS will error * // as `value` is not on `Element` * const searchValue = await page.$eval( * '#search', * (el: HTMLInputElement) => el.value, * ); * ``` * * The compiler should be able to infer the return type * from the `pageFunction` you provide. If it is unable to, you can use the generic * type to tell the compiler what return type you expect from `$eval`: * * @example * * ```ts * // The compiler can infer the return type in this case, but if it can't * // or if you want to be more explicit, provide it as the generic type. * const searchValue = await page.$eval( * '#search', * (el: HTMLInputElement) => el.value, * ); * ``` * * @param selector - * {@link https://pptr.dev/guides/page-interactions#selectors | selector} * to query the page for. * {@link https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_Selectors | CSS selectors} * can be passed as-is and a * {@link https://pptr.dev/guides/page-interactions#non-css-selectors | Puppeteer-specific selector syntax} * allows querying by * {@link https://pptr.dev/guides/page-interactions#text-selectors--p-text | text}, * {@link https://pptr.dev/guides/page-interactions#aria-selectors--p-aria | a11y role and name}, * and * {@link https://pptr.dev/guides/page-interactions#xpath-selectors--p-xpath | xpath} * and * {@link https://pptr.dev/guides/page-interactions#querying-elements-in-shadow-dom | combining these queries across shadow roots}. * Alternatively, you can specify the selector type using a * {@link https://pptr.dev/guides/page-interactions#prefixed-selector-syntax | prefix}. * @param pageFunction - the function to be evaluated in the page context. * Will be passed the result of the element matching the selector as its * first argument. * @param args - any additional arguments to pass through to `pageFunction`. * * @returns The result of calling `pageFunction`. If it returns an element it * is wrapped in an {@link ElementHandle}, else the raw value itself is * returned. */ async $eval< Selector extends string, Params extends unknown[], Func extends EvaluateFuncWith, Params> = EvaluateFuncWith< NodeFor, Params >, >( selector: Selector, pageFunction: Func | string, ...args: Params ): Promise>> { pageFunction = withSourcePuppeteerURLIfNone(this.$eval.name, pageFunction); return await this.mainFrame().$eval(selector, pageFunction, ...args); } /** * This method returns all elements matching the selector and passes the * resulting array as the first argument to the `pageFunction`. * * @remarks * If `pageFunction` returns a promise `$$eval` will wait for the promise to * resolve and then return its value. * * @example * * ```ts * // get the amount of divs on the page * const divCount = await page.$$eval('div', divs => divs.length); * * // get the text content of all the `.options` elements: * const options = await page.$$eval('div > span.options', options => { * return options.map(option => option.textContent); * }); * ``` * * If you are using TypeScript, you may have to provide an explicit type to the * first argument of the `pageFunction`. * By default it is typed as `Element[]`, but you may need to provide a more * specific sub-type: * * @example * * ```ts * await page.$$eval('input', elements => { * return elements.map(e => e.value); * }); * ``` * * The compiler should be able to infer the return type * from the `pageFunction` you provide. If it is unable to, you can use the generic * type to tell the compiler what return type you expect from `$$eval`: * * @example * * ```ts * const allInputValues = await page.$$eval('input', elements => * elements.map(e => e.textContent), * ); * ``` * * @param selector - * {@link https://pptr.dev/guides/page-interactions#selectors | selector} * to query the page for. * {@link https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_Selectors | CSS selectors} * can be passed as-is and a * {@link https://pptr.dev/guides/page-interactions#non-css-selectors | Puppeteer-specific selector syntax} * allows querying by * {@link https://pptr.dev/guides/page-interactions#text-selectors--p-text | text}, * {@link https://pptr.dev/guides/page-interactions#aria-selectors--p-aria | a11y role and name}, * and * {@link https://pptr.dev/guides/page-interactions#xpath-selectors--p-xpath | xpath} * and * {@link https://pptr.dev/guides/page-interactions#querying-elements-in-shadow-dom | combining these queries across shadow roots}. * Alternatively, you can specify the selector type using a * {@link https://pptr.dev/guides/page-interactions#prefixed-selector-syntax | prefix}. * @param pageFunction - the function to be evaluated in the page context. * Will be passed an array of matching elements as its first argument. * @param args - any additional arguments to pass through to `pageFunction`. * * @returns The result of calling `pageFunction`. If it returns an element it * is wrapped in an {@link ElementHandle}, else the raw value itself is * returned. */ async $$eval< Selector extends string, Params extends unknown[], Func extends EvaluateFuncWith>, Params> = EvaluateFuncWith>, Params>, >( selector: Selector, pageFunction: Func | string, ...args: Params ): Promise>> { pageFunction = withSourcePuppeteerURLIfNone(this.$$eval.name, pageFunction); return await this.mainFrame().$$eval(selector, pageFunction, ...args); } /** * If no URLs are specified, this method returns cookies for the * current page URL. If URLs are specified, only cookies for those * URLs are returned. * * @deprecated Page-level cookie API is deprecated. Use * {@link Browser.cookies} or {@link BrowserContext.cookies} instead. */ abstract cookies(...urls: string[]): Promise; /** * @deprecated Page-level cookie API is deprecated. Use * {@link Browser.deleteCookie}, {@link BrowserContext.deleteCookie}, * {@link Browser.deleteMatchingCookies} or {@link BrowserContext.deleteMatchingCookies} * instead. */ abstract deleteCookie(...cookies: DeleteCookiesRequest[]): Promise; /** * @example * *```ts * await page.setCookie(cookieObject1, cookieObject2); *``` * * @deprecated Page-level cookie API is deprecated. Use * {@link Browser.setCookie} or {@link BrowserContext.setCookie} * instead. */ abstract setCookie(...cookies: CookieParam[]): Promise; /** * Adds a `