123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199/** * Copyright 2017 Google Inc. All rights reserved. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */import { Protocol } from "../../vendor/devtools-protocol/types/protocol.d.ts";import { Accessibility } from "./Accessibility.js";import { Browser, BrowserContext } from "./Browser.js";import { CDPSession } from "./Connection.js";import { ConsoleMessage } from "./ConsoleMessage.js";import { Coverage } from "./Coverage.js";import { Dialog } from "./Dialog.js";import { WaitForSelectorOptions } from "./IsolatedWorld.js";import { ElementHandle } from "./ElementHandle.js";import { EventEmitter } from "./EventEmitter.js";import { FileChooser } from "./FileChooser.js";import { Frame } from "./Frame.js";import { HTTPRequest } from "./HTTPRequest.js";import { HTTPResponse } from "./HTTPResponse.js";import { Keyboard, Mouse, MouseButton, Touchscreen } from "./Input.js";import { JSHandle } from "./JSHandle.js";import { PuppeteerLifeCycleEvent } from "./LifecycleWatcher.js";import { Credentials, NetworkConditions } from "./NetworkManager.js";import { PDFOptions } from "./PDFOptions.js";import { Viewport } from "./PuppeteerViewport.js";import { Target } from "./Target.js";import { TaskQueue } from "./TaskQueue.js";import { Tracing } from "./Tracing.js";import { EvaluateFunc, HandleFor, NodeFor } from "./types.js";import { 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 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 `30000` */ timeout?: number;}/** * @public */export interface WaitForOptions { /** * Maximum wait time in milliseconds. Pass 0 to disable the timeout. * * The default value can be changed by using the * {@link Page.setDefaultTimeout} or {@link Page.setDefaultNavigationTimeout} * methods. * * @defaultValue `30000` */ timeout?: number; waitUntil?: PuppeteerLifeCycleEvent | PuppeteerLifeCycleEvent[];}/** * @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;}/** * @public */export interface MediaFeature { name: string; value: string;}/** * @public */export interface ScreenshotClip { x: number; y: number; width: number; height: number;}/** * @public */export interface ScreenshotOptions { /** * @defaultValue `png` */ type?: "png" | "jpeg" | "webp"; /** * 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; /** * When `true`, takes a screenshot of the full page. * @defaultValue `false` */ fullPage?: boolean; /** * An object which specifies the clipping region of the page. */ clip?: ScreenshotClip; /** * Quality of the image, between 0-100. Not applicable to `png` images. */ quality?: number; /** * Hides default white background and allows capturing screenshots with transparency. * @defaultValue `false` */ omitBackground?: boolean; /** * Encoding of the image. * @defaultValue `binary` */ encoding?: "base64" | "binary"; /** * Capture the screenshot beyond the viewport. * @defaultValue `true` */ captureBeyondViewport?: boolean; /** * Capture the screenshot from the surface, rather than the view. * @defaultValue `true` */ fromSurface?: boolean;}/** * All the events that a page instance may emit. * * @public */export declare const enum PageEmittedEvents { /** * Emitted when the page closes. * @eventProperty */ 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 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`: objec 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`. */ 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 PageEmittedEvents} for more detail on the events and when they are * emitted. * * @public */export interface PageEventObject { close: never; console: ConsoleMessage; dialog: Dialog; domcontentloaded: never; error: Error; frameattached: Frame; framedetached: Frame; framenavigated: Frame; load: never; metrics: { title: string; metrics: Metrics; }; pageerror: Error; popup: Page; request: HTTPRequest; response: HTTPResponse; requestfailed: HTTPRequest; requestfinished: HTTPRequest; requestservedfromcache: HTTPRequest; workercreated: WebWorker; workerdestroyed: WebWorker;}/** * Page provides methods to interact with a single tab or * {@link https://developer.chrome.com/extensions/background_pages | extension background page} * in Chromium. * * :::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 * const puppeteer = require('puppeteer'); * * (async () => { * 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 PageEmittedEvents} 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 Page.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 declare class Page extends EventEmitter { #private; /** * @internal */ static _create( client: CDPSession, target: Target, ignoreHTTPSErrors: boolean, defaultViewport: Viewport | null, screenshotTaskQueue: TaskQueue, ): Promise<Page>; /** * @internal */ constructor( client: CDPSession, target: Target, ignoreHTTPSErrors: boolean, screenshotTaskQueue: TaskQueue, ); /** * @returns `true` if drag events are being intercepted, `false` otherwise. */ isDragInterceptionEnabled(): boolean; /** * @returns `true` if the page has JavaScript enabled, `false` otherwise. */ isJavaScriptEnabled(): boolean; /** * Listen to page events. * * :::note * * 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}. * * ::: */ on<K extends keyof PageEventObject>( eventName: K, handler: (event: PageEventObject[K]) => void, ): EventEmitter; once<K extends keyof PageEventObject>( eventName: K, handler: (event: PageEventObject[K]) => void, ): EventEmitter; off<K extends keyof PageEventObject>( eventName: K, handler: (event: PageEventObject[K]) => void, ): EventEmitter; /** * 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. * * ::: * * @remarks * In non-headless Chromium, 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']); * ``` */ waitForFileChooser(options?: WaitTimeoutOptions): Promise<FileChooser>; /** * 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}); * ``` */ setGeolocation(options: GeolocationOptions): Promise<void>; /** * @returns A target this page was created from. */ target(): Target; /** * @internal */ _client(): CDPSession; /** * Get the browser the page belongs to. */ browser(): Browser; /** * Get the browser context that the page belongs to. */ browserContext(): BrowserContext; /** * @returns The page's main frame. * * @remarks * Page is guaranteed to have a main frame which persists during navigations. */ mainFrame(): Frame; get keyboard(): Keyboard; get touchscreen(): Touchscreen; get coverage(): Coverage; get tracing(): Tracing; get accessibility(): Accessibility; /** * @returns An array of all frames attached to the page. */ frames(): Frame[]; /** * @returns 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 */ 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. * * Enabling request interception disables page caching. * * See the * {@link https://pptr.dev/next/guides/request-interception|Request interception guide} * for more details. * * @example * An example of a naïve request interceptor that aborts all image requests: * * ```ts * const puppeteer = require('puppeteer'); * (async () => { * 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. */ setRequestInterception(value: boolean): Promise<void>; /** * @param enabled - Whether to enable drag interception. * * @remarks * Activating drag interception enables the `Input.drag`, * methods This provides the capability to capture drag events emitted * on the page, which can then be used to simulate drag-and-drop. */ setDragInterception(enabled: boolean): Promise<void>; /** * @param enabled - When `true`, enables offline mode for the page. * @remarks * NOTE: while this method sets the network connection to offline, it does * not change the parameters used in [page.emulateNetworkConditions(networkConditions)] * (#pageemulatenetworkconditionsnetworkconditions) */ setOfflineMode(enabled: boolean): Promise<void>; /** * @param networkConditions - Passing `null` disables network condition emulation. * @example * * ```ts * const puppeteer = require('puppeteer'); * const slow3G = puppeteer.networkConditions['Slow 3G']; * * (async () => { * 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(); * })(); * ``` * * @remarks * NOTE: This does not affect WebSockets and WebRTC PeerConnections (see * https://crbug.com/563644). To set the page offline, you can use * [page.setOfflineMode(enabled)](#pagesetofflinemodeenabled). */ emulateNetworkConditions( networkConditions: NetworkConditions | null, ): Promise<void>; /** * 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. */ setDefaultNavigationTimeout(timeout: number): void; /** * @param timeout - Maximum time in milliseconds. */ setDefaultTimeout(timeout: number): void; /** * Runs `document.querySelector` within the page. If no element matches the * selector, the return value resolves to `null`. * * @param selector - A `selector` to query page for * {@link https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_Selectors | selector} * to query page for. */ $<Selector extends string>( selector: Selector, ): Promise<ElementHandle<NodeFor<Selector>> | null>; /** * The method runs `document.querySelectorAll` within the page. If no elements * match the selector, the return value resolves to `[]`. * @remarks * Shortcut for {@link Frame.$$ | Page.mainFrame().$$(selector) }. * @param selector - A `selector` to query page for */ $$<Selector extends string>( selector: Selector, ): Promise<Array<ElementHandle<NodeFor<Selector>>>>; /** * @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.evaluteHandle` 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<ElementHandle>(...); * ``` * * @param pageFunction - a function that is run within the page * @param args - arguments to be passed to the pageFunction */ evaluateHandle< Params extends unknown[], Func extends EvaluateFunc<Params> = EvaluateFunc<Params>, >( pageFunction: Func | string, ...args: Params ): Promise<HandleFor<Awaited<ReturnType<Func>>>>; /** * This method iterates the JavaScript heap and finds all objects with the * given prototype. * * @remarks * Shortcut for * {@link ExecutionContext.queryObjects | * page.mainFrame().executionContext().queryObjects(prototypeHandle)}. * * @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. */ queryObjects<Prototype>( prototypeHandle: JSHandle<Prototype>, ): Promise<JSHandle<Prototype[]>>; /** * This method runs `document.querySelector` within the page 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<string>( * '#search', * (el: HTMLInputElement) => el.value * ); * ``` * * @param selector - the * {@link https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_Selectors | selector} * to query for * @param pageFunction - the function to be evaluated in the page context. * Will be passed the result of `document.querySelector(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. */ $eval< Selector extends string, Params extends unknown[], Func extends EvaluateFunc<[ ElementHandle<NodeFor<Selector>>, ...Params, ]> = EvaluateFunc<[ElementHandle<NodeFor<Selector>>, ...Params]>, >( selector: Selector, pageFunction: Func | string, ...args: Params ): Promise<Awaited<ReturnType<Func>>>; /** * This method runs `Array.from(document.querySelectorAll(selector))` within * the page and passes the result 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 * // if you don't provide HTMLInputElement here, TS will error * // as `value` is not on `Element` * await page.$$eval('input', (elements: HTMLInputElement[]) => { * 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 * // 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 allInputValues = await page.$$eval<string[]>( * 'input', * (elements: HTMLInputElement[]) => elements.map(e => e.textContent) * ); * ``` * * @param selector - the * {@link https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_Selectors | selector} * to query for * @param pageFunction - the function to be evaluated in the page context. * Will be passed the result of * `Array.from(document.querySelectorAll(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. */ $$eval< Selector extends string, Params extends unknown[], Func extends EvaluateFunc<[ Array<NodeFor<Selector>>, ...Params, ]> = EvaluateFunc<[Array<NodeFor<Selector>>, ...Params]>, >( selector: Selector, pageFunction: Func | string, ...args: Params ): Promise<Awaited<ReturnType<Func>>>; /** * The method evaluates the XPath expression relative to the page document as * its context node. If there are no such elements, the method resolves to an * empty array. * * @remarks * Shortcut for {@link Frame.$x | Page.mainFrame().$x(expression) }. * * @param expression - Expression to evaluate */ $x(expression: string): Promise<Array<ElementHandle<any>>>; /** * 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. */ cookies(...urls: string[]): Promise<Protocol.Network.Cookie[]>; deleteCookie( ...cookies: Protocol.Network.DeleteCookiesRequest[] ): Promise<void>; /** * @example * * ```ts * await page.setCookie(cookieObject1, cookieObject2); * ``` */ setCookie(...cookies: Protocol.Network.CookieParam[]): Promise<void>; /** * Adds a `<script>` tag into the page with the desired URL or content. * * @remarks * Shortcut for * {@link Frame.addScriptTag | page.mainFrame().addScriptTag(options)}. * * @returns Promise which resolves to the added tag when the script's onload * fires or when the script content was injected into frame. */ addScriptTag(options: { url?: string; path?: string; content?: string; type?: string; id?: string; }): Promise<ElementHandle<any>>; /** * Adds a `<link rel="stylesheet">` tag into the page with the desired URL or a * `<style type="text/css">` tag with the content. * @returns Promise which resolves to the added tag when the stylesheet's * onload fires or when the CSS content was injected into frame. */ addStyleTag(options: { url?: string; path?: string; content?: string; }): Promise<ElementHandle<any>>; /** * The method adds a function called `name` on the page's `window` object. * When called, the function executes `puppeteerFunction` in node.js and * returns a `Promise` which resolves to the return value of * `puppeteerFunction`. * * If the puppeteerFunction returns a `Promise`, it will be awaited. * * :::note * * Functions installed via `page.exposeFunction` survive navigations. * * :::note * * @example * An example of adding an `md5` function into the page: * * ```ts * const puppeteer = require('puppeteer'); * const crypto = require('crypto'); * * (async () => { * const browser = await puppeteer.launch(); * const page = await browser.newPage(); * page.on('console', msg => console.log(msg.text())); * await page.exposeFunction('md5', text => * crypto.createHash('md5').update(text).digest('hex') * ); * await page.evaluate(async () => { * // use window.md5 to compute hashes * const myString = 'PUPPETEER'; * const myHash = await window.md5(myString); * console.log(`md5 of ${myString} is ${myHash}`); * }); * await browser.close(); * })(); * ``` * * @example * An example of adding a `window.readfile` function into the page: * * ```ts * const puppeteer = require('puppeteer'); * const fs = require('fs'); * * (async () => { * const browser = await puppeteer.launch(); * const page = await browser.newPage(); * page.on('console', msg => console.log(msg.text())); * await page.exposeFunction('readfile', async filePath => { * return new Promise((resolve, reject) => { * fs.readFile(filePath, 'utf8', (err, text) => { * if (err) reject(err); * else resolve(text); * }); * }); * }); * await page.evaluate(async () => { * // use window.readfile to read contents of a file * const content = await window.readfile('/etc/hosts'); * console.log(content); * }); * await browser.close(); * })(); * ``` * * @param name - Name of the function on the window object * @param pptrFunction - Callback function which will be called in Puppeteer's * context. */ exposeFunction( name: string, pptrFunction: Function | { default: Function; }, ): Promise<void>; /** * Provide credentials for `HTTP authentication`. * * @remarks * To disable authentication, pass `null`. */ authenticate(credentials: Credentials): Promise<void>; /** * The extra HTTP headers will be sent with every request the page initiates. * * :::tip * * All HTTP header names are lowercased. (HTTP headers are * case-insensitive, so this shouldn’t impact your server code.) * * ::: * * :::note * * page.setExtraHTTPHeaders does not guarantee the order of headers in * the outgoing requests. * * ::: * * @param headers - An object containing additional HTTP headers to be sent * with every request. All header values must be strings. */ setExtraHTTPHeaders(headers: Record<string, string>): Promise<void>; /** * @param userAgent - Specific user agent to use in this page * @param userAgentData - Specific user agent client hint data to use in this * page * @returns Promise which resolves when the user agent is set. */ setUserAgent( userAgent: string, userAgentMetadata?: Protocol.Emulation.UserAgentMetadata, ): Promise<void>; /** * @returns Object containing metrics as key/value pairs. * * - `Timestamp` : The timestamp when the metrics sample was taken. * * - `Documents` : Number of documents in the page. * * - `Frames` : Number of frames in the page. * * - `JSEventListeners` : Number of events in the page. * * - `Nodes` : Number of DOM nodes in the page. * * - `LayoutCount` : Total number of full or partial page layout. * * - `RecalcStyleCount` : Total number of page style recalculations. * * - `LayoutDuration` : Combined durations of all page layouts. * * - `RecalcStyleDuration` : Combined duration of all page style * recalculations. * * - `ScriptDuration` : Combined duration of JavaScript execution. * * - `TaskDuration` : Combined duration of all tasks performed by the browser. * * - `JSHeapUsedSize` : Used JavaScript heap size. * * - `JSHeapTotalSize` : Total JavaScript heap size. * * @remarks * All timestamps are in monotonic time: monotonically increasing time * in seconds since an arbitrary point in the past. */ metrics(): Promise<Metrics>; /** * @returns * @remarks Shortcut for * {@link Frame.url | page.mainFrame().url()}. */ url(): string; content(): Promise<string>; /** * @param html - HTML markup to assign to the page. * @param options - Parameters that has some properties. * @remarks * The parameter `options` might have the following options. * * - `timeout` : Maximum time in milliseconds for resources to load, defaults * to 30 seconds, pass `0` to disable timeout. The default value can be * changed by using the {@link Page.setDefaultNavigationTimeout} or * {@link Page.setDefaultTimeout} methods. * * - `waitUntil`: When to consider setting markup succeeded, defaults to * `load`. Given an array of event strings, setting content is considered * to be successful after all events have been fired. Events can be * either:<br/> * - `load` : consider setting content to be finished when the `load` event * is fired.<br/> * - `domcontentloaded` : consider setting content to be finished when the * `DOMContentLoaded` event is fired.<br/> * - `networkidle0` : consider setting content to be finished when there are * no more than 0 network connections for at least `500` ms.<br/> * - `networkidle2` : consider setting content to be finished when there are * no more than 2 network connections for at least `500` ms. */ setContent(html: string, options?: WaitForOptions): Promise<void>; /** * @param url - URL to navigate page to. The URL should include scheme, e.g. * `https://` * @param options - Navigation Parameter * @returns Promise which resolves to the main resource response. In case of * multiple redirects, the navigation will resolve with the response of the * last redirect. * @remarks * The argument `options` might have the following properties: * * - `timeout` : Maximum navigation time in milliseconds, defaults to 30 * seconds, pass 0 to disable timeout. The default value can be changed by * using the {@link Page.setDefaultNavigationTimeout} or * {@link Page.setDefaultTimeout} methods. * * - `waitUntil`:When to consider navigation succeeded, defaults to `load`. * Given an array of event strings, navigation is considered to be * successful after all events have been fired. Events can be either:<br/> * - `load` : consider navigation to be finished when the load event is * fired.<br/> * - `domcontentloaded` : consider navigation to be finished when the * DOMContentLoaded event is fired.<br/> * - `networkidle0` : consider navigation to be finished when there are no * more than 0 network connections for at least `500` ms.<br/> * - `networkidle2` : consider navigation to be finished when there are no * more than 2 network connections for at least `500` ms. * * - `referer` : Referer header value. If provided it will take preference * over the referer header value set by * {@link Page.setExtraHTTPHeaders |page.setExtraHTTPHeaders()}. * * `page.goto` will throw an error if: * * - there's an SSL error (e.g. in case of self-signed certificates). * - target URL is invalid. * - the timeout is exceeded during navigation. * - the remote server does not respond or is unreachable. * - the main resource failed to load. * * `page.goto` will not throw an error when any valid HTTP status code is * returned by the remote server, including 404 "Not Found" and 500 * "Internal Server Error". The status code for such responses can be * retrieved by calling response.status(). * * NOTE: `page.goto` either throws an error or returns a main resource * response. The only exceptions are navigation to about:blank or navigation * to the same URL with a different hash, which would succeed and return null. * * NOTE: Headless mode doesn't support navigation to a PDF document. See the * {@link https://bugs.chromium.org/p/chromium/issues/detail?id=761295 | * upstream issue}. * * Shortcut for {@link Frame.goto | page.mainFrame().goto(url, options)}. */ goto( url: string, options?: WaitForOptions & { referer?: string; }, ): Promise<HTTPResponse | null>; /** * @param options - Navigation parameters which might have the following * properties: * @returns Promise which resolves to the main resource response. In case of * multiple redirects, the navigation will resolve with the response of the * last redirect. * @remarks * The argument `options` might have the following properties: * * - `timeout` : Maximum navigation time in milliseconds, defaults to 30 * seconds, pass 0 to disable timeout. The default value can be changed by * using the {@link Page.setDefaultNavigationTimeout} or * {@link Page.setDefaultTimeout} methods. * * - `waitUntil`: When to consider navigation succeeded, defaults to `load`. * Given an array of event strings, navigation is considered to be * successful after all events have been fired. Events can be either:<br/> * - `load` : consider navigation to be finished when the load event is * fired.<br/> * - `domcontentloaded` : consider navigation to be finished when the * DOMContentLoaded event is fired.<br/> * - `networkidle0` : consider navigation to be finished when there are no * more than 0 network connections for at least `500` ms.<br/> * - `networkidle2` : consider navigation to be finished when there are no * more than 2 network connections for at least `500` ms. */ reload(options?: WaitForOptions): Promise<HTTPResponse | null>; /** * Waits for the page to navigate to a new URL or to reload. It is useful when * you run code that will indirectly cause the page to navigate. * * @example * * ```ts * const [response] = await Promise.all([ * page.waitForNavigation(), // The promise resolves after navigation has finished * page.click('a.my-link'), // Clicking the link will indirectly cause a navigation * ]); * ``` * * @remarks * Usage of the * {@link https://developer.mozilla.org/en-US/docs/Web/API/History_API | History API} * to change the URL is considered a navigation. * * @param options - Navigation parameters which might have the following * properties: * @returns A `Promise` which resolves to the main resource response. * * - In case of multiple redirects, the navigation will resolve with the * response of the last redirect. * - In case of navigation to a different anchor or navigation due to History * API usage, the navigation will resolve with `null`. */ waitForNavigation(options?: WaitForOptions): Promise<HTTPResponse | null>; /** * @param urlOrPredicate - A URL or predicate to wait for * @param options - Optional waiting parameters * @returns Promise which resolves to the matched response * @example * * ```ts * const firstResponse = await page.waitForResponse( * 'https://example.com/resource' * ); * const finalResponse = await page.waitForResponse( * response => * response.url() === 'https://example.com' && response.status() === 200 * ); * const finalResponse = await page.waitForResponse(async response => { * return (await response.text()).includes('<html>'); * }); * return finalResponse.ok(); * ``` * * @remarks * Optional Waiting Parameters have: * * - `timeout`: Maximum wait time in milliseconds, defaults to `30` seconds, pass * `0` to disable the timeout. The default value can be changed by using the * {@link Page.setDefaultTimeout} method. */ waitForRequest( urlOrPredicate: string | ((req: HTTPRequest) => boolean | Promise<boolean>), options?: { timeout?: number; }, ): Promise<HTTPRequest>; /** * @param urlOrPredicate - A URL or predicate to wait for. * @param options - Optional waiting parameters * @returns Promise which resolves to the matched response. * @example * * ```ts * const firstResponse = await page.waitForResponse( * 'https://example.com/resource' * ); * const finalResponse = await page.waitForResponse( * response => * response.url() === 'https://example.com' && response.status() === 200 * ); * const finalResponse = await page.waitForResponse(async response => { * return (await response.text()).includes('<html>'); * }); * return finalResponse.ok(); * ``` * * @remarks * Optional Parameter have: * * - `timeout`: Maximum wait time in milliseconds, defaults to `30` seconds, * pass `0` to disable the timeout. The default value can be changed by using * the {@link Page.setDefaultTimeout} method. */ waitForResponse( urlOrPredicate: | string | ((res: HTTPResponse) => boolean | Promise<boolean>), options?: { timeout?: number; }, ): Promise<HTTPResponse>; /** * @param options - Optional waiting parameters * @returns Promise which resolves when network is idle */ waitForNetworkIdle(options?: { idleTime?: number; timeout?: number; }): Promise<void>; /** * @param urlOrPredicate - A URL or predicate to wait for. * @param options - Optional waiting parameters * @returns Promise which resolves to the matched frame. * @example * * ```ts * const frame = await page.waitForFrame(async frame => { * return frame.name() === 'Test'; * }); * ``` * * @remarks * Optional Parameter have: * * - `timeout`: Maximum wait time in milliseconds, defaults to `30` seconds, * pass `0` to disable the timeout. The default value can be changed by using * the {@link Page.setDefaultTimeout} method. */ waitForFrame( urlOrPredicate: string | ((frame: Frame) => boolean | Promise<boolean>), options?: { timeout?: number; }, ): Promise<Frame>; /** * This method navigate to the previous page in history. * @param options - Navigation parameters * @returns Promise which resolves to the main resource response. In case of * multiple redirects, the navigation will resolve with the response of the * last redirect. If can not go back, resolves to `null`. * @remarks * The argument `options` might have the following properties: * * - `timeout` : Maximum navigation time in milliseconds, defaults to 30 * seconds, pass 0 to disable timeout. The default value can be changed by * using the {@link Page.setDefaultNavigationTimeout} or * {@link Page.setDefaultTimeout} methods. * * - `waitUntil` : When to consider navigation succeeded, defaults to `load`. * Given an array of event strings, navigation is considered to be * successful after all events have been fired. Events can be either:<br/> * - `load` : consider navigation to be finished when the load event is * fired.<br/> * - `domcontentloaded` : consider navigation to be finished when the * DOMContentLoaded event is fired.<br/> * - `networkidle0` : consider navigation to be finished when there are no * more than 0 network connections for at least `500` ms.<br/> * - `networkidle2` : consider navigation to be finished when there are no * more than 2 network connections for at least `500` ms. */ goBack(options?: WaitForOptions): Promise<HTTPResponse | null>; /** * This method navigate to the next page in history. * @param options - Navigation Parameter * @returns Promise which resolves to the main resource response. In case of * multiple redirects, the navigation will resolve with the response of the * last redirect. If can not go forward, resolves to `null`. * @remarks * The argument `options` might have the following properties: * * - `timeout` : Maximum navigation time in milliseconds, defaults to 30 * seconds, pass 0 to disable timeout. The default value can be changed by * using the {@link Page.setDefaultNavigationTimeout} or * {@link Page.setDefaultTimeout} methods. * * - `waitUntil`: When to consider navigation succeeded, defaults to `load`. * Given an array of event strings, navigation is considered to be * successful after all events have been fired. Events can be either:<br/> * - `load` : consider navigation to be finished when the load event is * fired.<br/> * - `domcontentloaded` : consider navigation to be finished when the * DOMContentLoaded event is fired.<br/> * - `networkidle0` : consider navigation to be finished when there are no * more than 0 network connections for at least `500` ms.<br/> * - `networkidle2` : consider navigation to be finished when there are no * more than 2 network connections for at least `500` ms. */ goForward(options?: WaitForOptions): Promise<HTTPResponse | null>; /** * Brings page to front (activates tab). */ bringToFront(): Promise<void>; /** * Emulates given device metrics and user agent. * * @remarks * This method is a shortcut for calling two methods: * {@link Page.setUserAgent} and {@link Page.setViewport} To aid emulation, * Puppeteer provides a list of device descriptors that can be obtained via * {@link devices}. `page.emulate` will resize the page. A lot of websites * don't expect phones to change size, so you should emulate before navigating * to the page. * @example * * ```ts * const puppeteer = require('puppeteer'); * const iPhone = puppeteer.devices['iPhone 6']; * (async () => { * const browser = await puppeteer.launch(); * const page = await browser.newPage(); * await page.emulate(iPhone); * await page.goto('https://www.google.com'); * // other actions... * await browser.close(); * })(); * ``` * * @remarks List of all available devices is available in the source code: * {@link https://github.com/puppeteer/puppeteer/blob/main/src/common/DeviceDescriptors.ts | src/common/DeviceDescriptors.ts}. */ emulate(options: { viewport: Viewport; userAgent: string; }): Promise<void>; /** * @param enabled - Whether or not to enable JavaScript on the page. * @returns * @remarks * NOTE: changing this value won't affect scripts that have already been run. * It will take full effect on the next navigation. */ setJavaScriptEnabled(enabled: boolean): Promise<void>; /** * Toggles bypassing page's Content-Security-Policy. * @param enabled - sets bypassing of page's Content-Security-Policy. * @remarks * NOTE: CSP bypassing happens at the moment of CSP initialization rather than * evaluation. Usually, this means that `page.setBypassCSP` should be called * before navigating to the domain. */ setBypassCSP(enabled: boolean): Promise<void>; /** * @param type - Changes the CSS media type of the page. The only allowed * values are `screen`, `print` and `null`. Passing `null` disables CSS media * emulation. * @example * * ```ts * await page.evaluate(() => matchMedia('screen').matches); * // → true * await page.evaluate(() => matchMedia('print').matches); * // → false * * await page.emulateMediaType('print'); * await page.evaluate(() => matchMedia('screen').matches); * // → false * await page.evaluate(() => matchMedia('print').matches); * // → true * * await page.emulateMediaType(null); * await page.evaluate(() => matchMedia('screen').matches); * // → true * await page.evaluate(() => matchMedia('print').matches); * // → false * ``` */ emulateMediaType(type?: string): Promise<void>; /** * Enables CPU throttling to emulate slow CPUs. * @param factor - slowdown factor (1 is no throttle, 2 is 2x slowdown, etc). */ emulateCPUThrottling(factor: number | null): Promise<void>; /** * @param features - `<?Array<Object>>` Given an array of media feature * objects, emulates CSS media features on the page. Each media feature object * must have the following properties: * @example * * ```ts * await page.emulateMediaFeatures([ * {name: 'prefers-color-scheme', value: 'dark'}, * ]); * await page.evaluate( * () => matchMedia('(prefers-color-scheme: dark)').matches * ); * // → true * await page.evaluate( * () => matchMedia('(prefers-color-scheme: light)').matches * ); * // → false * * await page.emulateMediaFeatures([ * {name: 'prefers-reduced-motion', value: 'reduce'}, * ]); * await page.evaluate( * () => matchMedia('(prefers-reduced-motion: reduce)').matches * ); * // → true * await page.evaluate( * () => matchMedia('(prefers-reduced-motion: no-preference)').matches * ); * // → false * * await page.emulateMediaFeatures([ * {name: 'prefers-color-scheme', value: 'dark'}, * {name: 'prefers-reduced-motion', value: 'reduce'}, * ]); * await page.evaluate( * () => matchMedia('(prefers-color-scheme: dark)').matches * ); * // → true * await page.evaluate( * () => matchMedia('(prefers-color-scheme: light)').matches * ); * // → false * await page.evaluate( * () => matchMedia('(prefers-reduced-motion: reduce)').matches * ); * // → true * await page.evaluate( * () => matchMedia('(prefers-reduced-motion: no-preference)').matches * ); * // → false * * await page.emulateMediaFeatures([{name: 'color-gamut', value: 'p3'}]); * await page.evaluate(() => matchMedia('(color-gamut: srgb)').matches); * // → true * await page.evaluate(() => matchMedia('(color-gamut: p3)').matches); * // → true * await page.evaluate(() => matchMedia('(color-gamut: rec2020)').matches); * // → false * ``` */ emulateMediaFeatures(features?: MediaFeature[]): Promise<void>; /** * @param timezoneId - Changes the timezone of the page. See * {@link https://source.chromium.org/chromium/chromium/deps/icu.git/+/faee8bc70570192d82d2978a71e2a615788597d1:source/data/misc/metaZones.txt | ICU’s metaZones.txt} * for a list of supported timezone IDs. Passing * `null` disables timezone emulation. */ emulateTimezone(timezoneId?: string): Promise<void>; /** * Emulates the idle state. * If no arguments set, clears idle state emulation. * * @example * * ```ts * // set idle emulation * await page.emulateIdleState({isUserActive: true, isScreenUnlocked: false}); * * // do some checks here * ... * * // clear idle emulation * await page.emulateIdleState(); * ``` * * @param overrides - Mock idle state. If not set, clears idle overrides */ emulateIdleState(overrides?: { isUserActive: boolean; isScreenUnlocked: boolean; }): Promise<void>; /** * Simulates the given vision deficiency on the page. * * @example * * ```ts * const puppeteer = require('puppeteer'); * * (async () => { * const browser = await puppeteer.launch(); * const page = await browser.newPage(); * await page.goto('https://v8.dev/blog/10-years'); * * await page.emulateVisionDeficiency('achromatopsia'); * await page.screenshot({path: 'achromatopsia.png'}); * * await page.emulateVisionDeficiency('deuteranopia'); * await page.screenshot({path: 'deuteranopia.png'}); * * await page.emulateVisionDeficiency('blurredVision'); * await page.screenshot({path: 'blurred-vision.png'}); * * await browser.close(); * })(); * ``` * * @param type - the type of deficiency to simulate, or `'none'` to reset. */ emulateVisionDeficiency( type?: Protocol.Emulation.SetEmulatedVisionDeficiencyRequest["type"], ): Promise<void>; /** * `page.setViewport` will resize the page. A lot of websites don't expect * phones to change size, so you should set the viewport before navigating to * the page. * * In the case of multiple pages in a single browser, each page can have its * own viewport size. * @example * * ```ts * const page = await browser.newPage(); * await page.setViewport({ * width: 640, * height: 480, * deviceScaleFactor: 1, * }); * await page.goto('https://example.com'); * ``` * * @param viewport - * @remarks * Argument viewport have following properties: * * - `width`: page width in pixels. required * * - `height`: page height in pixels. required * * - `deviceScaleFactor`: Specify device scale factor (can be thought of as * DPR). Defaults to `1`. * * - `isMobile`: Whether the meta viewport tag is taken into account. Defaults * to `false`. * * - `hasTouch`: Specifies if viewport supports touch events. Defaults to `false` * * - `isLandScape`: Specifies if viewport is in landscape mode. Defaults to false. * * NOTE: in certain cases, setting viewport will reload the page in order to * set the isMobile or hasTouch properties. */ setViewport(viewport: Viewport): Promise<void>; /** * @returns * * - `width`: page's width in pixels * * - `height`: page's height in pixels * * - `deviceScalarFactor`: Specify device scale factor (can be though of as * dpr). Defaults to `1`. * * - `isMobile`: Whether the meta viewport tag is taken into account. Defaults * to `false`. * * - `hasTouch`: Specifies if viewport supports touch events. Defaults to * `false`. * * - `isLandScape`: Specifies if viewport is in landscape mode. Defaults to * `false`. */ viewport(): Viewport | null; /** * Evaluates a function in the page's context and returns the result. * * If the function passed to `page.evaluteHandle` returns a Promise, the * function will wait for the promise to resolve and return its value. * * @example * * ```ts * const result = await frame.evaluate(() => { * return Promise.resolve(8 * 7); * }); * console.log(result); // prints "56" * ``` * * 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.evaluate('1 + 2'); * ``` * * To get the best TypeScript experience, you should pass in as the * generic the type of `pageFunction`: * * ```ts * const aHandle = await page.evaluate(() => 2); * ``` * * @example * * {@link ElementHandle} instances (including {@link JSHandle}s) can be passed * as arguments to the `pageFunction`: * * ```ts * const bodyHandle = await page.$('body'); * const html = await page.evaluate(body => body.innerHTML, bodyHandle); * await bodyHandle.dispose(); * ``` * * @param pageFunction - a function that is run within the page * @param args - arguments to be passed to the pageFunction * * @returns the return value of `pageFunction`. */ evaluate< Params extends unknown[], Func extends EvaluateFunc<Params> = EvaluateFunc<Params>, >( pageFunction: Func | string, ...args: Params ): Promise<Awaited<ReturnType<Func>>>; /** * Adds a function which would be invoked in one of the following scenarios: * * - whenever the page is navigated * * - whenever the child frame is attached or navigated. In this case, the * function is invoked in the context of the newly attached frame. * * The function is invoked after the document was created but before any of * its scripts were run. This is useful to amend the JavaScript environment, * e.g. to seed `Math.random`. * @param pageFunction - Function to be evaluated in browser context * @param args - Arguments to pass to `pageFunction` * @example * An example of overriding the navigator.languages property before the page loads: * * ```ts * // preload.js * * // overwrite the `languages` property to use a custom getter * Object.defineProperty(navigator, 'languages', { * get: function () { * return ['en-US', 'en', 'bn']; * }, * }); * * // In your puppeteer script, assuming the preload.js file is * in same folder of our script * const preloadFile = fs.readFileSync('./preload.js', 'utf8'); * await page.evaluateOnNewDocument(preloadFile); * ``` */ evaluateOnNewDocument< Params extends unknown[], Func extends (...args: Params) => unknown = (...args: Params) => unknown, >(pageFunction: Func | string, ...args: Params): Promise<void>; /** * Toggles ignoring cache for each request based on the enabled state. By * default, caching is enabled. * @param enabled - sets the `enabled` state of cache */ setCacheEnabled(enabled?: boolean): Promise<void>; /** * @remarks * Options object which might have the following properties: * * - `path` : 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 * {@link https://nodejs.org/api/process.html#process_process_cwd * | current working directory}. * If no path is provided, the image won't be saved to the disk. * * - `type` : Specify screenshot type, can be either `jpeg` or `png`. * Defaults to 'png'. * * - `quality` : The quality of the image, between 0-100. Not * applicable to `png` images. * * - `fullPage` : When true, takes a screenshot of the full * scrollable page. Defaults to `false`. * * - `clip` : An object which specifies clipping region of the page. * Should have the following fields:<br/> * - `x` : x-coordinate of top-left corner of clip area.<br/> * - `y` : y-coordinate of top-left corner of clip area.<br/> * - `width` : width of clipping area.<br/> * - `height` : height of clipping area. * * - `omitBackground` : Hides default white background and allows * capturing screenshots with transparency. Defaults to `false`. * * - `encoding` : The encoding of the image, can be either base64 or * binary. Defaults to `binary`. * * - `captureBeyondViewport` : When true, captures screenshot * {@link https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-captureScreenshot * | beyond the viewport}. When false, falls back to old behaviour, * and cuts the screenshot by the viewport size. Defaults to `true`. * * - `fromSurface` : When true, captures screenshot * {@link https://chromedevtools.github.io/devtools-protocol/tot/Page/#method-captureScreenshot * | from the surface rather than the view}. When false, works only in * headful mode and ignores page viewport (but not browser window's * bounds). Defaults to `true`. * * NOTE: Screenshots take at least 1/6 second on OS X. See * {@link https://crbug.com/741689} for discussion. * @returns Promise which resolves to buffer or a base64 string (depending on * the value of `encoding`) with captured screenshot. */ screenshot(options?: ScreenshotOptions): Promise<Buffer | string>; /** * Generates a PDF of the page with the `print` CSS media type. * @remarks * * NOTE: PDF generation is only supported in Chrome headless mode. * * To generate a PDF with the `screen` media type, call * {@link Page.emulateMediaType | `page.emulateMediaType('screen')`} before * calling `page.pdf()`. * * By default, `page.pdf()` generates a pdf with modified colors for printing. * Use the * {@link https://developer.mozilla.org/en-US/docs/Web/CSS/-webkit-print-color-adjust | `-webkit-print-color-adjust`} * property to force rendering of exact colors. * * @param options - options for generating the PDF. */ createPDFStream(options?: PDFOptions): Promise<ReadableStream>; /** * @param options - * @returns */ pdf(options?: PDFOptions): Promise<Uint8Array>; /** * @returns The page's title * @remarks * Shortcut for {@link Frame.title | page.mainFrame().title()}. */ title(): Promise<string>; close(options?: { runBeforeUnload?: boolean; }): Promise<void>; /** * Indicates that the page has been closed. * @returns */ isClosed(): boolean; get mouse(): Mouse; /** * This method fetches an element with `selector`, scrolls it into view if * needed, and then uses {@link Page.mouse} to click in the center of the * element. If there's no element matching `selector`, the method throws an * error. * @remarks Bear in mind that if `click()` triggers a navigation event and * there's a separate `page.waitForNavigation()` promise to be resolved, you * may end up with a race condition that yields unexpected results. The * correct pattern for click and wait for navigation is the following: * * ```ts * const [response] = await Promise.all([ * page.waitForNavigation(waitOptions), * page.click(selector, clickOptions), * ]); * ``` * * Shortcut for {@link Frame.click | page.mainFrame().click(selector[, options]) }. * @param selector - A `selector` to search for element to click. If there are * multiple elements satisfying the `selector`, the first will be clicked * @param options - `Object` * @returns Promise which resolves when the element matching `selector` is * successfully clicked. The Promise will be rejected if there is no element * matching `selector`. */ click(selector: string, options?: { delay?: number; button?: MouseButton; clickCount?: number; }): Promise<void>; /** * This method fetches an element with `selector` and focuses it. If there's no * element matching `selector`, the method throws an error. * @param selector - A * {@link https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_Selectors | selector } * of an element to focus. If there are multiple elements satisfying the * selector, the first will be focused. * @returns Promise which resolves when the element matching selector is * successfully focused. The promise will be rejected if there is no element * matching selector. * @remarks * Shortcut for {@link Frame.focus | page.mainFrame().focus(selector)}. */ focus(selector: string): Promise<void>; /** * This method fetches an element with `selector`, scrolls it into view if * needed, and then uses {@link Page.mouse} to hover over the center of the element. * If there's no element matching `selector`, the method throws an error. * @param selector - A * {@link https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_Selectors | selector} * to search for element to hover. If there are multiple elements satisfying * the selector, the first will be hovered. * @returns Promise which resolves when the element matching `selector` is * successfully hovered. Promise gets rejected if there's no element matching * `selector`. * @remarks * Shortcut for {@link Page.hover | page.mainFrame().hover(selector)}. */ hover(selector: string): Promise<void>; /** * Triggers a `change` and `input` event once all the provided options have been * selected. If there's no `<select>` element matching `selector`, the method * throws an error. * * @example * * ```ts * page.select('select#colors', 'blue'); // single selection * page.select('select#colors', 'red', 'green', 'blue'); // multiple selections * ``` * * @param selector - A * {@link https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_Selectors | Selector} * to query the page for * @param values - Values of options to select. If the `<select>` has the * `multiple` attribute, all values are considered, otherwise only the first one * is taken into account. * @returns * * @remarks * Shortcut for {@link Frame.select | page.mainFrame().select()} */ select(selector: string, ...values: string[]): Promise<string[]>; /** * This method fetches an element with `selector`, scrolls it into view if * needed, and then uses {@link Page.touchscreen} to tap in the center of the element. * If there's no element matching `selector`, the method throws an error. * @param selector - A * {@link https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_Selectors | Selector} * to search for element to tap. If there are multiple elements satisfying the * selector, the first will be tapped. * @returns * @remarks * Shortcut for {@link Frame.tap | page.mainFrame().tap(selector)}. */ tap(selector: string): Promise<void>; /** * Sends a `keydown`, `keypress/input`, and `keyup` event for each character * in the text. * * To press a special key, like `Control` or `ArrowDown`, use {@link Keyboard.press}. * @example * * ```ts * await page.type('#mytextarea', 'Hello'); * // Types instantly * await page.type('#mytextarea', 'World', {delay: 100}); * // Types slower, like a user * ``` * * @param selector - A * {@link https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_Selectors | selector} * of an element to type into. If there are multiple elements satisfying the * selector, the first will be used. * @param text - A text to type into a focused element. * @param options - have property `delay` which is the Time to wait between * key presses in milliseconds. Defaults to `0`. * @returns * @remarks */ type(selector: string, text: string, options?: { delay: number; }): Promise<void>; /** * @deprecated Use `new Promise(r => setTimeout(r, milliseconds));`. * * Causes your script to wait for the given number of milliseconds. * * @remarks * It's generally recommended to not wait for a number of seconds, but instead * use {@link Frame.waitForSelector}, {@link Frame.waitForXPath} or * {@link Frame.waitForFunction} to wait for exactly the conditions you want. * * @example * * Wait for 1 second: * * ```ts * await page.waitForTimeout(1000); * ``` * * @param milliseconds - the number of milliseconds to wait. */ waitForTimeout(milliseconds: number): Promise<void>; /** * Wait for the `selector` to appear in page. If at the moment of calling the * method the `selector` already exists, the method will return immediately. If * the `selector` doesn't appear after the `timeout` milliseconds of waiting, the * function will throw. * * This method works across navigations: * * ```ts * const puppeteer = require('puppeteer'); * (async () => { * const browser = await puppeteer.launch(); * const page = await browser.newPage(); * let currentURL; * page * .waitForSelector('img') * .then(() => console.log('First URL with image: ' + currentURL)); * for (currentURL of [ * 'https://example.com', * 'https://google.com', * 'https://bbc.com', * ]) { * await page.goto(currentURL); * } * await browser.close(); * })(); * ``` * * @param selector - A * {@link https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_Selectors | selector} * of an element to wait for * @param options - Optional waiting parameters * @returns Promise which resolves when element specified by selector string * is added to DOM. Resolves to `null` if waiting for hidden: `true` and * selector is not found in DOM. * @remarks * The optional Parameter in Arguments `options` are : * * - `Visible`: A boolean wait for element to be present in DOM and to be * visible, i.e. to not have `display: none` or `visibility: hidden` CSS * properties. Defaults to `false`. * * - `hidden`: Wait for element to not be found in the DOM or to be hidden, * i.e. have `display: none` or `visibility: hidden` CSS properties. Defaults to * `false`. * * - `timeout`: maximum time to wait for in milliseconds. Defaults to `30000` * (30 seconds). Pass `0` to disable timeout. The default value can be changed * by using the {@link Page.setDefaultTimeout} method. */ waitForSelector<Selector extends string>( selector: Selector, options?: Exclude<WaitForSelectorOptions, "root">, ): Promise<ElementHandle<NodeFor<Selector>> | null>; /** * Wait for the `xpath` to appear in page. If at the moment of calling the * method the `xpath` already exists, the method will return immediately. If * the `xpath` doesn't appear after the `timeout` milliseconds of waiting, the * function will throw. * * This method works across navigation * * ```ts * const puppeteer = require('puppeteer'); * (async () => { * const browser = await puppeteer.launch(); * const page = await browser.newPage(); * let currentURL; * page * .waitForXPath('//img') * .then(() => console.log('First URL with image: ' + currentURL)); * for (currentURL of [ * 'https://example.com', * 'https://google.com', * 'https://bbc.com', * ]) { * await page.goto(currentURL); * } * await browser.close(); * })(); * ``` * * @param xpath - A * {@link https://developer.mozilla.org/en-US/docs/Web/XPath | xpath} of an * element to wait for * @param options - Optional waiting parameters * @returns Promise which resolves when element specified by xpath string is * added to DOM. Resolves to `null` if waiting for `hidden: true` and xpath is * not found in DOM. * @remarks * The optional Argument `options` have properties: * * - `visible`: A boolean to wait for element to be present in DOM and to be * visible, i.e. to not have `display: none` or `visibility: hidden` CSS * properties. Defaults to `false`. * * - `hidden`: A boolean wait for element to not be found in the DOM or to be * hidden, i.e. have `display: none` or `visibility: hidden` CSS properties. * Defaults to `false`. * * - `timeout`: A number which is maximum time to wait for in milliseconds. * Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default * value can be changed by using the {@link Page.setDefaultTimeout} method. */ waitForXPath(xpath: string, options?: { visible?: boolean; hidden?: boolean; timeout?: number; }): Promise<ElementHandle<any> | null>; /** * Waits for a function to finish evaluating in the page's context. * * @example * The {@link Page.waitForFunction} can be used to observe viewport size change: * * ```ts * const puppeteer = require('puppeteer'); * (async () => { * const browser = await puppeteer.launch(); * const page = await browser.newPage(); * const watchDog = page.waitForFunction('window.innerWidth < 100'); * await page.setViewport({width: 50, height: 50}); * await watchDog; * await browser.close(); * })(); * ``` * * @example * To pass arguments from node.js to the predicate of * {@link Page.waitForFunction} function: * * ```ts * const selector = '.foo'; * await page.waitForFunction( * selector => !!document.querySelector(selector), * {}, * selector * ); * ``` * * @example * The predicate of {@link Page.waitForFunction} can be asynchronous too: * * ```ts * const username = 'github-username'; * await page.waitForFunction( * async username => { * const githubResponse = await fetch( * `https://api.github.com/users/${username}` * ); * const githubUser = await githubResponse.json(); * // show the avatar * const img = document.createElement('img'); * img.src = githubUser.avatar_url; * // wait 3 seconds * await new Promise((resolve, reject) => setTimeout(resolve, 3000)); * img.remove(); * }, * {}, * username * ); * ``` * * @param pageFunction - Function to be evaluated in browser context * @param options - Optional waiting parameters * * - `polling` - An interval at which the `pageFunction` is executed, defaults * to `raf`. If `polling` is a number, then it is treated as an interval in * milliseconds at which the function would be executed. If polling is a * string, then it can be one of the following values: * - `raf` - to constantly execute `pageFunction` in * `requestAnimationFrame` callback. This is the tightest polling mode * which is suitable to observe styling changes. * - `mutation`- to execute pageFunction on every DOM mutation. * - `timeout` - maximum time to wait for in milliseconds. Defaults to `30000` * (30 seconds). Pass `0` to disable timeout. The default value can be * changed by using the {@link Page.setDefaultTimeout} method. * @param args - Arguments to pass to `pageFunction` * @returns A `Promise` which resolves to a JSHandle/ElementHandle of the the * `pageFunction`'s return value. */ waitForFunction< Params extends unknown[], Func extends EvaluateFunc<Params> = EvaluateFunc<Params>, >(pageFunction: Func | string, options?: { timeout?: number; polling?: string | number; }, ...args: Params): Promise<HandleFor<Awaited<ReturnType<Func>>>>;}