DMleadgen
46d973904b
Next.js website for Rocky Mountain Vending company featuring: - Product catalog with Stripe integration - Service areas and parts pages - Admin dashboard with Clerk authentication - SEO optimized pages with JSON-LD structured data Co-authored-by: Cursor <cursoragent@cursor.com>
1501 lines
No EOL
65 KiB
Text
1501 lines
No EOL
65 KiB
Text
"use strict";
|
|
/**
|
|
* @license
|
|
* Copyright 2017 Google Inc.
|
|
* SPDX-License-Identifier: Apache-2.0
|
|
*/
|
|
var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
|
|
var useValue = arguments.length > 2;
|
|
for (var i = 0; i < initializers.length; i++) {
|
|
value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
|
|
}
|
|
return useValue ? value : void 0;
|
|
};
|
|
var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
|
|
function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
|
|
var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
|
|
var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
|
|
var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
|
|
var _, done = false;
|
|
for (var i = decorators.length - 1; i >= 0; i--) {
|
|
var context = {};
|
|
for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
|
|
for (var p in contextIn.access) context.access[p] = contextIn.access[p];
|
|
context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
|
|
var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
|
|
if (kind === "accessor") {
|
|
if (result === void 0) continue;
|
|
if (result === null || typeof result !== "object") throw new TypeError("Object expected");
|
|
if (_ = accept(result.get)) descriptor.get = _;
|
|
if (_ = accept(result.set)) descriptor.set = _;
|
|
if (_ = accept(result.init)) initializers.unshift(_);
|
|
}
|
|
else if (_ = accept(result)) {
|
|
if (kind === "field") initializers.unshift(_);
|
|
else descriptor[key] = _;
|
|
}
|
|
}
|
|
if (target) Object.defineProperty(target, contextIn.name, descriptor);
|
|
done = true;
|
|
};
|
|
var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
|
|
if (value !== null && value !== void 0) {
|
|
if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
|
|
var dispose, inner;
|
|
if (async) {
|
|
if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
|
|
dispose = value[Symbol.asyncDispose];
|
|
}
|
|
if (dispose === void 0) {
|
|
if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
|
|
dispose = value[Symbol.dispose];
|
|
if (async) inner = dispose;
|
|
}
|
|
if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
|
|
if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
|
|
env.stack.push({ value: value, dispose: dispose, async: async });
|
|
}
|
|
else if (async) {
|
|
env.stack.push({ async: true });
|
|
}
|
|
return value;
|
|
};
|
|
var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
|
|
return function (env) {
|
|
function fail(e) {
|
|
env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
|
|
env.hasError = true;
|
|
}
|
|
var r, s = 0;
|
|
function next() {
|
|
while (r = env.stack.pop()) {
|
|
try {
|
|
if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
|
|
if (r.dispose) {
|
|
var result = r.dispose.call(r.value);
|
|
if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
|
|
}
|
|
else s |= 1;
|
|
}
|
|
catch (e) {
|
|
fail(e);
|
|
}
|
|
}
|
|
if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
|
|
if (env.hasError) throw env.error;
|
|
}
|
|
return next();
|
|
};
|
|
})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
|
|
var e = new Error(message);
|
|
return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
|
|
});
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.supportedMetrics = exports.Page = void 0;
|
|
exports.setDefaultScreenshotOptions = setDefaultScreenshotOptions;
|
|
const rxjs_js_1 = require("../../third_party/rxjs/rxjs.js");
|
|
const Errors_js_1 = require("../common/Errors.js");
|
|
const EventEmitter_js_1 = require("../common/EventEmitter.js");
|
|
const TimeoutSettings_js_1 = require("../common/TimeoutSettings.js");
|
|
const util_js_1 = require("../common/util.js");
|
|
const environment_js_1 = require("../environment.js");
|
|
const decorators_js_1 = require("../util/decorators.js");
|
|
const disposable_js_1 = require("../util/disposable.js");
|
|
const encoding_js_1 = require("../util/encoding.js");
|
|
const locators_js_1 = require("./locators/locators.js");
|
|
/**
|
|
* @internal
|
|
*/
|
|
function setDefaultScreenshotOptions(options) {
|
|
options.optimizeForSpeed ??= false;
|
|
options.type ??= 'png';
|
|
options.fromSurface ??= true;
|
|
options.fullPage ??= false;
|
|
options.omitBackground ??= false;
|
|
options.encoding ??= 'binary';
|
|
options.captureBeyondViewport ??= true;
|
|
}
|
|
/**
|
|
* 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
|
|
*/
|
|
let Page = (() => {
|
|
let _classSuper = EventEmitter_js_1.EventEmitter;
|
|
let _instanceExtraInitializers = [];
|
|
let _screenshot_decorators;
|
|
return class Page extends _classSuper {
|
|
static {
|
|
const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
|
|
__esDecorate(this, null, _screenshot_decorators, { kind: "method", name: "screenshot", static: false, private: false, access: { has: obj => "screenshot" in obj, get: obj => obj.screenshot }, metadata: _metadata }, null, _instanceExtraInitializers);
|
|
if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
|
|
}
|
|
/**
|
|
* @internal
|
|
*/
|
|
_isDragging = (__runInitializers(this, _instanceExtraInitializers), false);
|
|
/**
|
|
* @internal
|
|
*/
|
|
_timeoutSettings = new TimeoutSettings_js_1.TimeoutSettings();
|
|
#requestHandlers = new WeakMap();
|
|
#inflight$ = new rxjs_js_1.ReplaySubject(1);
|
|
/**
|
|
* @internal
|
|
*/
|
|
constructor() {
|
|
super();
|
|
(0, util_js_1.fromEmitterEvent)(this, "request" /* PageEvent.Request */)
|
|
.pipe((0, rxjs_js_1.mergeMap)(originalRequest => {
|
|
return (0, rxjs_js_1.concat)((0, rxjs_js_1.of)(1), (0, rxjs_js_1.merge)((0, util_js_1.fromEmitterEvent)(this, "requestfailed" /* PageEvent.RequestFailed */), (0, util_js_1.fromEmitterEvent)(this, "requestfinished" /* PageEvent.RequestFinished */), (0, util_js_1.fromEmitterEvent)(this, "response" /* PageEvent.Response */).pipe((0, rxjs_js_1.map)(response => {
|
|
return response.request();
|
|
}))).pipe((0, rxjs_js_1.filter)(request => {
|
|
return request.id === originalRequest.id;
|
|
}), (0, rxjs_js_1.take)(1), (0, rxjs_js_1.map)(() => {
|
|
return -1;
|
|
})));
|
|
}), (0, rxjs_js_1.mergeScan)((acc, addend) => {
|
|
return (0, rxjs_js_1.of)(acc + addend);
|
|
}, 0), (0, rxjs_js_1.takeUntil)((0, util_js_1.fromEmitterEvent)(this, "close" /* PageEvent.Close */)), (0, rxjs_js_1.startWith)(0))
|
|
.subscribe(this.#inflight$);
|
|
}
|
|
/**
|
|
* 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
|
|
*/
|
|
on(type, handler) {
|
|
if (type !== "request" /* PageEvent.Request */) {
|
|
return super.on(type, handler);
|
|
}
|
|
let wrapper = this.#requestHandlers.get(handler);
|
|
if (wrapper === undefined) {
|
|
wrapper = (event) => {
|
|
event.enqueueInterceptAction(() => {
|
|
return handler(event);
|
|
});
|
|
};
|
|
this.#requestHandlers.set(handler, wrapper);
|
|
}
|
|
return super.on(type, wrapper);
|
|
}
|
|
/**
|
|
* @internal
|
|
*/
|
|
off(type, handler) {
|
|
if (type === "request" /* PageEvent.Request */) {
|
|
handler =
|
|
this.#requestHandlers.get(handler) || handler;
|
|
}
|
|
return super.off(type, handler);
|
|
}
|
|
/**
|
|
* {@inheritDoc Accessibility}
|
|
*/
|
|
get accessibility() {
|
|
return this.mainFrame().accessibility;
|
|
}
|
|
locator(input) {
|
|
if (typeof input === 'string') {
|
|
return locators_js_1.NodeLocator.create(this, input);
|
|
}
|
|
else {
|
|
return locators_js_1.FunctionLocator.create(this, input);
|
|
}
|
|
}
|
|
/**
|
|
* A shortcut for {@link Locator.race} that does not require static imports.
|
|
*
|
|
* @internal
|
|
*/
|
|
locatorRace(locators) {
|
|
return locators_js_1.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) {
|
|
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, options) {
|
|
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<ElementHandle>(...);
|
|
* ```
|
|
*
|
|
* @param pageFunction - a function that is run within the page
|
|
* @param args - arguments to be passed to the pageFunction
|
|
*/
|
|
async evaluateHandle(pageFunction, ...args) {
|
|
pageFunction = (0, util_js_1.withSourcePuppeteerURLIfNone)(this.evaluateHandle.name, pageFunction);
|
|
return await this.mainFrame().evaluateHandle(pageFunction, ...args);
|
|
}
|
|
/**
|
|
* 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<string>(
|
|
* '#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, pageFunction, ...args) {
|
|
pageFunction = (0, util_js_1.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, pageFunction, ...args) {
|
|
pageFunction = (0, util_js_1.withSourcePuppeteerURLIfNone)(this.$$eval.name, pageFunction);
|
|
return await this.mainFrame().$$eval(selector, pageFunction, ...args);
|
|
}
|
|
/**
|
|
* Adds a `<script>` tag into the page with the desired URL or content.
|
|
*
|
|
* @remarks
|
|
* Shortcut for
|
|
* {@link Frame.addScriptTag | page.mainFrame().addScriptTag(options)}.
|
|
*
|
|
* @param options - Options for the script.
|
|
* @returns An {@link ElementHandle | element handle} to the injected
|
|
* `<script>` element.
|
|
*/
|
|
async addScriptTag(options) {
|
|
return await this.mainFrame().addScriptTag(options);
|
|
}
|
|
async addStyleTag(options) {
|
|
return await this.mainFrame().addStyleTag(options);
|
|
}
|
|
/**
|
|
* The page's URL.
|
|
*
|
|
* @remarks
|
|
*
|
|
* Shortcut for {@link Frame.url | page.mainFrame().url()}.
|
|
*/
|
|
url() {
|
|
return this.mainFrame().url();
|
|
}
|
|
/**
|
|
* The full HTML contents of the page, including the DOCTYPE.
|
|
*/
|
|
async content() {
|
|
return await this.mainFrame().content();
|
|
}
|
|
/**
|
|
* Set the content of the page.
|
|
*
|
|
* @param html - HTML markup to assign to the page.
|
|
* @param options - Parameters that has some properties.
|
|
*/
|
|
async setContent(html, options) {
|
|
await this.mainFrame().setContent(html, options);
|
|
}
|
|
/**
|
|
* {@inheritDoc Frame.goto}
|
|
*/
|
|
async goto(url, options) {
|
|
return await this.mainFrame().goto(url, options);
|
|
}
|
|
/**
|
|
* 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`.
|
|
*/
|
|
async waitForNavigation(options = {}) {
|
|
return await this.mainFrame().waitForNavigation(options);
|
|
}
|
|
/**
|
|
* @param urlOrPredicate - A URL or predicate to wait for
|
|
* @param options - Optional waiting parameters
|
|
* @returns Promise which resolves to the matched request
|
|
* @example
|
|
*
|
|
* ```ts
|
|
* const firstRequest = await page.waitForRequest(
|
|
* 'https://example.com/resource',
|
|
* );
|
|
* const finalRequest = await page.waitForRequest(
|
|
* request => request.url() === 'https://example.com',
|
|
* );
|
|
* return finalRequest.response()?.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, options = {}) {
|
|
const { timeout: ms = this._timeoutSettings.timeout(), signal } = options;
|
|
if (typeof urlOrPredicate === 'string') {
|
|
const url = urlOrPredicate;
|
|
urlOrPredicate = (request) => {
|
|
return request.url() === url;
|
|
};
|
|
}
|
|
const observable$ = (0, util_js_1.fromEmitterEvent)(this, "request" /* PageEvent.Request */).pipe((0, util_js_1.filterAsync)(urlOrPredicate), (0, rxjs_js_1.raceWith)((0, util_js_1.timeout)(ms), (0, util_js_1.fromAbortSignal)(signal), (0, util_js_1.fromEmitterEvent)(this, "close" /* PageEvent.Close */).pipe((0, rxjs_js_1.map)(() => {
|
|
throw new Errors_js_1.TargetCloseError('Page closed!');
|
|
}))));
|
|
return (0, rxjs_js_1.firstValueFrom)(observable$);
|
|
}
|
|
/**
|
|
* @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, options = {}) {
|
|
const { timeout: ms = this._timeoutSettings.timeout(), signal } = options;
|
|
if (typeof urlOrPredicate === 'string') {
|
|
const url = urlOrPredicate;
|
|
urlOrPredicate = (response) => {
|
|
return response.url() === url;
|
|
};
|
|
}
|
|
const observable$ = (0, util_js_1.fromEmitterEvent)(this, "response" /* PageEvent.Response */).pipe((0, util_js_1.filterAsync)(urlOrPredicate), (0, rxjs_js_1.raceWith)((0, util_js_1.timeout)(ms), (0, util_js_1.fromAbortSignal)(signal), (0, util_js_1.fromEmitterEvent)(this, "close" /* PageEvent.Close */).pipe((0, rxjs_js_1.map)(() => {
|
|
throw new Errors_js_1.TargetCloseError('Page closed!');
|
|
}))));
|
|
return (0, rxjs_js_1.firstValueFrom)(observable$);
|
|
}
|
|
/**
|
|
* Waits for the network to be idle.
|
|
*
|
|
* @remarks The function will always wait at least the
|
|
* set {@link WaitForNetworkIdleOptions.idleTime | IdleTime}.
|
|
*
|
|
* @param options - Options to configure waiting behavior.
|
|
* @returns A promise which resolves once the network is idle.
|
|
*/
|
|
waitForNetworkIdle(options = {}) {
|
|
return (0, rxjs_js_1.firstValueFrom)(this.waitForNetworkIdle$(options));
|
|
}
|
|
/**
|
|
* @internal
|
|
*/
|
|
waitForNetworkIdle$(options = {}) {
|
|
const { timeout: ms = this._timeoutSettings.timeout(), idleTime = util_js_1.NETWORK_IDLE_TIME, concurrency = 0, signal, } = options;
|
|
return this.#inflight$.pipe((0, rxjs_js_1.map)(inflight => {
|
|
return inflight > concurrency;
|
|
}), (0, rxjs_js_1.distinctUntilChanged)(), (0, rxjs_js_1.switchMap)(isInflightOverConcurrency => {
|
|
if (isInflightOverConcurrency) {
|
|
return rxjs_js_1.EMPTY;
|
|
}
|
|
return (0, rxjs_js_1.timer)(idleTime);
|
|
}), (0, rxjs_js_1.map)(() => { }), (0, rxjs_js_1.raceWith)((0, util_js_1.timeout)(ms), (0, util_js_1.fromAbortSignal)(signal), (0, util_js_1.fromEmitterEvent)(this, "close" /* PageEvent.Close */).pipe((0, rxjs_js_1.map)(() => {
|
|
throw new Errors_js_1.TargetCloseError('Page closed!');
|
|
}))));
|
|
}
|
|
/**
|
|
* Waits for a frame matching the given conditions to appear.
|
|
*
|
|
* @example
|
|
*
|
|
* ```ts
|
|
* const frame = await page.waitForFrame(async frame => {
|
|
* const frameElement = await frame.frameElement();
|
|
* if (!frameElement) {
|
|
* return false;
|
|
* }
|
|
* const name = await frameElement.evaluate(el => el.getAttribute('name'));
|
|
* return name === 'test';
|
|
* });
|
|
* ```
|
|
*/
|
|
async waitForFrame(urlOrPredicate, options = {}) {
|
|
const { timeout: ms = this.getDefaultTimeout(), signal } = options;
|
|
const predicate = (0, util_js_1.isString)(urlOrPredicate)
|
|
? (frame) => {
|
|
return urlOrPredicate === frame.url();
|
|
}
|
|
: urlOrPredicate;
|
|
return await (0, rxjs_js_1.firstValueFrom)((0, rxjs_js_1.merge)((0, util_js_1.fromEmitterEvent)(this, "frameattached" /* PageEvent.FrameAttached */), (0, util_js_1.fromEmitterEvent)(this, "framenavigated" /* PageEvent.FrameNavigated */), (0, rxjs_js_1.from)(this.frames())).pipe((0, util_js_1.filterAsync)(predicate), (0, rxjs_js_1.first)(), (0, rxjs_js_1.raceWith)((0, util_js_1.timeout)(ms), (0, util_js_1.fromAbortSignal)(signal), (0, util_js_1.fromEmitterEvent)(this, "close" /* PageEvent.Close */).pipe((0, rxjs_js_1.map)(() => {
|
|
throw new Errors_js_1.TargetCloseError('Page closed.');
|
|
})))));
|
|
}
|
|
/**
|
|
* Emulates a given device's metrics and user agent.
|
|
*
|
|
* To aid emulation, Puppeteer provides a list of known devices that can be
|
|
* via {@link KnownDevices}.
|
|
*
|
|
* @remarks
|
|
* This method is a shortcut for calling two methods:
|
|
* {@link Page.(setUserAgent:2) } and {@link Page.setViewport}.
|
|
*
|
|
* This method 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
|
|
* import {KnownDevices} from 'puppeteer';
|
|
* const iPhone = KnownDevices['iPhone 15 Pro'];
|
|
*
|
|
* 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();
|
|
* ```
|
|
*/
|
|
async emulate(device) {
|
|
await Promise.all([
|
|
this.setUserAgent({ userAgent: device.userAgent }),
|
|
this.setViewport(device.viewport),
|
|
]);
|
|
}
|
|
/**
|
|
* Evaluates a function in the page's context and returns the result.
|
|
*
|
|
* If the function passed to `page.evaluate` 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`.
|
|
*/
|
|
async evaluate(pageFunction, ...args) {
|
|
pageFunction = (0, util_js_1.withSourcePuppeteerURLIfNone)(this.evaluate.name, pageFunction);
|
|
return await this.mainFrame().evaluate(pageFunction, ...args);
|
|
}
|
|
/**
|
|
* @internal
|
|
*/
|
|
async _maybeWriteTypedArrayToFile(path, typedArray) {
|
|
if (!path) {
|
|
return;
|
|
}
|
|
await environment_js_1.environment.value.fs.promises.writeFile(path, typedArray);
|
|
}
|
|
/**
|
|
* Captures a screencast of this {@link Page | page}.
|
|
*
|
|
* @example
|
|
* Recording a {@link Page | page}:
|
|
*
|
|
* ```
|
|
* import puppeteer from 'puppeteer';
|
|
*
|
|
* // Launch a browser
|
|
* const browser = await puppeteer.launch();
|
|
*
|
|
* // Create a new page
|
|
* const page = await browser.newPage();
|
|
*
|
|
* // Go to your site.
|
|
* await page.goto("https://www.example.com");
|
|
*
|
|
* // Start recording.
|
|
* const recorder = await page.screencast({path: 'recording.webm'});
|
|
*
|
|
* // Do something.
|
|
*
|
|
* // Stop recording.
|
|
* await recorder.stop();
|
|
*
|
|
* browser.close();
|
|
* ```
|
|
*
|
|
* @param options - Configures screencast behavior.
|
|
*
|
|
* @experimental
|
|
*
|
|
* @remarks
|
|
*
|
|
* By default, all recordings will be {@link https://www.webmproject.org/ | WebM} format using
|
|
* the {@link https://www.webmproject.org/vp9/ | VP9} video codec, with a frame rate of 30 FPS.
|
|
*
|
|
* You must have {@link https://ffmpeg.org/ | ffmpeg} installed on your system.
|
|
*/
|
|
async screencast(options = {}) {
|
|
const ScreenRecorder = environment_js_1.environment.value.ScreenRecorder;
|
|
const [width, height, devicePixelRatio] = await this.#getNativePixelDimensions();
|
|
let crop;
|
|
if (options.crop) {
|
|
const { x, y, width: cropWidth, height: cropHeight, } = roundRectangle(normalizeRectangle(options.crop));
|
|
if (x < 0 || y < 0) {
|
|
throw new Error(`\`crop.x\` and \`crop.y\` must be greater than or equal to 0.`);
|
|
}
|
|
if (cropWidth <= 0 || cropHeight <= 0) {
|
|
throw new Error(`\`crop.height\` and \`crop.width\` must be greater than or equal to 0.`);
|
|
}
|
|
const viewportWidth = width / devicePixelRatio;
|
|
const viewportHeight = height / devicePixelRatio;
|
|
if (x + cropWidth > viewportWidth) {
|
|
throw new Error(`\`crop.width\` cannot be larger than the viewport width (${viewportWidth}).`);
|
|
}
|
|
if (y + cropHeight > viewportHeight) {
|
|
throw new Error(`\`crop.height\` cannot be larger than the viewport height (${viewportHeight}).`);
|
|
}
|
|
crop = {
|
|
x: x * devicePixelRatio,
|
|
y: y * devicePixelRatio,
|
|
width: cropWidth * devicePixelRatio,
|
|
height: cropHeight * devicePixelRatio,
|
|
};
|
|
}
|
|
if (options.speed !== undefined && options.speed <= 0) {
|
|
throw new Error(`\`speed\` must be greater than 0.`);
|
|
}
|
|
if (options.scale !== undefined && options.scale <= 0) {
|
|
throw new Error(`\`scale\` must be greater than 0.`);
|
|
}
|
|
const recorder = new ScreenRecorder(this, width, height, {
|
|
...options,
|
|
crop,
|
|
});
|
|
try {
|
|
await this._startScreencast();
|
|
}
|
|
catch (error) {
|
|
void recorder.stop();
|
|
throw error;
|
|
}
|
|
if (options.path) {
|
|
const { createWriteStream } = environment_js_1.environment.value.fs;
|
|
const stream = createWriteStream(options.path, 'binary');
|
|
recorder.pipe(stream);
|
|
}
|
|
return recorder;
|
|
}
|
|
#screencastSessionCount = 0;
|
|
#startScreencastPromise;
|
|
/**
|
|
* @internal
|
|
*/
|
|
async _startScreencast() {
|
|
++this.#screencastSessionCount;
|
|
if (!this.#startScreencastPromise) {
|
|
this.#startScreencastPromise = this.mainFrame()
|
|
.client.send('Page.startScreencast', { format: 'png' })
|
|
.then(() => {
|
|
// Wait for the first frame.
|
|
return new Promise(resolve => {
|
|
return this.mainFrame().client.once('Page.screencastFrame', () => {
|
|
return resolve();
|
|
});
|
|
});
|
|
});
|
|
}
|
|
await this.#startScreencastPromise;
|
|
}
|
|
/**
|
|
* @internal
|
|
*/
|
|
async _stopScreencast() {
|
|
--this.#screencastSessionCount;
|
|
if (!this.#startScreencastPromise) {
|
|
return;
|
|
}
|
|
this.#startScreencastPromise = undefined;
|
|
if (this.#screencastSessionCount === 0) {
|
|
await this.mainFrame().client.send('Page.stopScreencast');
|
|
}
|
|
}
|
|
/**
|
|
* Gets the native, non-emulated dimensions of the viewport.
|
|
*/
|
|
async #getNativePixelDimensions() {
|
|
const env_1 = { stack: [], error: void 0, hasError: false };
|
|
try {
|
|
const viewport = this.viewport();
|
|
const stack = __addDisposableResource(env_1, new disposable_js_1.DisposableStack(), false);
|
|
if (viewport && viewport.deviceScaleFactor !== 0) {
|
|
await this.setViewport({ ...viewport, deviceScaleFactor: 0 });
|
|
stack.defer(() => {
|
|
void this.setViewport(viewport).catch(util_js_1.debugError);
|
|
});
|
|
}
|
|
return await this.mainFrame()
|
|
.isolatedRealm()
|
|
.evaluate(() => {
|
|
return [
|
|
window.visualViewport.width * window.devicePixelRatio,
|
|
window.visualViewport.height * window.devicePixelRatio,
|
|
window.devicePixelRatio,
|
|
];
|
|
});
|
|
}
|
|
catch (e_1) {
|
|
env_1.error = e_1;
|
|
env_1.hasError = true;
|
|
}
|
|
finally {
|
|
__disposeResources(env_1);
|
|
}
|
|
}
|
|
async screenshot(userOptions = {}) {
|
|
const env_2 = { stack: [], error: void 0, hasError: false };
|
|
try {
|
|
const _guard = __addDisposableResource(env_2, await this.browserContext().startScreenshot(), false);
|
|
const options = {
|
|
...userOptions,
|
|
clip: userOptions.clip
|
|
? {
|
|
...userOptions.clip,
|
|
}
|
|
: undefined,
|
|
};
|
|
if (options.type === undefined && options.path !== undefined) {
|
|
const filePath = options.path;
|
|
// Note we cannot use Node.js here due to browser compatibility.
|
|
const extension = filePath
|
|
.slice(filePath.lastIndexOf('.') + 1)
|
|
.toLowerCase();
|
|
switch (extension) {
|
|
case 'png':
|
|
options.type = 'png';
|
|
break;
|
|
case 'jpeg':
|
|
case 'jpg':
|
|
options.type = 'jpeg';
|
|
break;
|
|
case 'webp':
|
|
options.type = 'webp';
|
|
break;
|
|
}
|
|
}
|
|
if (options.quality !== undefined) {
|
|
if (options.quality < 0 || options.quality > 100) {
|
|
throw new Error(`Expected 'quality' (${options.quality}) to be between 0 and 100, inclusive.`);
|
|
}
|
|
if (options.type === undefined ||
|
|
!['jpeg', 'webp'].includes(options.type)) {
|
|
throw new Error(`${options.type ?? 'png'} screenshots do not support 'quality'.`);
|
|
}
|
|
}
|
|
if (options.clip) {
|
|
if (options.clip.width <= 0) {
|
|
throw new Error("'width' in 'clip' must be positive.");
|
|
}
|
|
if (options.clip.height <= 0) {
|
|
throw new Error("'height' in 'clip' must be positive.");
|
|
}
|
|
}
|
|
setDefaultScreenshotOptions(options);
|
|
const stack = __addDisposableResource(env_2, new disposable_js_1.AsyncDisposableStack(), true);
|
|
if (options.clip) {
|
|
if (options.fullPage) {
|
|
throw new Error("'clip' and 'fullPage' are mutually exclusive");
|
|
}
|
|
options.clip = roundRectangle(normalizeRectangle(options.clip));
|
|
}
|
|
else {
|
|
if (options.fullPage) {
|
|
// If `captureBeyondViewport` is `false`, then we set the viewport to
|
|
// capture the full page. Note this may be affected by on-page CSS and
|
|
// JavaScript.
|
|
if (!options.captureBeyondViewport) {
|
|
const scrollDimensions = await this.mainFrame()
|
|
.isolatedRealm()
|
|
.evaluate(() => {
|
|
const element = document.documentElement;
|
|
return {
|
|
width: element.scrollWidth,
|
|
height: element.scrollHeight,
|
|
};
|
|
});
|
|
const viewport = this.viewport();
|
|
await this.setViewport({
|
|
...viewport,
|
|
...scrollDimensions,
|
|
});
|
|
stack.defer(async () => {
|
|
await this.setViewport(viewport).catch(util_js_1.debugError);
|
|
});
|
|
}
|
|
}
|
|
else {
|
|
options.captureBeyondViewport = false;
|
|
}
|
|
}
|
|
const data = await this._screenshot(options);
|
|
if (options.encoding === 'base64') {
|
|
return data;
|
|
}
|
|
const typedArray = (0, encoding_js_1.stringToTypedArray)(data, true);
|
|
await this._maybeWriteTypedArrayToFile(options.path, typedArray);
|
|
return typedArray;
|
|
}
|
|
catch (e_2) {
|
|
env_2.error = e_2;
|
|
env_2.hasError = true;
|
|
}
|
|
finally {
|
|
const result_1 = __disposeResources(env_2);
|
|
if (result_1)
|
|
await result_1;
|
|
}
|
|
}
|
|
/**
|
|
* The page's title
|
|
*
|
|
* @remarks
|
|
*
|
|
* Shortcut for {@link Frame.title | page.mainFrame().title()}.
|
|
*/
|
|
async title() {
|
|
return await this.mainFrame().title();
|
|
}
|
|
/**
|
|
* 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 -
|
|
* {@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}. 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, options) {
|
|
return this.mainFrame().click(selector, options);
|
|
}
|
|
/**
|
|
* This method fetches an element with `selector` and focuses it. If
|
|
* there's no element matching `selector`, the method throws an error.
|
|
* @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}.
|
|
* 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) {
|
|
return this.mainFrame().focus(selector);
|
|
}
|
|
/**
|
|
* 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 -
|
|
* {@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}. 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) {
|
|
return this.mainFrame().hover(selector);
|
|
}
|
|
/**
|
|
* 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 -
|
|
* {@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 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, ...values) {
|
|
return this.mainFrame().select(selector, ...values);
|
|
}
|
|
/**
|
|
* 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 -
|
|
* {@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}. If there are multiple elements satisfying the
|
|
* selector, the first will be tapped.
|
|
*
|
|
* @remarks
|
|
*
|
|
* Shortcut for {@link Frame.tap | page.mainFrame().tap(selector)}.
|
|
*/
|
|
tap(selector) {
|
|
return this.mainFrame().tap(selector);
|
|
}
|
|
/**
|
|
* 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 -
|
|
* {@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 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
|
|
*/
|
|
type(selector, text, options) {
|
|
return this.mainFrame().type(selector, text, options);
|
|
}
|
|
/**
|
|
* 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.
|
|
*
|
|
* @example
|
|
* This method works across navigations:
|
|
*
|
|
* ```ts
|
|
* import puppeteer from 'puppeteer';
|
|
*
|
|
* 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 -
|
|
* {@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 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.
|
|
*/
|
|
async waitForSelector(selector, options = {}) {
|
|
return await this.mainFrame().waitForSelector(selector, options);
|
|
}
|
|
/**
|
|
* Waits for the provided function, `pageFunction`, to return a truthy value when
|
|
* evaluated in the page's context.
|
|
*
|
|
* @example
|
|
* {@link Page.waitForFunction} can be used to observe a viewport size change:
|
|
*
|
|
* ```ts
|
|
* import puppeteer from 'puppeteer';
|
|
*
|
|
* 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
|
|
* Arguments can be passed from Node.js to `pageFunction`:
|
|
*
|
|
* ```ts
|
|
* const selector = '.foo';
|
|
* await page.waitForFunction(
|
|
* selector => !!document.querySelector(selector),
|
|
* {},
|
|
* selector,
|
|
* );
|
|
* ```
|
|
*
|
|
* @example
|
|
* The provided `pageFunction` can be asynchronous:
|
|
*
|
|
* ```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 until it returns a
|
|
* truthy value.
|
|
* @param options - Options for configuring waiting behavior.
|
|
*/
|
|
waitForFunction(pageFunction, options, ...args) {
|
|
return this.mainFrame().waitForFunction(pageFunction, options, ...args);
|
|
}
|
|
/** @internal */
|
|
[(_screenshot_decorators = [(0, decorators_js_1.guarded)(function () {
|
|
return this.browser();
|
|
})], disposable_js_1.disposeSymbol)]() {
|
|
return void this.close().catch(util_js_1.debugError);
|
|
}
|
|
/** @internal */
|
|
[disposable_js_1.asyncDisposeSymbol]() {
|
|
return this.close();
|
|
}
|
|
};
|
|
})();
|
|
exports.Page = Page;
|
|
/**
|
|
* @internal
|
|
*/
|
|
exports.supportedMetrics = new Set([
|
|
'Timestamp',
|
|
'Documents',
|
|
'Frames',
|
|
'JSEventListeners',
|
|
'Nodes',
|
|
'LayoutCount',
|
|
'RecalcStyleCount',
|
|
'LayoutDuration',
|
|
'RecalcStyleDuration',
|
|
'ScriptDuration',
|
|
'TaskDuration',
|
|
'JSHeapUsedSize',
|
|
'JSHeapTotalSize',
|
|
]);
|
|
/** @see https://w3c.github.io/webdriver-bidi/#normalize-rect */
|
|
function normalizeRectangle(clip) {
|
|
return {
|
|
...clip,
|
|
...(clip.width < 0
|
|
? {
|
|
x: clip.x + clip.width,
|
|
width: -clip.width,
|
|
}
|
|
: {
|
|
x: clip.x,
|
|
width: clip.width,
|
|
}),
|
|
...(clip.height < 0
|
|
? {
|
|
y: clip.y + clip.height,
|
|
height: -clip.height,
|
|
}
|
|
: {
|
|
y: clip.y,
|
|
height: clip.height,
|
|
}),
|
|
};
|
|
}
|
|
function roundRectangle(clip) {
|
|
const x = Math.round(clip.x);
|
|
const y = Math.round(clip.y);
|
|
const width = Math.round(clip.width + clip.x - x);
|
|
const height = Math.round(clip.height + clip.y - y);
|
|
return { ...clip, x, y, width, height };
|
|
}
|
|
//# sourceMappingURL=Page.js.map |