First Commit
This commit is contained in:
281
node_modules/playwright-core/lib/client/elementHandle.js
generated
vendored
Normal file
281
node_modules/playwright-core/lib/client/elementHandle.js
generated
vendored
Normal file
@@ -0,0 +1,281 @@
|
||||
"use strict";
|
||||
var __defProp = Object.defineProperty;
|
||||
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
|
||||
var __getOwnPropNames = Object.getOwnPropertyNames;
|
||||
var __hasOwnProp = Object.prototype.hasOwnProperty;
|
||||
var __export = (target, all) => {
|
||||
for (var name in all)
|
||||
__defProp(target, name, { get: all[name], enumerable: true });
|
||||
};
|
||||
var __copyProps = (to, from, except, desc) => {
|
||||
if (from && typeof from === "object" || typeof from === "function") {
|
||||
for (let key of __getOwnPropNames(from))
|
||||
if (!__hasOwnProp.call(to, key) && key !== except)
|
||||
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
|
||||
}
|
||||
return to;
|
||||
};
|
||||
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
|
||||
var elementHandle_exports = {};
|
||||
__export(elementHandle_exports, {
|
||||
ElementHandle: () => ElementHandle,
|
||||
convertInputFiles: () => convertInputFiles,
|
||||
convertSelectOptionValues: () => convertSelectOptionValues,
|
||||
determineScreenshotType: () => determineScreenshotType
|
||||
});
|
||||
module.exports = __toCommonJS(elementHandle_exports);
|
||||
var import_frame = require("./frame");
|
||||
var import_jsHandle = require("./jsHandle");
|
||||
var import_assert = require("../utils/isomorphic/assert");
|
||||
var import_fileUtils = require("./fileUtils");
|
||||
var import_rtti = require("../utils/isomorphic/rtti");
|
||||
var import_writableStream = require("./writableStream");
|
||||
var import_mimeType = require("../utils/isomorphic/mimeType");
|
||||
class ElementHandle extends import_jsHandle.JSHandle {
|
||||
static from(handle) {
|
||||
return handle._object;
|
||||
}
|
||||
static fromNullable(handle) {
|
||||
return handle ? ElementHandle.from(handle) : null;
|
||||
}
|
||||
constructor(parent, type, guid, initializer) {
|
||||
super(parent, type, guid, initializer);
|
||||
this._frame = parent;
|
||||
this._elementChannel = this._channel;
|
||||
}
|
||||
asElement() {
|
||||
return this;
|
||||
}
|
||||
async ownerFrame() {
|
||||
return import_frame.Frame.fromNullable((await this._elementChannel.ownerFrame()).frame);
|
||||
}
|
||||
async contentFrame() {
|
||||
return import_frame.Frame.fromNullable((await this._elementChannel.contentFrame()).frame);
|
||||
}
|
||||
async getAttribute(name) {
|
||||
const value = (await this._elementChannel.getAttribute({ name })).value;
|
||||
return value === void 0 ? null : value;
|
||||
}
|
||||
async inputValue() {
|
||||
return (await this._elementChannel.inputValue()).value;
|
||||
}
|
||||
async textContent() {
|
||||
const value = (await this._elementChannel.textContent()).value;
|
||||
return value === void 0 ? null : value;
|
||||
}
|
||||
async innerText() {
|
||||
return (await this._elementChannel.innerText()).value;
|
||||
}
|
||||
async innerHTML() {
|
||||
return (await this._elementChannel.innerHTML()).value;
|
||||
}
|
||||
async isChecked() {
|
||||
return (await this._elementChannel.isChecked()).value;
|
||||
}
|
||||
async isDisabled() {
|
||||
return (await this._elementChannel.isDisabled()).value;
|
||||
}
|
||||
async isEditable() {
|
||||
return (await this._elementChannel.isEditable()).value;
|
||||
}
|
||||
async isEnabled() {
|
||||
return (await this._elementChannel.isEnabled()).value;
|
||||
}
|
||||
async isHidden() {
|
||||
return (await this._elementChannel.isHidden()).value;
|
||||
}
|
||||
async isVisible() {
|
||||
return (await this._elementChannel.isVisible()).value;
|
||||
}
|
||||
async dispatchEvent(type, eventInit = {}) {
|
||||
await this._elementChannel.dispatchEvent({ type, eventInit: (0, import_jsHandle.serializeArgument)(eventInit) });
|
||||
}
|
||||
async scrollIntoViewIfNeeded(options = {}) {
|
||||
await this._elementChannel.scrollIntoViewIfNeeded({ ...options, timeout: this._frame._timeout(options) });
|
||||
}
|
||||
async hover(options = {}) {
|
||||
await this._elementChannel.hover({ ...options, timeout: this._frame._timeout(options) });
|
||||
}
|
||||
async click(options = {}) {
|
||||
return await this._elementChannel.click({ ...options, timeout: this._frame._timeout(options) });
|
||||
}
|
||||
async dblclick(options = {}) {
|
||||
return await this._elementChannel.dblclick({ ...options, timeout: this._frame._timeout(options) });
|
||||
}
|
||||
async tap(options = {}) {
|
||||
return await this._elementChannel.tap({ ...options, timeout: this._frame._timeout(options) });
|
||||
}
|
||||
async selectOption(values, options = {}) {
|
||||
const result = await this._elementChannel.selectOption({ ...convertSelectOptionValues(values), ...options, timeout: this._frame._timeout(options) });
|
||||
return result.values;
|
||||
}
|
||||
async fill(value, options = {}) {
|
||||
return await this._elementChannel.fill({ value, ...options, timeout: this._frame._timeout(options) });
|
||||
}
|
||||
async selectText(options = {}) {
|
||||
await this._elementChannel.selectText({ ...options, timeout: this._frame._timeout(options) });
|
||||
}
|
||||
async setInputFiles(files, options = {}) {
|
||||
const frame = await this.ownerFrame();
|
||||
if (!frame)
|
||||
throw new Error("Cannot set input files to detached element");
|
||||
const converted = await convertInputFiles(this._platform, files, frame.page().context());
|
||||
await this._elementChannel.setInputFiles({ ...converted, ...options, timeout: this._frame._timeout(options) });
|
||||
}
|
||||
async focus() {
|
||||
await this._elementChannel.focus();
|
||||
}
|
||||
async type(text, options = {}) {
|
||||
await this._elementChannel.type({ text, ...options, timeout: this._frame._timeout(options) });
|
||||
}
|
||||
async press(key, options = {}) {
|
||||
await this._elementChannel.press({ key, ...options, timeout: this._frame._timeout(options) });
|
||||
}
|
||||
async check(options = {}) {
|
||||
return await this._elementChannel.check({ ...options, timeout: this._frame._timeout(options) });
|
||||
}
|
||||
async uncheck(options = {}) {
|
||||
return await this._elementChannel.uncheck({ ...options, timeout: this._frame._timeout(options) });
|
||||
}
|
||||
async setChecked(checked, options) {
|
||||
if (checked)
|
||||
await this.check(options);
|
||||
else
|
||||
await this.uncheck(options);
|
||||
}
|
||||
async boundingBox() {
|
||||
const value = (await this._elementChannel.boundingBox()).value;
|
||||
return value === void 0 ? null : value;
|
||||
}
|
||||
async screenshot(options = {}) {
|
||||
const mask = options.mask;
|
||||
const copy = { ...options, mask: void 0, timeout: this._frame._timeout(options) };
|
||||
if (!copy.type)
|
||||
copy.type = determineScreenshotType(options);
|
||||
if (mask) {
|
||||
copy.mask = mask.map((locator) => ({
|
||||
frame: locator._frame._channel,
|
||||
selector: locator._selector
|
||||
}));
|
||||
}
|
||||
const result = await this._elementChannel.screenshot(copy);
|
||||
if (options.path) {
|
||||
await (0, import_fileUtils.mkdirIfNeeded)(this._platform, options.path);
|
||||
await this._platform.fs().promises.writeFile(options.path, result.binary);
|
||||
}
|
||||
return result.binary;
|
||||
}
|
||||
async $(selector) {
|
||||
return ElementHandle.fromNullable((await this._elementChannel.querySelector({ selector })).element);
|
||||
}
|
||||
async $$(selector) {
|
||||
const result = await this._elementChannel.querySelectorAll({ selector });
|
||||
return result.elements.map((h) => ElementHandle.from(h));
|
||||
}
|
||||
async $eval(selector, pageFunction, arg) {
|
||||
const result = await this._elementChannel.evalOnSelector({ selector, expression: String(pageFunction), isFunction: typeof pageFunction === "function", arg: (0, import_jsHandle.serializeArgument)(arg) });
|
||||
return (0, import_jsHandle.parseResult)(result.value);
|
||||
}
|
||||
async $$eval(selector, pageFunction, arg) {
|
||||
const result = await this._elementChannel.evalOnSelectorAll({ selector, expression: String(pageFunction), isFunction: typeof pageFunction === "function", arg: (0, import_jsHandle.serializeArgument)(arg) });
|
||||
return (0, import_jsHandle.parseResult)(result.value);
|
||||
}
|
||||
async waitForElementState(state, options = {}) {
|
||||
return await this._elementChannel.waitForElementState({ state, ...options, timeout: this._frame._timeout(options) });
|
||||
}
|
||||
async waitForSelector(selector, options = {}) {
|
||||
const result = await this._elementChannel.waitForSelector({ selector, ...options, timeout: this._frame._timeout(options) });
|
||||
return ElementHandle.fromNullable(result.element);
|
||||
}
|
||||
}
|
||||
function convertSelectOptionValues(values) {
|
||||
if (values === null)
|
||||
return {};
|
||||
if (!Array.isArray(values))
|
||||
values = [values];
|
||||
if (!values.length)
|
||||
return {};
|
||||
for (let i = 0; i < values.length; i++)
|
||||
(0, import_assert.assert)(values[i] !== null, `options[${i}]: expected object, got null`);
|
||||
if (values[0] instanceof ElementHandle)
|
||||
return { elements: values.map((v) => v._elementChannel) };
|
||||
if ((0, import_rtti.isString)(values[0]))
|
||||
return { options: values.map((valueOrLabel) => ({ valueOrLabel })) };
|
||||
return { options: values };
|
||||
}
|
||||
function filePayloadExceedsSizeLimit(payloads) {
|
||||
return payloads.reduce((size, item) => size + (item.buffer ? item.buffer.byteLength : 0), 0) >= import_fileUtils.fileUploadSizeLimit;
|
||||
}
|
||||
async function resolvePathsAndDirectoryForInputFiles(platform, items) {
|
||||
let localPaths;
|
||||
let localDirectory;
|
||||
for (const item of items) {
|
||||
const stat = await platform.fs().promises.stat(item);
|
||||
if (stat.isDirectory()) {
|
||||
if (localDirectory)
|
||||
throw new Error("Multiple directories are not supported");
|
||||
localDirectory = platform.path().resolve(item);
|
||||
} else {
|
||||
localPaths ??= [];
|
||||
localPaths.push(platform.path().resolve(item));
|
||||
}
|
||||
}
|
||||
if (localPaths?.length && localDirectory)
|
||||
throw new Error("File paths must be all files or a single directory");
|
||||
return [localPaths, localDirectory];
|
||||
}
|
||||
async function convertInputFiles(platform, files, context) {
|
||||
const items = Array.isArray(files) ? files.slice() : [files];
|
||||
if (items.some((item) => typeof item === "string")) {
|
||||
if (!items.every((item) => typeof item === "string"))
|
||||
throw new Error("File paths cannot be mixed with buffers");
|
||||
const [localPaths, localDirectory] = await resolvePathsAndDirectoryForInputFiles(platform, items);
|
||||
if (context._connection.isRemote()) {
|
||||
const files2 = localDirectory ? (await platform.fs().promises.readdir(localDirectory, { withFileTypes: true, recursive: true })).filter((f) => f.isFile()).map((f) => platform.path().join(f.path, f.name)) : localPaths;
|
||||
const { writableStreams, rootDir } = await context._wrapApiCall(async () => context._channel.createTempFiles({
|
||||
rootDirName: localDirectory ? platform.path().basename(localDirectory) : void 0,
|
||||
items: await Promise.all(files2.map(async (file) => {
|
||||
const lastModifiedMs = (await platform.fs().promises.stat(file)).mtimeMs;
|
||||
return {
|
||||
name: localDirectory ? platform.path().relative(localDirectory, file) : platform.path().basename(file),
|
||||
lastModifiedMs
|
||||
};
|
||||
}))
|
||||
}), { internal: true });
|
||||
for (let i = 0; i < files2.length; i++) {
|
||||
const writable = import_writableStream.WritableStream.from(writableStreams[i]);
|
||||
await platform.streamFile(files2[i], writable.stream());
|
||||
}
|
||||
return {
|
||||
directoryStream: rootDir,
|
||||
streams: localDirectory ? void 0 : writableStreams
|
||||
};
|
||||
}
|
||||
return {
|
||||
localPaths,
|
||||
localDirectory
|
||||
};
|
||||
}
|
||||
const payloads = items;
|
||||
if (filePayloadExceedsSizeLimit(payloads))
|
||||
throw new Error("Cannot set buffer larger than 50Mb, please write it to a file and pass its path instead.");
|
||||
return { payloads };
|
||||
}
|
||||
function determineScreenshotType(options) {
|
||||
if (options.path) {
|
||||
const mimeType = (0, import_mimeType.getMimeTypeForPath)(options.path);
|
||||
if (mimeType === "image/png")
|
||||
return "png";
|
||||
else if (mimeType === "image/jpeg")
|
||||
return "jpeg";
|
||||
throw new Error(`path: unsupported mime type "${mimeType}"`);
|
||||
}
|
||||
return options.type;
|
||||
}
|
||||
// Annotate the CommonJS export names for ESM import in node:
|
||||
0 && (module.exports = {
|
||||
ElementHandle,
|
||||
convertInputFiles,
|
||||
convertSelectOptionValues,
|
||||
determineScreenshotType
|
||||
});
|
||||
Reference in New Issue
Block a user