init commit
This commit is contained in:
iFlip721
@@ -0,0 +1,50 @@
|
||||
"use strict";
|
||||
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
exports.Accessibility = void 0;
|
||||
/**
|
||||
* Copyright 2017 Google Inc. All rights reserved.
|
||||
* Modifications copyright (c) Microsoft Corporation.
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
function axNodeFromProtocol(axNode) {
|
||||
const result = {
|
||||
...axNode,
|
||||
value: axNode.valueNumber !== undefined ? axNode.valueNumber : axNode.valueString,
|
||||
checked: axNode.checked === 'checked' ? true : axNode.checked === 'unchecked' ? false : axNode.checked,
|
||||
pressed: axNode.pressed === 'pressed' ? true : axNode.pressed === 'released' ? false : axNode.pressed,
|
||||
children: axNode.children ? axNode.children.map(axNodeFromProtocol) : undefined
|
||||
};
|
||||
delete result.valueNumber;
|
||||
delete result.valueString;
|
||||
return result;
|
||||
}
|
||||
class Accessibility {
|
||||
constructor(channel) {
|
||||
this._channel = void 0;
|
||||
this._channel = channel;
|
||||
}
|
||||
async snapshot(options = {}) {
|
||||
const root = options.root ? options.root._elementChannel : undefined;
|
||||
const result = await this._channel.accessibilitySnapshot({
|
||||
interestingOnly: options.interestingOnly,
|
||||
root
|
||||
});
|
||||
return result.rootAXNode ? axNodeFromProtocol(result.rootAXNode) : null;
|
||||
}
|
||||
}
|
||||
exports.Accessibility = Accessibility;
|
||||
466
bin/pac/tools/.playwright/package/lib/client/android.js
Normal file
466
bin/pac/tools/.playwright/package/lib/client/android.js
Normal file
@@ -0,0 +1,466 @@
|
||||
"use strict";
|
||||
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
exports.AndroidWebView = exports.AndroidSocket = exports.AndroidInput = exports.AndroidDevice = exports.Android = void 0;
|
||||
var _fs = _interopRequireDefault(require("fs"));
|
||||
var _utils = require("../utils");
|
||||
var _events = require("./events");
|
||||
var _browserContext = require("./browserContext");
|
||||
var _channelOwner = require("./channelOwner");
|
||||
var _timeoutSettings = require("../common/timeoutSettings");
|
||||
var _waiter = require("./waiter");
|
||||
var _events2 = require("events");
|
||||
var _connection = require("./connection");
|
||||
var _errors = require("../common/errors");
|
||||
var _timeoutRunner = require("../utils/timeoutRunner");
|
||||
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
||||
/**
|
||||
* Copyright (c) Microsoft Corporation.
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
class Android extends _channelOwner.ChannelOwner {
|
||||
static from(android) {
|
||||
return android._object;
|
||||
}
|
||||
constructor(parent, type, guid, initializer) {
|
||||
super(parent, type, guid, initializer);
|
||||
this._timeoutSettings = void 0;
|
||||
this._serverLauncher = void 0;
|
||||
this._timeoutSettings = new _timeoutSettings.TimeoutSettings();
|
||||
}
|
||||
setDefaultTimeout(timeout) {
|
||||
this._timeoutSettings.setDefaultTimeout(timeout);
|
||||
this._channel.setDefaultTimeoutNoReply({
|
||||
timeout
|
||||
});
|
||||
}
|
||||
async devices(options = {}) {
|
||||
const {
|
||||
devices
|
||||
} = await this._channel.devices(options);
|
||||
return devices.map(d => AndroidDevice.from(d));
|
||||
}
|
||||
async launchServer(options = {}) {
|
||||
if (!this._serverLauncher) throw new Error('Launching server is not supported');
|
||||
return this._serverLauncher.launchServer(options);
|
||||
}
|
||||
async connect(wsEndpoint, options = {}) {
|
||||
return await this._wrapApiCall(async () => {
|
||||
const deadline = options.timeout ? (0, _utils.monotonicTime)() + options.timeout : 0;
|
||||
const headers = {
|
||||
'x-playwright-browser': 'android',
|
||||
...options.headers
|
||||
};
|
||||
const localUtils = this._connection.localUtils();
|
||||
const connectParams = {
|
||||
wsEndpoint,
|
||||
headers,
|
||||
slowMo: options.slowMo,
|
||||
timeout: options.timeout
|
||||
};
|
||||
const {
|
||||
pipe
|
||||
} = await localUtils._channel.connect(connectParams);
|
||||
const closePipe = () => pipe.close().catch(() => {});
|
||||
const connection = new _connection.Connection(localUtils, this._instrumentation);
|
||||
connection.markAsRemote();
|
||||
connection.on('close', closePipe);
|
||||
let device;
|
||||
let closeError;
|
||||
const onPipeClosed = () => {
|
||||
var _device;
|
||||
(_device = device) === null || _device === void 0 ? void 0 : _device._didClose();
|
||||
connection.close(closeError || _errors.kBrowserClosedError);
|
||||
};
|
||||
pipe.on('closed', onPipeClosed);
|
||||
connection.onmessage = message => pipe.send({
|
||||
message
|
||||
}).catch(onPipeClosed);
|
||||
pipe.on('message', ({
|
||||
message
|
||||
}) => {
|
||||
try {
|
||||
connection.dispatch(message);
|
||||
} catch (e) {
|
||||
closeError = e.toString();
|
||||
closePipe();
|
||||
}
|
||||
});
|
||||
const result = await (0, _timeoutRunner.raceAgainstTimeout)(async () => {
|
||||
const playwright = await connection.initializePlaywright();
|
||||
if (!playwright._initializer.preConnectedAndroidDevice) {
|
||||
closePipe();
|
||||
throw new Error('Malformed endpoint. Did you use Android.launchServer method?');
|
||||
}
|
||||
device = AndroidDevice.from(playwright._initializer.preConnectedAndroidDevice);
|
||||
device._shouldCloseConnectionOnClose = true;
|
||||
device.on(_events.Events.AndroidDevice.Close, closePipe);
|
||||
return device;
|
||||
}, deadline ? deadline - (0, _utils.monotonicTime)() : 0);
|
||||
if (!result.timedOut) {
|
||||
return result.result;
|
||||
} else {
|
||||
closePipe();
|
||||
throw new Error(`Timeout ${options.timeout}ms exceeded`);
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
exports.Android = Android;
|
||||
class AndroidDevice extends _channelOwner.ChannelOwner {
|
||||
static from(androidDevice) {
|
||||
return androidDevice._object;
|
||||
}
|
||||
constructor(parent, type, guid, initializer) {
|
||||
super(parent, type, guid, initializer);
|
||||
this._timeoutSettings = void 0;
|
||||
this._webViews = new Map();
|
||||
this._shouldCloseConnectionOnClose = false;
|
||||
this.input = void 0;
|
||||
this.input = new AndroidInput(this);
|
||||
this._timeoutSettings = new _timeoutSettings.TimeoutSettings(parent._timeoutSettings);
|
||||
this._channel.on('webViewAdded', ({
|
||||
webView
|
||||
}) => this._onWebViewAdded(webView));
|
||||
this._channel.on('webViewRemoved', ({
|
||||
socketName
|
||||
}) => this._onWebViewRemoved(socketName));
|
||||
this._channel.on('close', () => this._didClose());
|
||||
}
|
||||
_onWebViewAdded(webView) {
|
||||
const view = new AndroidWebView(this, webView);
|
||||
this._webViews.set(webView.socketName, view);
|
||||
this.emit(_events.Events.AndroidDevice.WebView, view);
|
||||
}
|
||||
_onWebViewRemoved(socketName) {
|
||||
const view = this._webViews.get(socketName);
|
||||
this._webViews.delete(socketName);
|
||||
if (view) view.emit(_events.Events.AndroidWebView.Close);
|
||||
}
|
||||
setDefaultTimeout(timeout) {
|
||||
this._timeoutSettings.setDefaultTimeout(timeout);
|
||||
this._channel.setDefaultTimeoutNoReply({
|
||||
timeout
|
||||
});
|
||||
}
|
||||
serial() {
|
||||
return this._initializer.serial;
|
||||
}
|
||||
model() {
|
||||
return this._initializer.model;
|
||||
}
|
||||
webViews() {
|
||||
return [...this._webViews.values()];
|
||||
}
|
||||
async webView(selector, options) {
|
||||
const predicate = v => {
|
||||
if (selector.pkg) return v.pkg() === selector.pkg;
|
||||
if (selector.socketName) return v._socketName() === selector.socketName;
|
||||
return false;
|
||||
};
|
||||
const webView = [...this._webViews.values()].find(predicate);
|
||||
if (webView) return webView;
|
||||
return this.waitForEvent('webview', {
|
||||
...options,
|
||||
predicate
|
||||
});
|
||||
}
|
||||
async wait(selector, options) {
|
||||
await this._channel.wait({
|
||||
selector: toSelectorChannel(selector),
|
||||
...options
|
||||
});
|
||||
}
|
||||
async fill(selector, text, options) {
|
||||
await this._channel.fill({
|
||||
selector: toSelectorChannel(selector),
|
||||
text,
|
||||
...options
|
||||
});
|
||||
}
|
||||
async press(selector, key, options) {
|
||||
await this.tap(selector, options);
|
||||
await this.input.press(key);
|
||||
}
|
||||
async tap(selector, options) {
|
||||
await this._channel.tap({
|
||||
selector: toSelectorChannel(selector),
|
||||
...options
|
||||
});
|
||||
}
|
||||
async drag(selector, dest, options) {
|
||||
await this._channel.drag({
|
||||
selector: toSelectorChannel(selector),
|
||||
dest,
|
||||
...options
|
||||
});
|
||||
}
|
||||
async fling(selector, direction, options) {
|
||||
await this._channel.fling({
|
||||
selector: toSelectorChannel(selector),
|
||||
direction,
|
||||
...options
|
||||
});
|
||||
}
|
||||
async longTap(selector, options) {
|
||||
await this._channel.longTap({
|
||||
selector: toSelectorChannel(selector),
|
||||
...options
|
||||
});
|
||||
}
|
||||
async pinchClose(selector, percent, options) {
|
||||
await this._channel.pinchClose({
|
||||
selector: toSelectorChannel(selector),
|
||||
percent,
|
||||
...options
|
||||
});
|
||||
}
|
||||
async pinchOpen(selector, percent, options) {
|
||||
await this._channel.pinchOpen({
|
||||
selector: toSelectorChannel(selector),
|
||||
percent,
|
||||
...options
|
||||
});
|
||||
}
|
||||
async scroll(selector, direction, percent, options) {
|
||||
await this._channel.scroll({
|
||||
selector: toSelectorChannel(selector),
|
||||
direction,
|
||||
percent,
|
||||
...options
|
||||
});
|
||||
}
|
||||
async swipe(selector, direction, percent, options) {
|
||||
await this._channel.swipe({
|
||||
selector: toSelectorChannel(selector),
|
||||
direction,
|
||||
percent,
|
||||
...options
|
||||
});
|
||||
}
|
||||
async info(selector) {
|
||||
return (await this._channel.info({
|
||||
selector: toSelectorChannel(selector)
|
||||
})).info;
|
||||
}
|
||||
async screenshot(options = {}) {
|
||||
const {
|
||||
binary
|
||||
} = await this._channel.screenshot();
|
||||
if (options.path) await _fs.default.promises.writeFile(options.path, binary);
|
||||
return binary;
|
||||
}
|
||||
async close() {
|
||||
try {
|
||||
if (this._shouldCloseConnectionOnClose) this._connection.close(_errors.kBrowserClosedError);else await this._channel.close();
|
||||
} catch (e) {
|
||||
if ((0, _errors.isSafeCloseError)(e)) return;
|
||||
throw e;
|
||||
}
|
||||
}
|
||||
_didClose() {
|
||||
this.emit(_events.Events.AndroidDevice.Close, this);
|
||||
}
|
||||
async shell(command) {
|
||||
const {
|
||||
result
|
||||
} = await this._channel.shell({
|
||||
command
|
||||
});
|
||||
return result;
|
||||
}
|
||||
async open(command) {
|
||||
return AndroidSocket.from((await this._channel.open({
|
||||
command
|
||||
})).socket);
|
||||
}
|
||||
async installApk(file, options) {
|
||||
await this._channel.installApk({
|
||||
file: await loadFile(file),
|
||||
args: options && options.args
|
||||
});
|
||||
}
|
||||
async push(file, path, options) {
|
||||
await this._channel.push({
|
||||
file: await loadFile(file),
|
||||
path,
|
||||
mode: options ? options.mode : undefined
|
||||
});
|
||||
}
|
||||
async launchBrowser(options = {}) {
|
||||
const contextOptions = await (0, _browserContext.prepareBrowserContextParams)(options);
|
||||
const {
|
||||
context
|
||||
} = await this._channel.launchBrowser(contextOptions);
|
||||
return _browserContext.BrowserContext.from(context);
|
||||
}
|
||||
async waitForEvent(event, optionsOrPredicate = {}) {
|
||||
return this._wrapApiCall(async () => {
|
||||
const timeout = this._timeoutSettings.timeout(typeof optionsOrPredicate === 'function' ? {} : optionsOrPredicate);
|
||||
const predicate = typeof optionsOrPredicate === 'function' ? optionsOrPredicate : optionsOrPredicate.predicate;
|
||||
const waiter = _waiter.Waiter.createForEvent(this, event);
|
||||
waiter.rejectOnTimeout(timeout, `Timeout ${timeout}ms exceeded while waiting for event "${event}"`);
|
||||
if (event !== _events.Events.AndroidDevice.Close) waiter.rejectOnEvent(this, _events.Events.AndroidDevice.Close, new Error('Device closed'));
|
||||
const result = await waiter.waitForEvent(this, event, predicate);
|
||||
waiter.dispose();
|
||||
return result;
|
||||
});
|
||||
}
|
||||
}
|
||||
exports.AndroidDevice = AndroidDevice;
|
||||
class AndroidSocket extends _channelOwner.ChannelOwner {
|
||||
static from(androidDevice) {
|
||||
return androidDevice._object;
|
||||
}
|
||||
constructor(parent, type, guid, initializer) {
|
||||
super(parent, type, guid, initializer);
|
||||
this._channel.on('data', ({
|
||||
data
|
||||
}) => this.emit(_events.Events.AndroidSocket.Data, data));
|
||||
this._channel.on('close', () => this.emit(_events.Events.AndroidSocket.Close));
|
||||
}
|
||||
async write(data) {
|
||||
await this._channel.write({
|
||||
data
|
||||
});
|
||||
}
|
||||
async close() {
|
||||
await this._channel.close();
|
||||
}
|
||||
}
|
||||
exports.AndroidSocket = AndroidSocket;
|
||||
async function loadFile(file) {
|
||||
if ((0, _utils.isString)(file)) return _fs.default.promises.readFile(file);
|
||||
return file;
|
||||
}
|
||||
class AndroidInput {
|
||||
constructor(device) {
|
||||
this._device = void 0;
|
||||
this._device = device;
|
||||
}
|
||||
async type(text) {
|
||||
await this._device._channel.inputType({
|
||||
text
|
||||
});
|
||||
}
|
||||
async press(key) {
|
||||
await this._device._channel.inputPress({
|
||||
key
|
||||
});
|
||||
}
|
||||
async tap(point) {
|
||||
await this._device._channel.inputTap({
|
||||
point
|
||||
});
|
||||
}
|
||||
async swipe(from, segments, steps) {
|
||||
await this._device._channel.inputSwipe({
|
||||
segments,
|
||||
steps
|
||||
});
|
||||
}
|
||||
async drag(from, to, steps) {
|
||||
await this._device._channel.inputDrag({
|
||||
from,
|
||||
to,
|
||||
steps
|
||||
});
|
||||
}
|
||||
}
|
||||
exports.AndroidInput = AndroidInput;
|
||||
function toSelectorChannel(selector) {
|
||||
const {
|
||||
checkable,
|
||||
checked,
|
||||
clazz,
|
||||
clickable,
|
||||
depth,
|
||||
desc,
|
||||
enabled,
|
||||
focusable,
|
||||
focused,
|
||||
hasChild,
|
||||
hasDescendant,
|
||||
longClickable,
|
||||
pkg,
|
||||
res,
|
||||
scrollable,
|
||||
selected,
|
||||
text
|
||||
} = selector;
|
||||
const toRegex = value => {
|
||||
if (value === undefined) return undefined;
|
||||
if ((0, _utils.isRegExp)(value)) return value.source;
|
||||
return '^' + value.replace(/[|\\{}()[\]^$+*?.]/g, '\\$&').replace(/-/g, '\\x2d') + '$';
|
||||
};
|
||||
return {
|
||||
checkable,
|
||||
checked,
|
||||
clazz: toRegex(clazz),
|
||||
pkg: toRegex(pkg),
|
||||
desc: toRegex(desc),
|
||||
res: toRegex(res),
|
||||
text: toRegex(text),
|
||||
clickable,
|
||||
depth,
|
||||
enabled,
|
||||
focusable,
|
||||
focused,
|
||||
hasChild: hasChild ? {
|
||||
selector: toSelectorChannel(hasChild.selector)
|
||||
} : undefined,
|
||||
hasDescendant: hasDescendant ? {
|
||||
selector: toSelectorChannel(hasDescendant.selector),
|
||||
maxDepth: hasDescendant.maxDepth
|
||||
} : undefined,
|
||||
longClickable,
|
||||
scrollable,
|
||||
selected
|
||||
};
|
||||
}
|
||||
class AndroidWebView extends _events2.EventEmitter {
|
||||
constructor(device, data) {
|
||||
super();
|
||||
this._device = void 0;
|
||||
this._data = void 0;
|
||||
this._pagePromise = void 0;
|
||||
this._device = device;
|
||||
this._data = data;
|
||||
}
|
||||
pid() {
|
||||
return this._data.pid;
|
||||
}
|
||||
pkg() {
|
||||
return this._data.pkg;
|
||||
}
|
||||
_socketName() {
|
||||
return this._data.socketName;
|
||||
}
|
||||
async page() {
|
||||
if (!this._pagePromise) this._pagePromise = this._fetchPage();
|
||||
return this._pagePromise;
|
||||
}
|
||||
async _fetchPage() {
|
||||
const {
|
||||
context
|
||||
} = await this._device._channel.connectToWebView({
|
||||
socketName: this._data.socketName
|
||||
});
|
||||
return _browserContext.BrowserContext.from(context).pages()[0];
|
||||
}
|
||||
}
|
||||
exports.AndroidWebView = AndroidWebView;
|
||||
265
bin/pac/tools/.playwright/package/lib/client/api.js
Normal file
265
bin/pac/tools/.playwright/package/lib/client/api.js
Normal file
@@ -0,0 +1,265 @@
|
||||
"use strict";
|
||||
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
Object.defineProperty(exports, "APIRequest", {
|
||||
enumerable: true,
|
||||
get: function () {
|
||||
return _fetch.APIRequest;
|
||||
}
|
||||
});
|
||||
Object.defineProperty(exports, "APIRequestContext", {
|
||||
enumerable: true,
|
||||
get: function () {
|
||||
return _fetch.APIRequestContext;
|
||||
}
|
||||
});
|
||||
Object.defineProperty(exports, "APIResponse", {
|
||||
enumerable: true,
|
||||
get: function () {
|
||||
return _fetch.APIResponse;
|
||||
}
|
||||
});
|
||||
Object.defineProperty(exports, "Accessibility", {
|
||||
enumerable: true,
|
||||
get: function () {
|
||||
return _accessibility.Accessibility;
|
||||
}
|
||||
});
|
||||
Object.defineProperty(exports, "Android", {
|
||||
enumerable: true,
|
||||
get: function () {
|
||||
return _android.Android;
|
||||
}
|
||||
});
|
||||
Object.defineProperty(exports, "AndroidDevice", {
|
||||
enumerable: true,
|
||||
get: function () {
|
||||
return _android.AndroidDevice;
|
||||
}
|
||||
});
|
||||
Object.defineProperty(exports, "AndroidInput", {
|
||||
enumerable: true,
|
||||
get: function () {
|
||||
return _android.AndroidInput;
|
||||
}
|
||||
});
|
||||
Object.defineProperty(exports, "AndroidSocket", {
|
||||
enumerable: true,
|
||||
get: function () {
|
||||
return _android.AndroidSocket;
|
||||
}
|
||||
});
|
||||
Object.defineProperty(exports, "AndroidWebView", {
|
||||
enumerable: true,
|
||||
get: function () {
|
||||
return _android.AndroidWebView;
|
||||
}
|
||||
});
|
||||
Object.defineProperty(exports, "Browser", {
|
||||
enumerable: true,
|
||||
get: function () {
|
||||
return _browser.Browser;
|
||||
}
|
||||
});
|
||||
Object.defineProperty(exports, "BrowserContext", {
|
||||
enumerable: true,
|
||||
get: function () {
|
||||
return _browserContext.BrowserContext;
|
||||
}
|
||||
});
|
||||
Object.defineProperty(exports, "BrowserType", {
|
||||
enumerable: true,
|
||||
get: function () {
|
||||
return _browserType.BrowserType;
|
||||
}
|
||||
});
|
||||
Object.defineProperty(exports, "CDPSession", {
|
||||
enumerable: true,
|
||||
get: function () {
|
||||
return _cdpSession.CDPSession;
|
||||
}
|
||||
});
|
||||
Object.defineProperty(exports, "ConsoleMessage", {
|
||||
enumerable: true,
|
||||
get: function () {
|
||||
return _consoleMessage.ConsoleMessage;
|
||||
}
|
||||
});
|
||||
Object.defineProperty(exports, "Coverage", {
|
||||
enumerable: true,
|
||||
get: function () {
|
||||
return _coverage.Coverage;
|
||||
}
|
||||
});
|
||||
Object.defineProperty(exports, "Dialog", {
|
||||
enumerable: true,
|
||||
get: function () {
|
||||
return _dialog.Dialog;
|
||||
}
|
||||
});
|
||||
Object.defineProperty(exports, "Download", {
|
||||
enumerable: true,
|
||||
get: function () {
|
||||
return _download.Download;
|
||||
}
|
||||
});
|
||||
Object.defineProperty(exports, "Electron", {
|
||||
enumerable: true,
|
||||
get: function () {
|
||||
return _electron.Electron;
|
||||
}
|
||||
});
|
||||
Object.defineProperty(exports, "ElectronApplication", {
|
||||
enumerable: true,
|
||||
get: function () {
|
||||
return _electron.ElectronApplication;
|
||||
}
|
||||
});
|
||||
Object.defineProperty(exports, "ElementHandle", {
|
||||
enumerable: true,
|
||||
get: function () {
|
||||
return _elementHandle.ElementHandle;
|
||||
}
|
||||
});
|
||||
Object.defineProperty(exports, "FileChooser", {
|
||||
enumerable: true,
|
||||
get: function () {
|
||||
return _fileChooser.FileChooser;
|
||||
}
|
||||
});
|
||||
Object.defineProperty(exports, "Frame", {
|
||||
enumerable: true,
|
||||
get: function () {
|
||||
return _frame.Frame;
|
||||
}
|
||||
});
|
||||
Object.defineProperty(exports, "FrameLocator", {
|
||||
enumerable: true,
|
||||
get: function () {
|
||||
return _locator.FrameLocator;
|
||||
}
|
||||
});
|
||||
Object.defineProperty(exports, "JSHandle", {
|
||||
enumerable: true,
|
||||
get: function () {
|
||||
return _jsHandle.JSHandle;
|
||||
}
|
||||
});
|
||||
Object.defineProperty(exports, "Keyboard", {
|
||||
enumerable: true,
|
||||
get: function () {
|
||||
return _input.Keyboard;
|
||||
}
|
||||
});
|
||||
Object.defineProperty(exports, "Locator", {
|
||||
enumerable: true,
|
||||
get: function () {
|
||||
return _locator.Locator;
|
||||
}
|
||||
});
|
||||
Object.defineProperty(exports, "Mouse", {
|
||||
enumerable: true,
|
||||
get: function () {
|
||||
return _input.Mouse;
|
||||
}
|
||||
});
|
||||
Object.defineProperty(exports, "Page", {
|
||||
enumerable: true,
|
||||
get: function () {
|
||||
return _page.Page;
|
||||
}
|
||||
});
|
||||
Object.defineProperty(exports, "Playwright", {
|
||||
enumerable: true,
|
||||
get: function () {
|
||||
return _playwright.Playwright;
|
||||
}
|
||||
});
|
||||
Object.defineProperty(exports, "Request", {
|
||||
enumerable: true,
|
||||
get: function () {
|
||||
return _network.Request;
|
||||
}
|
||||
});
|
||||
Object.defineProperty(exports, "Response", {
|
||||
enumerable: true,
|
||||
get: function () {
|
||||
return _network.Response;
|
||||
}
|
||||
});
|
||||
Object.defineProperty(exports, "Route", {
|
||||
enumerable: true,
|
||||
get: function () {
|
||||
return _network.Route;
|
||||
}
|
||||
});
|
||||
Object.defineProperty(exports, "Selectors", {
|
||||
enumerable: true,
|
||||
get: function () {
|
||||
return _selectors.Selectors;
|
||||
}
|
||||
});
|
||||
Object.defineProperty(exports, "TimeoutError", {
|
||||
enumerable: true,
|
||||
get: function () {
|
||||
return _errors.TimeoutError;
|
||||
}
|
||||
});
|
||||
Object.defineProperty(exports, "Touchscreen", {
|
||||
enumerable: true,
|
||||
get: function () {
|
||||
return _input.Touchscreen;
|
||||
}
|
||||
});
|
||||
Object.defineProperty(exports, "Tracing", {
|
||||
enumerable: true,
|
||||
get: function () {
|
||||
return _tracing.Tracing;
|
||||
}
|
||||
});
|
||||
Object.defineProperty(exports, "Video", {
|
||||
enumerable: true,
|
||||
get: function () {
|
||||
return _video.Video;
|
||||
}
|
||||
});
|
||||
Object.defineProperty(exports, "WebSocket", {
|
||||
enumerable: true,
|
||||
get: function () {
|
||||
return _network.WebSocket;
|
||||
}
|
||||
});
|
||||
Object.defineProperty(exports, "Worker", {
|
||||
enumerable: true,
|
||||
get: function () {
|
||||
return _worker.Worker;
|
||||
}
|
||||
});
|
||||
var _accessibility = require("./accessibility");
|
||||
var _android = require("./android");
|
||||
var _browser = require("./browser");
|
||||
var _browserContext = require("./browserContext");
|
||||
var _browserType = require("./browserType");
|
||||
var _consoleMessage = require("./consoleMessage");
|
||||
var _coverage = require("./coverage");
|
||||
var _dialog = require("./dialog");
|
||||
var _download = require("./download");
|
||||
var _electron = require("./electron");
|
||||
var _locator = require("./locator");
|
||||
var _elementHandle = require("./elementHandle");
|
||||
var _fileChooser = require("./fileChooser");
|
||||
var _errors = require("../common/errors");
|
||||
var _frame = require("./frame");
|
||||
var _input = require("./input");
|
||||
var _jsHandle = require("./jsHandle");
|
||||
var _network = require("./network");
|
||||
var _fetch = require("./fetch");
|
||||
var _page = require("./page");
|
||||
var _selectors = require("./selectors");
|
||||
var _tracing = require("./tracing");
|
||||
var _video = require("./video");
|
||||
var _worker = require("./worker");
|
||||
var _cdpSession = require("./cdpSession");
|
||||
var _playwright = require("./playwright");
|
||||
67
bin/pac/tools/.playwright/package/lib/client/artifact.js
Normal file
67
bin/pac/tools/.playwright/package/lib/client/artifact.js
Normal file
@@ -0,0 +1,67 @@
|
||||
"use strict";
|
||||
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
exports.Artifact = void 0;
|
||||
var fs = _interopRequireWildcard(require("fs"));
|
||||
var _stream = require("./stream");
|
||||
var _fileUtils = require("../utils/fileUtils");
|
||||
var _channelOwner = require("./channelOwner");
|
||||
function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
|
||||
function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
|
||||
/**
|
||||
* Copyright (c) Microsoft Corporation.
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
class Artifact extends _channelOwner.ChannelOwner {
|
||||
static from(channel) {
|
||||
return channel._object;
|
||||
}
|
||||
async pathAfterFinished() {
|
||||
if (this._connection.isRemote()) throw new Error(`Path is not available when connecting remotely. Use saveAs() to save a local copy.`);
|
||||
return (await this._channel.pathAfterFinished()).value || null;
|
||||
}
|
||||
async saveAs(path) {
|
||||
if (!this._connection.isRemote()) {
|
||||
await this._channel.saveAs({
|
||||
path
|
||||
});
|
||||
return;
|
||||
}
|
||||
const result = await this._channel.saveAsStream();
|
||||
const stream = _stream.Stream.from(result.stream);
|
||||
await (0, _fileUtils.mkdirIfNeeded)(path);
|
||||
await new Promise((resolve, reject) => {
|
||||
stream.stream().pipe(fs.createWriteStream(path)).on('finish', resolve).on('error', reject);
|
||||
});
|
||||
}
|
||||
async failure() {
|
||||
return (await this._channel.failure()).error || null;
|
||||
}
|
||||
async createReadStream() {
|
||||
const result = await this._channel.stream();
|
||||
if (!result.stream) return null;
|
||||
const stream = _stream.Stream.from(result.stream);
|
||||
return stream.stream();
|
||||
}
|
||||
async cancel() {
|
||||
return this._channel.cancel();
|
||||
}
|
||||
async delete() {
|
||||
return this._channel.delete();
|
||||
}
|
||||
}
|
||||
exports.Artifact = Artifact;
|
||||
119
bin/pac/tools/.playwright/package/lib/client/browser.js
Normal file
119
bin/pac/tools/.playwright/package/lib/client/browser.js
Normal file
@@ -0,0 +1,119 @@
|
||||
"use strict";
|
||||
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
exports.Browser = void 0;
|
||||
var _browserContext = require("./browserContext");
|
||||
var _channelOwner = require("./channelOwner");
|
||||
var _events = require("./events");
|
||||
var _errors = require("../common/errors");
|
||||
var _cdpSession = require("./cdpSession");
|
||||
/**
|
||||
* Copyright (c) Microsoft Corporation.
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
class Browser extends _channelOwner.ChannelOwner {
|
||||
// Used from @playwright/test fixtures.
|
||||
|
||||
static from(browser) {
|
||||
return browser._object;
|
||||
}
|
||||
constructor(parent, type, guid, initializer) {
|
||||
super(parent, type, guid, initializer);
|
||||
this._contexts = new Set();
|
||||
this._isConnected = true;
|
||||
this._closedPromise = void 0;
|
||||
this._shouldCloseConnectionOnClose = false;
|
||||
this._browserType = void 0;
|
||||
this._options = {};
|
||||
this._name = void 0;
|
||||
this._connectHeaders = void 0;
|
||||
this._name = initializer.name;
|
||||
this._channel.on('close', () => this._didClose());
|
||||
this._closedPromise = new Promise(f => this.once(_events.Events.Browser.Disconnected, f));
|
||||
}
|
||||
browserType() {
|
||||
return this._browserType;
|
||||
}
|
||||
async newContext(options = {}) {
|
||||
return await this._innerNewContext(options, false);
|
||||
}
|
||||
async _newContextForReuse(options = {}) {
|
||||
return await this._wrapApiCall(async () => {
|
||||
for (const context of this._contexts) {
|
||||
await this._browserType._willCloseContext(context);
|
||||
for (const page of context.pages()) page._onClose();
|
||||
context._onClose();
|
||||
}
|
||||
return await this._innerNewContext(options, true);
|
||||
}, true);
|
||||
}
|
||||
async _innerNewContext(options = {}, forReuse) {
|
||||
options = {
|
||||
...this._browserType._defaultContextOptions,
|
||||
...options
|
||||
};
|
||||
const contextOptions = await (0, _browserContext.prepareBrowserContextParams)(options);
|
||||
const response = forReuse ? await this._channel.newContextForReuse(contextOptions) : await this._channel.newContext(contextOptions);
|
||||
const context = _browserContext.BrowserContext.from(response.context);
|
||||
await this._browserType._didCreateContext(context, contextOptions, this._options, options.logger || this._logger);
|
||||
return context;
|
||||
}
|
||||
contexts() {
|
||||
return [...this._contexts];
|
||||
}
|
||||
version() {
|
||||
return this._initializer.version;
|
||||
}
|
||||
async newPage(options = {}) {
|
||||
return await this._wrapApiCall(async () => {
|
||||
const context = await this.newContext(options);
|
||||
const page = await context.newPage();
|
||||
page._ownedContext = context;
|
||||
context._ownerPage = page;
|
||||
return page;
|
||||
});
|
||||
}
|
||||
isConnected() {
|
||||
return this._isConnected;
|
||||
}
|
||||
async newBrowserCDPSession() {
|
||||
return _cdpSession.CDPSession.from((await this._channel.newBrowserCDPSession()).session);
|
||||
}
|
||||
async startTracing(page, options = {}) {
|
||||
await this._channel.startTracing({
|
||||
...options,
|
||||
page: page ? page._channel : undefined
|
||||
});
|
||||
}
|
||||
async stopTracing() {
|
||||
return (await this._channel.stopTracing()).binary;
|
||||
}
|
||||
async close() {
|
||||
try {
|
||||
if (this._shouldCloseConnectionOnClose) this._connection.close(_errors.kBrowserClosedError);else await this._channel.close();
|
||||
await this._closedPromise;
|
||||
} catch (e) {
|
||||
if ((0, _errors.isSafeCloseError)(e)) return;
|
||||
throw e;
|
||||
}
|
||||
}
|
||||
_didClose() {
|
||||
this._isConnected = false;
|
||||
this.emit(_events.Events.Browser.Disconnected, this);
|
||||
}
|
||||
}
|
||||
exports.Browser = Browser;
|
||||
452
bin/pac/tools/.playwright/package/lib/client/browserContext.js
Normal file
452
bin/pac/tools/.playwright/package/lib/client/browserContext.js
Normal file
@@ -0,0 +1,452 @@
|
||||
"use strict";
|
||||
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
exports.BrowserContext = void 0;
|
||||
exports.prepareBrowserContextParams = prepareBrowserContextParams;
|
||||
var _page = require("./page");
|
||||
var _frame = require("./frame");
|
||||
var network = _interopRequireWildcard(require("./network"));
|
||||
var _fs = _interopRequireDefault(require("fs"));
|
||||
var _channelOwner = require("./channelOwner");
|
||||
var _clientHelper = require("./clientHelper");
|
||||
var _browser = require("./browser");
|
||||
var _worker = require("./worker");
|
||||
var _events = require("./events");
|
||||
var _timeoutSettings = require("../common/timeoutSettings");
|
||||
var _waiter = require("./waiter");
|
||||
var _utils = require("../utils");
|
||||
var _fileUtils = require("../utils/fileUtils");
|
||||
var _cdpSession = require("./cdpSession");
|
||||
var _tracing = require("./tracing");
|
||||
var _artifact = require("./artifact");
|
||||
var _fetch = require("./fetch");
|
||||
var _stackTrace = require("../utils/stackTrace");
|
||||
var _harRouter = require("./harRouter");
|
||||
var _consoleMessage = require("./consoleMessage");
|
||||
var _dialog = require("./dialog");
|
||||
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
||||
function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
|
||||
function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
|
||||
/**
|
||||
* Copyright 2017 Google Inc. All rights reserved.
|
||||
* Modifications copyright (c) Microsoft Corporation.
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
class BrowserContext extends _channelOwner.ChannelOwner {
|
||||
static from(context) {
|
||||
return context._object;
|
||||
}
|
||||
static fromNullable(context) {
|
||||
return context ? BrowserContext.from(context) : null;
|
||||
}
|
||||
constructor(parent, type, guid, initializer) {
|
||||
var _this$_browser, _this$_browser2;
|
||||
super(parent, type, guid, initializer);
|
||||
this._pages = new Set();
|
||||
this._routes = [];
|
||||
this._browser = null;
|
||||
this._browserType = void 0;
|
||||
this._bindings = new Map();
|
||||
this._timeoutSettings = new _timeoutSettings.TimeoutSettings();
|
||||
this._ownerPage = void 0;
|
||||
this._closedPromise = void 0;
|
||||
this._options = {};
|
||||
this.request = void 0;
|
||||
this.tracing = void 0;
|
||||
this._backgroundPages = new Set();
|
||||
this._serviceWorkers = new Set();
|
||||
this._isChromium = void 0;
|
||||
this._harRecorders = new Map();
|
||||
this._closeWasCalled = false;
|
||||
if (parent instanceof _browser.Browser) this._browser = parent;
|
||||
(_this$_browser = this._browser) === null || _this$_browser === void 0 ? void 0 : _this$_browser._contexts.add(this);
|
||||
this._isChromium = ((_this$_browser2 = this._browser) === null || _this$_browser2 === void 0 ? void 0 : _this$_browser2._name) === 'chromium';
|
||||
this.tracing = _tracing.Tracing.from(initializer.tracing);
|
||||
this.request = _fetch.APIRequestContext.from(initializer.requestContext);
|
||||
this._channel.on('bindingCall', ({
|
||||
binding
|
||||
}) => this._onBinding(_page.BindingCall.from(binding)));
|
||||
this._channel.on('close', () => this._onClose());
|
||||
this._channel.on('page', ({
|
||||
page
|
||||
}) => this._onPage(_page.Page.from(page)));
|
||||
this._channel.on('route', ({
|
||||
route
|
||||
}) => this._onRoute(network.Route.from(route)));
|
||||
this._channel.on('backgroundPage', ({
|
||||
page
|
||||
}) => {
|
||||
const backgroundPage = _page.Page.from(page);
|
||||
this._backgroundPages.add(backgroundPage);
|
||||
this.emit(_events.Events.BrowserContext.BackgroundPage, backgroundPage);
|
||||
});
|
||||
this._channel.on('serviceWorker', ({
|
||||
worker
|
||||
}) => {
|
||||
const serviceWorker = _worker.Worker.from(worker);
|
||||
serviceWorker._context = this;
|
||||
this._serviceWorkers.add(serviceWorker);
|
||||
this.emit(_events.Events.BrowserContext.ServiceWorker, serviceWorker);
|
||||
});
|
||||
this._channel.on('console', ({
|
||||
message
|
||||
}) => {
|
||||
const consoleMessage = _consoleMessage.ConsoleMessage.from(message);
|
||||
this.emit(_events.Events.BrowserContext.Console, consoleMessage);
|
||||
const page = consoleMessage.page();
|
||||
if (page) page.emit(_events.Events.Page.Console, consoleMessage);
|
||||
});
|
||||
this._channel.on('dialog', ({
|
||||
dialog
|
||||
}) => {
|
||||
const dialogObject = _dialog.Dialog.from(dialog);
|
||||
let hasListeners = this.emit(_events.Events.BrowserContext.Dialog, dialogObject);
|
||||
const page = dialogObject.page();
|
||||
if (page) hasListeners = page.emit(_events.Events.Page.Dialog, dialogObject) || hasListeners;
|
||||
if (!hasListeners) {
|
||||
// Although we do similar handling on the server side, we still need this logic
|
||||
// on the client side due to a possible race condition between two async calls:
|
||||
// a) removing "dialog" listener subscription (client->server)
|
||||
// b) actual "dialog" event (server->client)
|
||||
if (dialogObject.type() === 'beforeunload') dialog.accept({}).catch(() => {});else dialog.dismiss().catch(() => {});
|
||||
}
|
||||
});
|
||||
this._channel.on('request', ({
|
||||
request,
|
||||
page
|
||||
}) => this._onRequest(network.Request.from(request), _page.Page.fromNullable(page)));
|
||||
this._channel.on('requestFailed', ({
|
||||
request,
|
||||
failureText,
|
||||
responseEndTiming,
|
||||
page
|
||||
}) => this._onRequestFailed(network.Request.from(request), responseEndTiming, failureText, _page.Page.fromNullable(page)));
|
||||
this._channel.on('requestFinished', params => this._onRequestFinished(params));
|
||||
this._channel.on('response', ({
|
||||
response,
|
||||
page
|
||||
}) => this._onResponse(network.Response.from(response), _page.Page.fromNullable(page)));
|
||||
this._closedPromise = new Promise(f => this.once(_events.Events.BrowserContext.Close, f));
|
||||
this._setEventToSubscriptionMapping(new Map([[_events.Events.BrowserContext.Console, 'console'], [_events.Events.BrowserContext.Dialog, 'dialog'], [_events.Events.BrowserContext.Request, 'request'], [_events.Events.BrowserContext.Response, 'response'], [_events.Events.BrowserContext.RequestFinished, 'requestFinished'], [_events.Events.BrowserContext.RequestFailed, 'requestFailed']]));
|
||||
}
|
||||
_setOptions(contextOptions, browserOptions) {
|
||||
this._options = contextOptions;
|
||||
if (this._options.recordHar) this._harRecorders.set('', {
|
||||
path: this._options.recordHar.path,
|
||||
content: this._options.recordHar.content
|
||||
});
|
||||
this.tracing._tracesDir = browserOptions.tracesDir;
|
||||
}
|
||||
_onPage(page) {
|
||||
this._pages.add(page);
|
||||
this.emit(_events.Events.BrowserContext.Page, page);
|
||||
if (page._opener && !page._opener.isClosed()) page._opener.emit(_events.Events.Page.Popup, page);
|
||||
}
|
||||
_onRequest(request, page) {
|
||||
this.emit(_events.Events.BrowserContext.Request, request);
|
||||
if (page) page.emit(_events.Events.Page.Request, request);
|
||||
}
|
||||
_onResponse(response, page) {
|
||||
this.emit(_events.Events.BrowserContext.Response, response);
|
||||
if (page) page.emit(_events.Events.Page.Response, response);
|
||||
}
|
||||
_onRequestFailed(request, responseEndTiming, failureText, page) {
|
||||
request._failureText = failureText || null;
|
||||
request._setResponseEndTiming(responseEndTiming);
|
||||
this.emit(_events.Events.BrowserContext.RequestFailed, request);
|
||||
if (page) page.emit(_events.Events.Page.RequestFailed, request);
|
||||
}
|
||||
_onRequestFinished(params) {
|
||||
const {
|
||||
responseEndTiming
|
||||
} = params;
|
||||
const request = network.Request.from(params.request);
|
||||
const response = network.Response.fromNullable(params.response);
|
||||
const page = _page.Page.fromNullable(params.page);
|
||||
request._setResponseEndTiming(responseEndTiming);
|
||||
this.emit(_events.Events.BrowserContext.RequestFinished, request);
|
||||
if (page) page.emit(_events.Events.Page.RequestFinished, request);
|
||||
if (response) response._finishedPromise.resolve(null);
|
||||
}
|
||||
async _onRoute(route) {
|
||||
const routeHandlers = this._routes.slice();
|
||||
for (const routeHandler of routeHandlers) {
|
||||
if (!routeHandler.matches(route.request().url())) continue;
|
||||
if (routeHandler.willExpire()) this._routes.splice(this._routes.indexOf(routeHandler), 1);
|
||||
const handled = await routeHandler.handle(route);
|
||||
if (!this._routes.length) this._wrapApiCall(() => this._updateInterceptionPatterns(), true).catch(() => {});
|
||||
if (handled) return;
|
||||
}
|
||||
await route._innerContinue(true);
|
||||
}
|
||||
async _onBinding(bindingCall) {
|
||||
const func = this._bindings.get(bindingCall._initializer.name);
|
||||
if (!func) return;
|
||||
await bindingCall.call(func);
|
||||
}
|
||||
setDefaultNavigationTimeout(timeout) {
|
||||
this._timeoutSettings.setDefaultNavigationTimeout(timeout);
|
||||
this._wrapApiCall(async () => {
|
||||
this._channel.setDefaultNavigationTimeoutNoReply({
|
||||
timeout
|
||||
}).catch(() => {});
|
||||
}, true);
|
||||
}
|
||||
setDefaultTimeout(timeout) {
|
||||
this._timeoutSettings.setDefaultTimeout(timeout);
|
||||
this._wrapApiCall(async () => {
|
||||
this._channel.setDefaultTimeoutNoReply({
|
||||
timeout
|
||||
}).catch(() => {});
|
||||
}, true);
|
||||
}
|
||||
browser() {
|
||||
return this._browser;
|
||||
}
|
||||
pages() {
|
||||
return [...this._pages];
|
||||
}
|
||||
async newPage() {
|
||||
if (this._ownerPage) throw new Error('Please use browser.newContext()');
|
||||
return _page.Page.from((await this._channel.newPage()).page);
|
||||
}
|
||||
async cookies(urls) {
|
||||
if (!urls) urls = [];
|
||||
if (urls && typeof urls === 'string') urls = [urls];
|
||||
return (await this._channel.cookies({
|
||||
urls: urls
|
||||
})).cookies;
|
||||
}
|
||||
async addCookies(cookies) {
|
||||
await this._channel.addCookies({
|
||||
cookies
|
||||
});
|
||||
}
|
||||
async clearCookies() {
|
||||
await this._channel.clearCookies();
|
||||
}
|
||||
async grantPermissions(permissions, options) {
|
||||
await this._channel.grantPermissions({
|
||||
permissions,
|
||||
...options
|
||||
});
|
||||
}
|
||||
async clearPermissions() {
|
||||
await this._channel.clearPermissions();
|
||||
}
|
||||
async setGeolocation(geolocation) {
|
||||
await this._channel.setGeolocation({
|
||||
geolocation: geolocation || undefined
|
||||
});
|
||||
}
|
||||
async setExtraHTTPHeaders(headers) {
|
||||
network.validateHeaders(headers);
|
||||
await this._channel.setExtraHTTPHeaders({
|
||||
headers: (0, _utils.headersObjectToArray)(headers)
|
||||
});
|
||||
}
|
||||
async setOffline(offline) {
|
||||
await this._channel.setOffline({
|
||||
offline
|
||||
});
|
||||
}
|
||||
async setHTTPCredentials(httpCredentials) {
|
||||
await this._channel.setHTTPCredentials({
|
||||
httpCredentials: httpCredentials || undefined
|
||||
});
|
||||
}
|
||||
async addInitScript(script, arg) {
|
||||
const source = await (0, _clientHelper.evaluationScript)(script, arg);
|
||||
await this._channel.addInitScript({
|
||||
source
|
||||
});
|
||||
}
|
||||
async exposeBinding(name, callback, options = {}) {
|
||||
await this._channel.exposeBinding({
|
||||
name,
|
||||
needsHandle: options.handle
|
||||
});
|
||||
this._bindings.set(name, callback);
|
||||
}
|
||||
async exposeFunction(name, callback) {
|
||||
await this._channel.exposeBinding({
|
||||
name
|
||||
});
|
||||
const binding = (source, ...args) => callback(...args);
|
||||
this._bindings.set(name, binding);
|
||||
}
|
||||
async route(url, handler, options = {}) {
|
||||
this._routes.unshift(new network.RouteHandler(this._options.baseURL, url, handler, options.times));
|
||||
await this._updateInterceptionPatterns();
|
||||
}
|
||||
async _recordIntoHAR(har, page, options = {}) {
|
||||
var _options$updateConten, _options$updateMode, _options$updateConten2;
|
||||
const {
|
||||
harId
|
||||
} = await this._channel.harStart({
|
||||
page: page === null || page === void 0 ? void 0 : page._channel,
|
||||
options: prepareRecordHarOptions({
|
||||
path: har,
|
||||
content: (_options$updateConten = options.updateContent) !== null && _options$updateConten !== void 0 ? _options$updateConten : 'attach',
|
||||
mode: (_options$updateMode = options.updateMode) !== null && _options$updateMode !== void 0 ? _options$updateMode : 'minimal',
|
||||
urlFilter: options.url
|
||||
})
|
||||
});
|
||||
this._harRecorders.set(harId, {
|
||||
path: har,
|
||||
content: (_options$updateConten2 = options.updateContent) !== null && _options$updateConten2 !== void 0 ? _options$updateConten2 : 'attach'
|
||||
});
|
||||
}
|
||||
async routeFromHAR(har, options = {}) {
|
||||
if (options.update) {
|
||||
await this._recordIntoHAR(har, null, options);
|
||||
return;
|
||||
}
|
||||
const harRouter = await _harRouter.HarRouter.create(this._connection.localUtils(), har, options.notFound || 'abort', {
|
||||
urlMatch: options.url
|
||||
});
|
||||
harRouter.addContextRoute(this);
|
||||
}
|
||||
async unroute(url, handler) {
|
||||
this._routes = this._routes.filter(route => !(0, _utils.urlMatchesEqual)(route.url, url) || handler && route.handler !== handler);
|
||||
await this._updateInterceptionPatterns();
|
||||
}
|
||||
async _updateInterceptionPatterns() {
|
||||
const patterns = network.RouteHandler.prepareInterceptionPatterns(this._routes);
|
||||
await this._channel.setNetworkInterceptionPatterns({
|
||||
patterns
|
||||
});
|
||||
}
|
||||
async waitForEvent(event, optionsOrPredicate = {}) {
|
||||
return this._wrapApiCall(async () => {
|
||||
const timeout = this._timeoutSettings.timeout(typeof optionsOrPredicate === 'function' ? {} : optionsOrPredicate);
|
||||
const predicate = typeof optionsOrPredicate === 'function' ? optionsOrPredicate : optionsOrPredicate.predicate;
|
||||
const waiter = _waiter.Waiter.createForEvent(this, event);
|
||||
waiter.rejectOnTimeout(timeout, `Timeout ${timeout}ms exceeded while waiting for event "${event}"`);
|
||||
if (event !== _events.Events.BrowserContext.Close) waiter.rejectOnEvent(this, _events.Events.BrowserContext.Close, new Error('Context closed'));
|
||||
const result = await waiter.waitForEvent(this, event, predicate);
|
||||
waiter.dispose();
|
||||
return result;
|
||||
});
|
||||
}
|
||||
async storageState(options = {}) {
|
||||
const state = await this._channel.storageState();
|
||||
if (options.path) {
|
||||
await (0, _fileUtils.mkdirIfNeeded)(options.path);
|
||||
await _fs.default.promises.writeFile(options.path, JSON.stringify(state, undefined, 2), 'utf8');
|
||||
}
|
||||
return state;
|
||||
}
|
||||
backgroundPages() {
|
||||
return [...this._backgroundPages];
|
||||
}
|
||||
serviceWorkers() {
|
||||
return [...this._serviceWorkers];
|
||||
}
|
||||
async newCDPSession(page) {
|
||||
// channelOwner.ts's validation messages don't handle the pseudo-union type, so we're explicit here
|
||||
if (!(page instanceof _page.Page) && !(page instanceof _frame.Frame)) throw new Error('page: expected Page or Frame');
|
||||
const result = await this._channel.newCDPSession(page instanceof _page.Page ? {
|
||||
page: page._channel
|
||||
} : {
|
||||
frame: page._channel
|
||||
});
|
||||
return _cdpSession.CDPSession.from(result.session);
|
||||
}
|
||||
_onClose() {
|
||||
var _this$_browserType, _this$_browserType$_c;
|
||||
if (this._browser) this._browser._contexts.delete(this);
|
||||
(_this$_browserType = this._browserType) === null || _this$_browserType === void 0 ? void 0 : (_this$_browserType$_c = _this$_browserType._contexts) === null || _this$_browserType$_c === void 0 ? void 0 : _this$_browserType$_c.delete(this);
|
||||
this.emit(_events.Events.BrowserContext.Close, this);
|
||||
}
|
||||
async close() {
|
||||
if (this._closeWasCalled) return;
|
||||
this._closeWasCalled = true;
|
||||
await this._wrapApiCall(async () => {
|
||||
var _this$_browserType2;
|
||||
await ((_this$_browserType2 = this._browserType) === null || _this$_browserType2 === void 0 ? void 0 : _this$_browserType2._willCloseContext(this));
|
||||
for (const [harId, harParams] of this._harRecorders) {
|
||||
const har = await this._channel.harExport({
|
||||
harId
|
||||
});
|
||||
const artifact = _artifact.Artifact.from(har.artifact);
|
||||
// Server side will compress artifact if content is attach or if file is .zip.
|
||||
const isCompressed = harParams.content === 'attach' || harParams.path.endsWith('.zip');
|
||||
const needCompressed = harParams.path.endsWith('.zip');
|
||||
if (isCompressed && !needCompressed) {
|
||||
await artifact.saveAs(harParams.path + '.tmp');
|
||||
await this._connection.localUtils()._channel.harUnzip({
|
||||
zipFile: harParams.path + '.tmp',
|
||||
harFile: harParams.path
|
||||
});
|
||||
} else {
|
||||
await artifact.saveAs(harParams.path);
|
||||
}
|
||||
await artifact.delete();
|
||||
}
|
||||
}, true);
|
||||
await this._channel.close();
|
||||
await this._closedPromise;
|
||||
}
|
||||
async _enableRecorder(params) {
|
||||
await this._channel.recorderSupplementEnable(params);
|
||||
}
|
||||
}
|
||||
exports.BrowserContext = BrowserContext;
|
||||
async function prepareStorageState(options) {
|
||||
if (typeof options.storageState !== 'string') return options.storageState;
|
||||
try {
|
||||
return JSON.parse(await _fs.default.promises.readFile(options.storageState, 'utf8'));
|
||||
} catch (e) {
|
||||
(0, _stackTrace.rewriteErrorMessage)(e, `Error reading storage state from ${options.storageState}:\n` + e.message);
|
||||
throw e;
|
||||
}
|
||||
}
|
||||
function prepareRecordHarOptions(options) {
|
||||
if (!options) return;
|
||||
return {
|
||||
path: options.path,
|
||||
content: options.content || (options.omitContent ? 'omit' : undefined),
|
||||
urlGlob: (0, _utils.isString)(options.urlFilter) ? options.urlFilter : undefined,
|
||||
urlRegexSource: (0, _utils.isRegExp)(options.urlFilter) ? options.urlFilter.source : undefined,
|
||||
urlRegexFlags: (0, _utils.isRegExp)(options.urlFilter) ? options.urlFilter.flags : undefined,
|
||||
mode: options.mode
|
||||
};
|
||||
}
|
||||
async function prepareBrowserContextParams(options) {
|
||||
if (options.videoSize && !options.videosPath) throw new Error(`"videoSize" option requires "videosPath" to be specified`);
|
||||
if (options.extraHTTPHeaders) network.validateHeaders(options.extraHTTPHeaders);
|
||||
const contextParams = {
|
||||
...options,
|
||||
viewport: options.viewport === null ? undefined : options.viewport,
|
||||
noDefaultViewport: options.viewport === null,
|
||||
extraHTTPHeaders: options.extraHTTPHeaders ? (0, _utils.headersObjectToArray)(options.extraHTTPHeaders) : undefined,
|
||||
storageState: await prepareStorageState(options),
|
||||
serviceWorkers: options.serviceWorkers,
|
||||
recordHar: prepareRecordHarOptions(options.recordHar),
|
||||
colorScheme: options.colorScheme === null ? 'no-override' : options.colorScheme,
|
||||
reducedMotion: options.reducedMotion === null ? 'no-override' : options.reducedMotion,
|
||||
forcedColors: options.forcedColors === null ? 'no-override' : options.forcedColors
|
||||
};
|
||||
if (!contextParams.recordVideo && options.videosPath) {
|
||||
contextParams.recordVideo = {
|
||||
dir: options.videosPath,
|
||||
size: options.videoSize
|
||||
};
|
||||
}
|
||||
return contextParams;
|
||||
}
|
||||
252
bin/pac/tools/.playwright/package/lib/client/browserType.js
Normal file
252
bin/pac/tools/.playwright/package/lib/client/browserType.js
Normal file
@@ -0,0 +1,252 @@
|
||||
"use strict";
|
||||
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
exports.BrowserType = void 0;
|
||||
var _browser3 = require("./browser");
|
||||
var _browserContext = require("./browserContext");
|
||||
var _channelOwner = require("./channelOwner");
|
||||
var _connection = require("./connection");
|
||||
var _events = require("./events");
|
||||
var _clientHelper = require("./clientHelper");
|
||||
var _utils = require("../utils");
|
||||
var _errors = require("../common/errors");
|
||||
var _timeoutRunner = require("../utils/timeoutRunner");
|
||||
/**
|
||||
* Copyright (c) Microsoft Corporation.
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
// This is here just for api generation and checking.
|
||||
|
||||
class BrowserType extends _channelOwner.ChannelOwner {
|
||||
constructor(...args) {
|
||||
super(...args);
|
||||
this._serverLauncher = void 0;
|
||||
this._contexts = new Set();
|
||||
this._playwright = void 0;
|
||||
// Instrumentation.
|
||||
this._defaultContextOptions = void 0;
|
||||
this._defaultContextTimeout = void 0;
|
||||
this._defaultContextNavigationTimeout = void 0;
|
||||
this._defaultLaunchOptions = void 0;
|
||||
this._defaultConnectOptions = void 0;
|
||||
}
|
||||
static from(browserType) {
|
||||
return browserType._object;
|
||||
}
|
||||
executablePath() {
|
||||
if (!this._initializer.executablePath) throw new Error('Browser is not supported on current platform');
|
||||
return this._initializer.executablePath;
|
||||
}
|
||||
name() {
|
||||
return this._initializer.name;
|
||||
}
|
||||
async launch(options = {}) {
|
||||
var _this$_defaultLaunchO;
|
||||
(0, _utils.assert)(!options.userDataDir, 'userDataDir option is not supported in `browserType.launch`. Use `browserType.launchPersistentContext` instead');
|
||||
(0, _utils.assert)(!options.port, 'Cannot specify a port without launching as a server.');
|
||||
if (this._defaultConnectOptions) return await this._connectInsteadOfLaunching(this._defaultConnectOptions, options);
|
||||
const logger = options.logger || ((_this$_defaultLaunchO = this._defaultLaunchOptions) === null || _this$_defaultLaunchO === void 0 ? void 0 : _this$_defaultLaunchO.logger);
|
||||
options = {
|
||||
...this._defaultLaunchOptions,
|
||||
...options
|
||||
};
|
||||
const launchOptions = {
|
||||
...options,
|
||||
ignoreDefaultArgs: Array.isArray(options.ignoreDefaultArgs) ? options.ignoreDefaultArgs : undefined,
|
||||
ignoreAllDefaultArgs: !!options.ignoreDefaultArgs && !Array.isArray(options.ignoreDefaultArgs),
|
||||
env: options.env ? (0, _clientHelper.envObjectToArray)(options.env) : undefined
|
||||
};
|
||||
return await this._wrapApiCall(async () => {
|
||||
const browser = _browser3.Browser.from((await this._channel.launch(launchOptions)).browser);
|
||||
this._didLaunchBrowser(browser, options, logger);
|
||||
return browser;
|
||||
});
|
||||
}
|
||||
async _connectInsteadOfLaunching(connectOptions, launchOptions) {
|
||||
var _connectOptions$timeo;
|
||||
return this._connect({
|
||||
wsEndpoint: connectOptions.wsEndpoint,
|
||||
headers: {
|
||||
'x-playwright-launch-options': JSON.stringify({
|
||||
...this._defaultLaunchOptions,
|
||||
...launchOptions
|
||||
}),
|
||||
...connectOptions.headers
|
||||
},
|
||||
_exposeNetwork: connectOptions._exposeNetwork,
|
||||
slowMo: connectOptions.slowMo,
|
||||
timeout: (_connectOptions$timeo = connectOptions.timeout) !== null && _connectOptions$timeo !== void 0 ? _connectOptions$timeo : 3 * 60 * 1000 // 3 minutes
|
||||
});
|
||||
}
|
||||
|
||||
async launchServer(options = {}) {
|
||||
if (!this._serverLauncher) throw new Error('Launching server is not supported');
|
||||
options = {
|
||||
...this._defaultLaunchOptions,
|
||||
...options
|
||||
};
|
||||
return this._serverLauncher.launchServer(options);
|
||||
}
|
||||
async launchPersistentContext(userDataDir, options = {}) {
|
||||
var _this$_defaultLaunchO2;
|
||||
const logger = options.logger || ((_this$_defaultLaunchO2 = this._defaultLaunchOptions) === null || _this$_defaultLaunchO2 === void 0 ? void 0 : _this$_defaultLaunchO2.logger);
|
||||
(0, _utils.assert)(!options.port, 'Cannot specify a port without launching as a server.');
|
||||
options = {
|
||||
...this._defaultLaunchOptions,
|
||||
...this._defaultContextOptions,
|
||||
...options
|
||||
};
|
||||
const contextParams = await (0, _browserContext.prepareBrowserContextParams)(options);
|
||||
const persistentParams = {
|
||||
...contextParams,
|
||||
ignoreDefaultArgs: Array.isArray(options.ignoreDefaultArgs) ? options.ignoreDefaultArgs : undefined,
|
||||
ignoreAllDefaultArgs: !!options.ignoreDefaultArgs && !Array.isArray(options.ignoreDefaultArgs),
|
||||
env: options.env ? (0, _clientHelper.envObjectToArray)(options.env) : undefined,
|
||||
channel: options.channel,
|
||||
userDataDir
|
||||
};
|
||||
return await this._wrapApiCall(async () => {
|
||||
const result = await this._channel.launchPersistentContext(persistentParams);
|
||||
const context = _browserContext.BrowserContext.from(result.context);
|
||||
await this._didCreateContext(context, contextParams, options, logger);
|
||||
return context;
|
||||
});
|
||||
}
|
||||
async connect(optionsOrWsEndpoint, options) {
|
||||
if (typeof optionsOrWsEndpoint === 'string') return this._connect({
|
||||
...options,
|
||||
wsEndpoint: optionsOrWsEndpoint
|
||||
});
|
||||
(0, _utils.assert)(optionsOrWsEndpoint.wsEndpoint, 'options.wsEndpoint is required');
|
||||
return this._connect(optionsOrWsEndpoint);
|
||||
}
|
||||
async _connect(params) {
|
||||
const logger = params.logger;
|
||||
return await this._wrapApiCall(async () => {
|
||||
const deadline = params.timeout ? (0, _utils.monotonicTime)() + params.timeout : 0;
|
||||
const headers = {
|
||||
'x-playwright-browser': this.name(),
|
||||
...params.headers
|
||||
};
|
||||
const localUtils = this._connection.localUtils();
|
||||
const connectParams = {
|
||||
wsEndpoint: params.wsEndpoint,
|
||||
headers,
|
||||
exposeNetwork: params._exposeNetwork,
|
||||
slowMo: params.slowMo,
|
||||
timeout: params.timeout
|
||||
};
|
||||
if (params.__testHookRedirectPortForwarding) connectParams.socksProxyRedirectPortForTest = params.__testHookRedirectPortForwarding;
|
||||
const {
|
||||
pipe,
|
||||
headers: connectHeaders
|
||||
} = await localUtils._channel.connect(connectParams);
|
||||
const closePipe = () => pipe.close().catch(() => {});
|
||||
const connection = new _connection.Connection(localUtils, this._instrumentation);
|
||||
connection.markAsRemote();
|
||||
connection.on('close', closePipe);
|
||||
let browser;
|
||||
let closeError;
|
||||
const onPipeClosed = () => {
|
||||
var _browser2;
|
||||
// Emulate all pages, contexts and the browser closing upon disconnect.
|
||||
for (const context of ((_browser = browser) === null || _browser === void 0 ? void 0 : _browser.contexts()) || []) {
|
||||
var _browser;
|
||||
for (const page of context.pages()) page._onClose();
|
||||
context._onClose();
|
||||
}
|
||||
(_browser2 = browser) === null || _browser2 === void 0 ? void 0 : _browser2._didClose();
|
||||
connection.close(closeError || _errors.kBrowserClosedError);
|
||||
};
|
||||
pipe.on('closed', onPipeClosed);
|
||||
connection.onmessage = message => pipe.send({
|
||||
message
|
||||
}).catch(onPipeClosed);
|
||||
pipe.on('message', ({
|
||||
message
|
||||
}) => {
|
||||
try {
|
||||
connection.dispatch(message);
|
||||
} catch (e) {
|
||||
closeError = e.toString();
|
||||
closePipe();
|
||||
}
|
||||
});
|
||||
const result = await (0, _timeoutRunner.raceAgainstTimeout)(async () => {
|
||||
// For tests.
|
||||
if (params.__testHookBeforeCreateBrowser) await params.__testHookBeforeCreateBrowser();
|
||||
const playwright = await connection.initializePlaywright();
|
||||
if (!playwright._initializer.preLaunchedBrowser) {
|
||||
closePipe();
|
||||
throw new Error('Malformed endpoint. Did you use BrowserType.launchServer method?');
|
||||
}
|
||||
playwright._setSelectors(this._playwright.selectors);
|
||||
browser = _browser3.Browser.from(playwright._initializer.preLaunchedBrowser);
|
||||
this._didLaunchBrowser(browser, {}, logger);
|
||||
browser._shouldCloseConnectionOnClose = true;
|
||||
browser._connectHeaders = connectHeaders;
|
||||
browser.on(_events.Events.Browser.Disconnected, closePipe);
|
||||
return browser;
|
||||
}, deadline ? deadline - (0, _utils.monotonicTime)() : 0);
|
||||
if (!result.timedOut) {
|
||||
return result.result;
|
||||
} else {
|
||||
closePipe();
|
||||
throw new Error(`Timeout ${params.timeout}ms exceeded`);
|
||||
}
|
||||
});
|
||||
}
|
||||
connectOverCDP(endpointURLOrOptions, options) {
|
||||
if (typeof endpointURLOrOptions === 'string') return this._connectOverCDP(endpointURLOrOptions, options);
|
||||
const endpointURL = 'endpointURL' in endpointURLOrOptions ? endpointURLOrOptions.endpointURL : endpointURLOrOptions.wsEndpoint;
|
||||
(0, _utils.assert)(endpointURL, 'Cannot connect over CDP without wsEndpoint.');
|
||||
return this.connectOverCDP(endpointURL, endpointURLOrOptions);
|
||||
}
|
||||
async _connectOverCDP(endpointURL, params = {}) {
|
||||
if (this.name() !== 'chromium') throw new Error('Connecting over CDP is only supported in Chromium.');
|
||||
const headers = params.headers ? (0, _utils.headersObjectToArray)(params.headers) : undefined;
|
||||
const result = await this._channel.connectOverCDP({
|
||||
endpointURL,
|
||||
headers,
|
||||
slowMo: params.slowMo,
|
||||
timeout: params.timeout
|
||||
});
|
||||
const browser = _browser3.Browser.from(result.browser);
|
||||
this._didLaunchBrowser(browser, {}, params.logger);
|
||||
if (result.defaultContext) await this._didCreateContext(_browserContext.BrowserContext.from(result.defaultContext), {}, {}, undefined);
|
||||
return browser;
|
||||
}
|
||||
_didLaunchBrowser(browser, browserOptions, logger) {
|
||||
browser._browserType = this;
|
||||
browser._options = browserOptions;
|
||||
browser._logger = logger;
|
||||
}
|
||||
async _didCreateContext(context, contextOptions, browserOptions, logger) {
|
||||
context._logger = logger;
|
||||
context._browserType = this;
|
||||
this._contexts.add(context);
|
||||
context._setOptions(contextOptions, browserOptions);
|
||||
if (this._defaultContextTimeout !== undefined) context.setDefaultTimeout(this._defaultContextTimeout);
|
||||
if (this._defaultContextNavigationTimeout !== undefined) context.setDefaultNavigationTimeout(this._defaultContextNavigationTimeout);
|
||||
await this._instrumentation.onDidCreateBrowserContext(context);
|
||||
}
|
||||
async _willCloseContext(context) {
|
||||
this._contexts.delete(context);
|
||||
await this._instrumentation.onWillCloseBrowserContext(context);
|
||||
}
|
||||
}
|
||||
exports.BrowserType = BrowserType;
|
||||
53
bin/pac/tools/.playwright/package/lib/client/cdpSession.js
Normal file
53
bin/pac/tools/.playwright/package/lib/client/cdpSession.js
Normal file
@@ -0,0 +1,53 @@
|
||||
"use strict";
|
||||
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
exports.CDPSession = void 0;
|
||||
var _channelOwner = require("./channelOwner");
|
||||
/**
|
||||
* Copyright (c) Microsoft Corporation.
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
class CDPSession extends _channelOwner.ChannelOwner {
|
||||
static from(cdpSession) {
|
||||
return cdpSession._object;
|
||||
}
|
||||
constructor(parent, type, guid, initializer) {
|
||||
super(parent, type, guid, initializer);
|
||||
this._channel.on('event', ({
|
||||
method,
|
||||
params
|
||||
}) => {
|
||||
this.emit(method, params);
|
||||
});
|
||||
this.on = super.on;
|
||||
this.addListener = super.addListener;
|
||||
this.off = super.removeListener;
|
||||
this.removeListener = super.removeListener;
|
||||
this.once = super.once;
|
||||
}
|
||||
async send(method, params) {
|
||||
const result = await this._channel.send({
|
||||
method,
|
||||
params
|
||||
});
|
||||
return result.result;
|
||||
}
|
||||
async detach() {
|
||||
return this._channel.detach();
|
||||
}
|
||||
}
|
||||
exports.CDPSession = CDPSession;
|
||||
223
bin/pac/tools/.playwright/package/lib/client/channelOwner.js
Normal file
223
bin/pac/tools/.playwright/package/lib/client/channelOwner.js
Normal file
@@ -0,0 +1,223 @@
|
||||
"use strict";
|
||||
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
exports.ChannelOwner = void 0;
|
||||
var _events = require("events");
|
||||
var _validator = require("../protocol/validator");
|
||||
var _debugLogger = require("../common/debugLogger");
|
||||
var _stackTrace = require("../utils/stackTrace");
|
||||
var _utils = require("../utils");
|
||||
var _zones = require("../utils/zones");
|
||||
/**
|
||||
* Copyright (c) Microsoft Corporation.
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
class ChannelOwner extends _events.EventEmitter {
|
||||
constructor(parent, type, guid, initializer) {
|
||||
super();
|
||||
this._connection = void 0;
|
||||
this._parent = void 0;
|
||||
this._objects = new Map();
|
||||
this._type = void 0;
|
||||
this._guid = void 0;
|
||||
this._channel = void 0;
|
||||
this._initializer = void 0;
|
||||
this._logger = void 0;
|
||||
this._instrumentation = void 0;
|
||||
this._eventToSubscriptionMapping = new Map();
|
||||
this.setMaxListeners(0);
|
||||
this._connection = parent instanceof ChannelOwner ? parent._connection : parent;
|
||||
this._type = type;
|
||||
this._guid = guid;
|
||||
this._parent = parent instanceof ChannelOwner ? parent : undefined;
|
||||
this._instrumentation = this._connection._instrumentation;
|
||||
this._connection._objects.set(guid, this);
|
||||
if (this._parent) {
|
||||
this._parent._objects.set(guid, this);
|
||||
this._logger = this._parent._logger;
|
||||
}
|
||||
this._channel = this._createChannel(new _events.EventEmitter());
|
||||
this._initializer = initializer;
|
||||
}
|
||||
_setEventToSubscriptionMapping(mapping) {
|
||||
this._eventToSubscriptionMapping = mapping;
|
||||
}
|
||||
_updateSubscription(event, enabled) {
|
||||
const protocolEvent = this._eventToSubscriptionMapping.get(String(event));
|
||||
if (protocolEvent) {
|
||||
this._wrapApiCall(async () => {
|
||||
await this._channel.updateSubscription({
|
||||
event: protocolEvent,
|
||||
enabled
|
||||
});
|
||||
}, true).catch(() => {});
|
||||
}
|
||||
}
|
||||
on(event, listener) {
|
||||
if (!this.listenerCount(event)) this._updateSubscription(event, true);
|
||||
super.on(event, listener);
|
||||
return this;
|
||||
}
|
||||
addListener(event, listener) {
|
||||
if (!this.listenerCount(event)) this._updateSubscription(event, true);
|
||||
super.addListener(event, listener);
|
||||
return this;
|
||||
}
|
||||
prependListener(event, listener) {
|
||||
if (!this.listenerCount(event)) this._updateSubscription(event, true);
|
||||
super.prependListener(event, listener);
|
||||
return this;
|
||||
}
|
||||
off(event, listener) {
|
||||
super.off(event, listener);
|
||||
if (!this.listenerCount(event)) this._updateSubscription(event, false);
|
||||
return this;
|
||||
}
|
||||
removeListener(event, listener) {
|
||||
super.removeListener(event, listener);
|
||||
if (!this.listenerCount(event)) this._updateSubscription(event, false);
|
||||
return this;
|
||||
}
|
||||
_adopt(child) {
|
||||
child._parent._objects.delete(child._guid);
|
||||
this._objects.set(child._guid, child);
|
||||
child._parent = this;
|
||||
}
|
||||
_dispose() {
|
||||
// Clean up from parent and connection.
|
||||
if (this._parent) this._parent._objects.delete(this._guid);
|
||||
this._connection._objects.delete(this._guid);
|
||||
|
||||
// Dispose all children.
|
||||
for (const object of [...this._objects.values()]) object._dispose();
|
||||
this._objects.clear();
|
||||
}
|
||||
_debugScopeState() {
|
||||
return {
|
||||
_guid: this._guid,
|
||||
objects: Array.from(this._objects.values()).map(o => o._debugScopeState())
|
||||
};
|
||||
}
|
||||
_createChannel(base) {
|
||||
const channel = new Proxy(base, {
|
||||
get: (obj, prop) => {
|
||||
if (typeof prop === 'string') {
|
||||
const validator = (0, _validator.maybeFindValidator)(this._type, prop, 'Params');
|
||||
if (validator) {
|
||||
return params => {
|
||||
return this._wrapApiCall(apiZone => {
|
||||
const {
|
||||
stackTrace,
|
||||
csi,
|
||||
callCookie,
|
||||
wallTime
|
||||
} = apiZone.reported ? {
|
||||
csi: undefined,
|
||||
callCookie: undefined,
|
||||
stackTrace: null,
|
||||
wallTime: undefined
|
||||
} : apiZone;
|
||||
apiZone.reported = true;
|
||||
if (csi && stackTrace && stackTrace.apiName) csi.onApiCallBegin(stackTrace.apiName, params, stackTrace, wallTime, callCookie);
|
||||
return this._connection.sendMessageToServer(this, this._type, prop, validator(params, '', {
|
||||
tChannelImpl: tChannelImplToWire,
|
||||
binary: this._connection.isRemote() ? 'toBase64' : 'buffer'
|
||||
}), stackTrace, wallTime);
|
||||
});
|
||||
};
|
||||
}
|
||||
}
|
||||
return obj[prop];
|
||||
}
|
||||
});
|
||||
channel._object = this;
|
||||
return channel;
|
||||
}
|
||||
async _wrapApiCall(func, isInternal = false) {
|
||||
const logger = this._logger;
|
||||
const stack = (0, _stackTrace.captureRawStack)();
|
||||
const apiZone = _zones.zones.zoneData('apiZone', stack);
|
||||
if (apiZone) return func(apiZone);
|
||||
const stackTrace = (0, _stackTrace.captureLibraryStackTrace)(stack);
|
||||
isInternal = isInternal || this._type === 'LocalUtils';
|
||||
if (isInternal) delete stackTrace.apiName;
|
||||
|
||||
// Enclosing zone could have provided the apiName and wallTime.
|
||||
const expectZone = _zones.zones.zoneData('expectZone', stack);
|
||||
const wallTime = expectZone ? expectZone.wallTime : Date.now();
|
||||
if (!isInternal && expectZone) stackTrace.apiName = expectZone.title;
|
||||
const csi = isInternal ? undefined : this._instrumentation;
|
||||
const callCookie = {};
|
||||
const {
|
||||
apiName,
|
||||
frameTexts
|
||||
} = stackTrace;
|
||||
try {
|
||||
logApiCall(logger, `=> ${apiName} started`, isInternal);
|
||||
const apiZone = {
|
||||
stackTrace,
|
||||
isInternal,
|
||||
reported: false,
|
||||
csi,
|
||||
callCookie,
|
||||
wallTime
|
||||
};
|
||||
const result = await _zones.zones.run('apiZone', apiZone, async () => {
|
||||
return await func(apiZone);
|
||||
});
|
||||
csi === null || csi === void 0 ? void 0 : csi.onApiCallEnd(callCookie);
|
||||
logApiCall(logger, `<= ${apiName} succeeded`, isInternal);
|
||||
return result;
|
||||
} catch (e) {
|
||||
const innerError = (process.env.PWDEBUGIMPL || (0, _utils.isUnderTest)()) && e.stack ? '\n<inner error>\n' + e.stack : '';
|
||||
if (apiName && !apiName.includes('<anonymous>')) e.message = apiName + ': ' + e.message;
|
||||
const stackFrames = '\n' + frameTexts.join('\n') + innerError;
|
||||
if (stackFrames.trim()) e.stack = e.message + stackFrames;else e.stack = '';
|
||||
csi === null || csi === void 0 ? void 0 : csi.onApiCallEnd(callCookie, e);
|
||||
logApiCall(logger, `<= ${apiName} failed`, isInternal);
|
||||
throw e;
|
||||
}
|
||||
}
|
||||
_toImpl() {
|
||||
var _this$_connection$toI, _this$_connection;
|
||||
return (_this$_connection$toI = (_this$_connection = this._connection).toImpl) === null || _this$_connection$toI === void 0 ? void 0 : _this$_connection$toI.call(_this$_connection, this);
|
||||
}
|
||||
toJSON() {
|
||||
// Jest's expect library tries to print objects sometimes.
|
||||
// RPC objects can contain links to lots of other objects,
|
||||
// which can cause jest to crash. Let's help it out
|
||||
// by just returning the important values.
|
||||
return {
|
||||
_type: this._type,
|
||||
_guid: this._guid
|
||||
};
|
||||
}
|
||||
}
|
||||
exports.ChannelOwner = ChannelOwner;
|
||||
function logApiCall(logger, message, isNested) {
|
||||
if (isNested) return;
|
||||
if (logger && logger.isEnabled('api', 'info')) logger.log('api', 'info', message, [], {
|
||||
color: 'cyan'
|
||||
});
|
||||
_debugLogger.debugLogger.log('api', message);
|
||||
}
|
||||
function tChannelImplToWire(names, arg, path, context) {
|
||||
if (arg._object instanceof ChannelOwner && (names === '*' || names.includes(arg._object._type))) return {
|
||||
guid: arg._object._guid
|
||||
};
|
||||
throw new _validator.ValidationError(`${path}: expected channel ${names.toString()}`);
|
||||
}
|
||||
53
bin/pac/tools/.playwright/package/lib/client/clientHelper.js
Normal file
53
bin/pac/tools/.playwright/package/lib/client/clientHelper.js
Normal file
@@ -0,0 +1,53 @@
|
||||
"use strict";
|
||||
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
exports.envObjectToArray = envObjectToArray;
|
||||
exports.evaluationScript = evaluationScript;
|
||||
var _fs = _interopRequireDefault(require("fs"));
|
||||
var _utils = require("../utils");
|
||||
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
||||
/**
|
||||
* Copyright 2017 Google Inc. All rights reserved.
|
||||
* Modifications copyright (c) Microsoft Corporation.
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
function envObjectToArray(env) {
|
||||
const result = [];
|
||||
for (const name in env) {
|
||||
if (!Object.is(env[name], undefined)) result.push({
|
||||
name,
|
||||
value: String(env[name])
|
||||
});
|
||||
}
|
||||
return result;
|
||||
}
|
||||
async function evaluationScript(fun, arg, addSourceUrl = true) {
|
||||
if (typeof fun === 'function') {
|
||||
const source = fun.toString();
|
||||
const argString = Object.is(arg, undefined) ? 'undefined' : JSON.stringify(arg);
|
||||
return `(${source})(${argString})`;
|
||||
}
|
||||
if (arg !== undefined) throw new Error('Cannot evaluate a string with arguments');
|
||||
if ((0, _utils.isString)(fun)) return fun;
|
||||
if (fun.content !== undefined) return fun.content;
|
||||
if (fun.path !== undefined) {
|
||||
let source = await _fs.default.promises.readFile(fun.path, 'utf8');
|
||||
if (addSourceUrl) source += '\n//# sourceURL=' + fun.path.replace(/\n/g, '');
|
||||
return source;
|
||||
}
|
||||
throw new Error('Either path or content property must be present');
|
||||
}
|
||||
@@ -0,0 +1,40 @@
|
||||
"use strict";
|
||||
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
exports.createInstrumentation = createInstrumentation;
|
||||
/**
|
||||
* Copyright (c) Microsoft Corporation. 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.
|
||||
*/
|
||||
|
||||
function createInstrumentation() {
|
||||
const listeners = [];
|
||||
return new Proxy({}, {
|
||||
get: (obj, prop) => {
|
||||
if (typeof prop !== 'string') return obj[prop];
|
||||
if (prop === 'addListener') return listener => listeners.push(listener);
|
||||
if (prop === 'removeListener') return listener => listeners.splice(listeners.indexOf(listener), 1);
|
||||
if (prop === 'removeAllListeners') return () => listeners.splice(0, listeners.length);
|
||||
if (!prop.startsWith('on')) return obj[prop];
|
||||
return async (...params) => {
|
||||
for (const listener of listeners) {
|
||||
var _prop, _ref;
|
||||
await ((_prop = (_ref = listener)[prop]) === null || _prop === void 0 ? void 0 : _prop.call(_ref, ...params));
|
||||
}
|
||||
};
|
||||
}
|
||||
});
|
||||
}
|
||||
330
bin/pac/tools/.playwright/package/lib/client/connection.js
Normal file
330
bin/pac/tools/.playwright/package/lib/client/connection.js
Normal file
@@ -0,0 +1,330 @@
|
||||
"use strict";
|
||||
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
exports.Connection = void 0;
|
||||
var _browser = require("./browser");
|
||||
var _browserContext = require("./browserContext");
|
||||
var _browserType = require("./browserType");
|
||||
var _channelOwner = require("./channelOwner");
|
||||
var _elementHandle = require("./elementHandle");
|
||||
var _frame = require("./frame");
|
||||
var _jsHandle = require("./jsHandle");
|
||||
var _network = require("./network");
|
||||
var _page = require("./page");
|
||||
var _worker = require("./worker");
|
||||
var _consoleMessage = require("./consoleMessage");
|
||||
var _dialog = require("./dialog");
|
||||
var _serializers = require("../protocol/serializers");
|
||||
var _cdpSession = require("./cdpSession");
|
||||
var _playwright = require("./playwright");
|
||||
var _electron = require("./electron");
|
||||
var _stream = require("./stream");
|
||||
var _writableStream = require("./writableStream");
|
||||
var _debugLogger = require("../common/debugLogger");
|
||||
var _selectors = require("./selectors");
|
||||
var _android = require("./android");
|
||||
var _stackTrace = require("../utils/stackTrace");
|
||||
var _artifact = require("./artifact");
|
||||
var _events = require("events");
|
||||
var _jsonPipe = require("./jsonPipe");
|
||||
var _fetch = require("./fetch");
|
||||
var _localUtils = require("./localUtils");
|
||||
var _tracing = require("./tracing");
|
||||
var _validator = require("../protocol/validator");
|
||||
var _clientInstrumentation = require("./clientInstrumentation");
|
||||
/**
|
||||
* Copyright (c) Microsoft Corporation.
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
class Root extends _channelOwner.ChannelOwner {
|
||||
constructor(connection) {
|
||||
super(connection, 'Root', '', {});
|
||||
}
|
||||
async initialize() {
|
||||
return _playwright.Playwright.from((await this._channel.initialize({
|
||||
sdkLanguage: 'javascript'
|
||||
})).playwright);
|
||||
}
|
||||
}
|
||||
class DummyChannelOwner extends _channelOwner.ChannelOwner {}
|
||||
class Connection extends _events.EventEmitter {
|
||||
// Some connections allow resolving in-process dispatchers.
|
||||
|
||||
constructor(localUtils, instrumentation) {
|
||||
super();
|
||||
this._objects = new Map();
|
||||
this.onmessage = message => {};
|
||||
this._lastId = 0;
|
||||
this._callbacks = new Map();
|
||||
this._rootObject = void 0;
|
||||
this._closedErrorMessage = void 0;
|
||||
this._isRemote = false;
|
||||
this._localUtils = void 0;
|
||||
this.toImpl = void 0;
|
||||
this._tracingCount = 0;
|
||||
this._instrumentation = void 0;
|
||||
this._rootObject = new Root(this);
|
||||
this._localUtils = localUtils;
|
||||
this._instrumentation = instrumentation || (0, _clientInstrumentation.createInstrumentation)();
|
||||
}
|
||||
markAsRemote() {
|
||||
this._isRemote = true;
|
||||
}
|
||||
isRemote() {
|
||||
return this._isRemote;
|
||||
}
|
||||
localUtils() {
|
||||
return this._localUtils;
|
||||
}
|
||||
async initializePlaywright() {
|
||||
return await this._rootObject.initialize();
|
||||
}
|
||||
pendingProtocolCalls() {
|
||||
return Array.from(this._callbacks.values()).map(callback => callback.stackTrace).filter(Boolean);
|
||||
}
|
||||
getObjectWithKnownName(guid) {
|
||||
return this._objects.get(guid);
|
||||
}
|
||||
async setIsTracing(isTracing) {
|
||||
if (isTracing) this._tracingCount++;else this._tracingCount--;
|
||||
}
|
||||
async sendMessageToServer(object, type, method, params, stackTrace, wallTime) {
|
||||
var _this$_localUtils;
|
||||
if (this._closedErrorMessage) throw new Error(this._closedErrorMessage);
|
||||
const {
|
||||
apiName,
|
||||
frames
|
||||
} = stackTrace || {
|
||||
apiName: '',
|
||||
frames: []
|
||||
};
|
||||
const guid = object._guid;
|
||||
const id = ++this._lastId;
|
||||
const converted = {
|
||||
id,
|
||||
guid,
|
||||
method,
|
||||
params
|
||||
};
|
||||
// Do not include metadata in debug logs to avoid noise.
|
||||
_debugLogger.debugLogger.log('channel:command', converted);
|
||||
const location = frames[0] ? {
|
||||
file: frames[0].file,
|
||||
line: frames[0].line,
|
||||
column: frames[0].column
|
||||
} : undefined;
|
||||
const metadata = {
|
||||
wallTime,
|
||||
apiName,
|
||||
location,
|
||||
internal: !apiName
|
||||
};
|
||||
this.onmessage({
|
||||
...converted,
|
||||
metadata
|
||||
});
|
||||
if (this._tracingCount && frames && type !== 'LocalUtils') (_this$_localUtils = this._localUtils) === null || _this$_localUtils === void 0 ? void 0 : _this$_localUtils._channel.addStackToTracingNoReply({
|
||||
callData: {
|
||||
stack: frames,
|
||||
id
|
||||
}
|
||||
}).catch(() => {});
|
||||
return await new Promise((resolve, reject) => this._callbacks.set(id, {
|
||||
resolve,
|
||||
reject,
|
||||
stackTrace,
|
||||
type,
|
||||
method
|
||||
}));
|
||||
}
|
||||
dispatch(message) {
|
||||
if (this._closedErrorMessage) return;
|
||||
const {
|
||||
id,
|
||||
guid,
|
||||
method,
|
||||
params,
|
||||
result,
|
||||
error
|
||||
} = message;
|
||||
if (id) {
|
||||
_debugLogger.debugLogger.log('channel:response', message);
|
||||
const callback = this._callbacks.get(id);
|
||||
if (!callback) throw new Error(`Cannot find command to respond: ${id}`);
|
||||
this._callbacks.delete(id);
|
||||
if (error && !result) {
|
||||
callback.reject((0, _serializers.parseError)(error));
|
||||
} else {
|
||||
const validator = (0, _validator.findValidator)(callback.type, callback.method, 'Result');
|
||||
callback.resolve(validator(result, '', {
|
||||
tChannelImpl: this._tChannelImplFromWire.bind(this),
|
||||
binary: this.isRemote() ? 'fromBase64' : 'buffer'
|
||||
}));
|
||||
}
|
||||
return;
|
||||
}
|
||||
_debugLogger.debugLogger.log('channel:event', message);
|
||||
if (method === '__create__') {
|
||||
this._createRemoteObject(guid, params.type, params.guid, params.initializer);
|
||||
return;
|
||||
}
|
||||
const object = this._objects.get(guid);
|
||||
if (!object) throw new Error(`Cannot find object to "${method}": ${guid}`);
|
||||
if (method === '__adopt__') {
|
||||
const child = this._objects.get(params.guid);
|
||||
if (!child) throw new Error(`Unknown new child: ${params.guid}`);
|
||||
object._adopt(child);
|
||||
return;
|
||||
}
|
||||
if (method === '__dispose__') {
|
||||
object._dispose();
|
||||
return;
|
||||
}
|
||||
const validator = (0, _validator.findValidator)(object._type, method, 'Event');
|
||||
object._channel.emit(method, validator(params, '', {
|
||||
tChannelImpl: this._tChannelImplFromWire.bind(this),
|
||||
binary: this.isRemote() ? 'fromBase64' : 'buffer'
|
||||
}));
|
||||
}
|
||||
close(errorMessage = 'Connection closed') {
|
||||
const stack = (0, _stackTrace.captureLibraryStackTrace)().frameTexts.join('\n');
|
||||
if (stack) errorMessage += '\n ==== Closed by ====\n' + stack + '\n';
|
||||
this._closedErrorMessage = errorMessage;
|
||||
for (const callback of this._callbacks.values()) callback.reject(new Error(errorMessage));
|
||||
this._callbacks.clear();
|
||||
this.emit('close');
|
||||
}
|
||||
_tChannelImplFromWire(names, arg, path, context) {
|
||||
if (arg && typeof arg === 'object' && typeof arg.guid === 'string') {
|
||||
const object = this._objects.get(arg.guid);
|
||||
if (!object) throw new Error(`Object with guid ${arg.guid} was not bound in the connection`);
|
||||
if (names !== '*' && !names.includes(object._type)) throw new _validator.ValidationError(`${path}: expected channel ${names.toString()}`);
|
||||
return object._channel;
|
||||
}
|
||||
throw new _validator.ValidationError(`${path}: expected channel ${names.toString()}`);
|
||||
}
|
||||
_createRemoteObject(parentGuid, type, guid, initializer) {
|
||||
const parent = this._objects.get(parentGuid);
|
||||
if (!parent) throw new Error(`Cannot find parent object ${parentGuid} to create ${guid}`);
|
||||
let result;
|
||||
const validator = (0, _validator.findValidator)(type, '', 'Initializer');
|
||||
initializer = validator(initializer, '', {
|
||||
tChannelImpl: this._tChannelImplFromWire.bind(this),
|
||||
binary: this.isRemote() ? 'fromBase64' : 'buffer'
|
||||
});
|
||||
switch (type) {
|
||||
case 'Android':
|
||||
result = new _android.Android(parent, type, guid, initializer);
|
||||
break;
|
||||
case 'AndroidSocket':
|
||||
result = new _android.AndroidSocket(parent, type, guid, initializer);
|
||||
break;
|
||||
case 'AndroidDevice':
|
||||
result = new _android.AndroidDevice(parent, type, guid, initializer);
|
||||
break;
|
||||
case 'APIRequestContext':
|
||||
result = new _fetch.APIRequestContext(parent, type, guid, initializer);
|
||||
break;
|
||||
case 'Artifact':
|
||||
result = new _artifact.Artifact(parent, type, guid, initializer);
|
||||
break;
|
||||
case 'BindingCall':
|
||||
result = new _page.BindingCall(parent, type, guid, initializer);
|
||||
break;
|
||||
case 'Browser':
|
||||
result = new _browser.Browser(parent, type, guid, initializer);
|
||||
break;
|
||||
case 'BrowserContext':
|
||||
result = new _browserContext.BrowserContext(parent, type, guid, initializer);
|
||||
break;
|
||||
case 'BrowserType':
|
||||
result = new _browserType.BrowserType(parent, type, guid, initializer);
|
||||
break;
|
||||
case 'CDPSession':
|
||||
result = new _cdpSession.CDPSession(parent, type, guid, initializer);
|
||||
break;
|
||||
case 'ConsoleMessage':
|
||||
result = new _consoleMessage.ConsoleMessage(parent, type, guid, initializer);
|
||||
break;
|
||||
case 'Dialog':
|
||||
result = new _dialog.Dialog(parent, type, guid, initializer);
|
||||
break;
|
||||
case 'Electron':
|
||||
result = new _electron.Electron(parent, type, guid, initializer);
|
||||
break;
|
||||
case 'ElectronApplication':
|
||||
result = new _electron.ElectronApplication(parent, type, guid, initializer);
|
||||
break;
|
||||
case 'ElementHandle':
|
||||
result = new _elementHandle.ElementHandle(parent, type, guid, initializer);
|
||||
break;
|
||||
case 'Frame':
|
||||
result = new _frame.Frame(parent, type, guid, initializer);
|
||||
break;
|
||||
case 'JSHandle':
|
||||
result = new _jsHandle.JSHandle(parent, type, guid, initializer);
|
||||
break;
|
||||
case 'JsonPipe':
|
||||
result = new _jsonPipe.JsonPipe(parent, type, guid, initializer);
|
||||
break;
|
||||
case 'LocalUtils':
|
||||
result = new _localUtils.LocalUtils(parent, type, guid, initializer);
|
||||
if (!this._localUtils) this._localUtils = result;
|
||||
break;
|
||||
case 'Page':
|
||||
result = new _page.Page(parent, type, guid, initializer);
|
||||
break;
|
||||
case 'Playwright':
|
||||
result = new _playwright.Playwright(parent, type, guid, initializer);
|
||||
break;
|
||||
case 'Request':
|
||||
result = new _network.Request(parent, type, guid, initializer);
|
||||
break;
|
||||
case 'Response':
|
||||
result = new _network.Response(parent, type, guid, initializer);
|
||||
break;
|
||||
case 'Route':
|
||||
result = new _network.Route(parent, type, guid, initializer);
|
||||
break;
|
||||
case 'Stream':
|
||||
result = new _stream.Stream(parent, type, guid, initializer);
|
||||
break;
|
||||
case 'Selectors':
|
||||
result = new _selectors.SelectorsOwner(parent, type, guid, initializer);
|
||||
break;
|
||||
case 'SocksSupport':
|
||||
result = new DummyChannelOwner(parent, type, guid, initializer);
|
||||
break;
|
||||
case 'Tracing':
|
||||
result = new _tracing.Tracing(parent, type, guid, initializer);
|
||||
break;
|
||||
case 'WebSocket':
|
||||
result = new _network.WebSocket(parent, type, guid, initializer);
|
||||
break;
|
||||
case 'Worker':
|
||||
result = new _worker.Worker(parent, type, guid, initializer);
|
||||
break;
|
||||
case 'WritableStream':
|
||||
result = new _writableStream.WritableStream(parent, type, guid, initializer);
|
||||
break;
|
||||
default:
|
||||
throw new Error('Missing type ' + type);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
}
|
||||
exports.Connection = Connection;
|
||||
@@ -0,0 +1,61 @@
|
||||
"use strict";
|
||||
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
exports.ConsoleMessage = void 0;
|
||||
var util = _interopRequireWildcard(require("util"));
|
||||
var _jsHandle = require("./jsHandle");
|
||||
var _channelOwner = require("./channelOwner");
|
||||
var _page = require("./page");
|
||||
let _util$inspect$custom;
|
||||
/**
|
||||
* Copyright (c) Microsoft Corporation.
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
|
||||
function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
|
||||
_util$inspect$custom = util.inspect.custom;
|
||||
class ConsoleMessage extends _channelOwner.ChannelOwner {
|
||||
static from(message) {
|
||||
return message._object;
|
||||
}
|
||||
constructor(parent, type, guid, initializer) {
|
||||
super(parent, type, guid, initializer);
|
||||
// Note: currently, we only report console messages for pages and they always have a page.
|
||||
// However, in the future we might report console messages for service workers or something else,
|
||||
// where page() would be null.
|
||||
this._page = void 0;
|
||||
this._page = _page.Page.fromNullable(initializer.page);
|
||||
}
|
||||
page() {
|
||||
return this._page;
|
||||
}
|
||||
type() {
|
||||
return this._initializer.type;
|
||||
}
|
||||
text() {
|
||||
return this._initializer.text;
|
||||
}
|
||||
args() {
|
||||
return this._initializer.args.map(_jsHandle.JSHandle.from);
|
||||
}
|
||||
location() {
|
||||
return this._initializer.location;
|
||||
}
|
||||
[_util$inspect$custom]() {
|
||||
return this.text();
|
||||
}
|
||||
}
|
||||
exports.ConsoleMessage = ConsoleMessage;
|
||||
41
bin/pac/tools/.playwright/package/lib/client/coverage.js
Normal file
41
bin/pac/tools/.playwright/package/lib/client/coverage.js
Normal file
@@ -0,0 +1,41 @@
|
||||
"use strict";
|
||||
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
exports.Coverage = void 0;
|
||||
/**
|
||||
* Copyright (c) Microsoft Corporation.
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
class Coverage {
|
||||
constructor(channel) {
|
||||
this._channel = void 0;
|
||||
this._channel = channel;
|
||||
}
|
||||
async startJSCoverage(options = {}) {
|
||||
await this._channel.startJSCoverage(options);
|
||||
}
|
||||
async stopJSCoverage() {
|
||||
return (await this._channel.stopJSCoverage()).entries;
|
||||
}
|
||||
async startCSSCoverage(options = {}) {
|
||||
await this._channel.startCSSCoverage(options);
|
||||
}
|
||||
async stopCSSCoverage() {
|
||||
return (await this._channel.stopCSSCoverage()).entries;
|
||||
}
|
||||
}
|
||||
exports.Coverage = Coverage;
|
||||
57
bin/pac/tools/.playwright/package/lib/client/dialog.js
Normal file
57
bin/pac/tools/.playwright/package/lib/client/dialog.js
Normal file
@@ -0,0 +1,57 @@
|
||||
"use strict";
|
||||
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
exports.Dialog = void 0;
|
||||
var _channelOwner = require("./channelOwner");
|
||||
var _page = require("./page");
|
||||
/**
|
||||
* Copyright (c) Microsoft Corporation.
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
class Dialog extends _channelOwner.ChannelOwner {
|
||||
static from(dialog) {
|
||||
return dialog._object;
|
||||
}
|
||||
constructor(parent, type, guid, initializer) {
|
||||
super(parent, type, guid, initializer);
|
||||
// Note: dialogs that open early during page initialization block it.
|
||||
// Therefore, we must report the dialog without a page to be able to handle it.
|
||||
this._page = void 0;
|
||||
this._page = _page.Page.fromNullable(initializer.page);
|
||||
}
|
||||
page() {
|
||||
return this._page;
|
||||
}
|
||||
type() {
|
||||
return this._initializer.type;
|
||||
}
|
||||
message() {
|
||||
return this._initializer.message;
|
||||
}
|
||||
defaultValue() {
|
||||
return this._initializer.defaultValue;
|
||||
}
|
||||
async accept(promptText) {
|
||||
await this._channel.accept({
|
||||
promptText
|
||||
});
|
||||
}
|
||||
async dismiss() {
|
||||
await this._channel.dismiss();
|
||||
}
|
||||
}
|
||||
exports.Dialog = Dialog;
|
||||
62
bin/pac/tools/.playwright/package/lib/client/download.js
Normal file
62
bin/pac/tools/.playwright/package/lib/client/download.js
Normal file
@@ -0,0 +1,62 @@
|
||||
"use strict";
|
||||
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
exports.Download = void 0;
|
||||
/**
|
||||
* Copyright (c) Microsoft Corporation.
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
class Download {
|
||||
constructor(page, url, suggestedFilename, artifact) {
|
||||
this._page = void 0;
|
||||
this._url = void 0;
|
||||
this._suggestedFilename = void 0;
|
||||
this._artifact = void 0;
|
||||
this._page = page;
|
||||
this._url = url;
|
||||
this._suggestedFilename = suggestedFilename;
|
||||
this._artifact = artifact;
|
||||
}
|
||||
page() {
|
||||
return this._page;
|
||||
}
|
||||
url() {
|
||||
return this._url;
|
||||
}
|
||||
suggestedFilename() {
|
||||
return this._suggestedFilename;
|
||||
}
|
||||
async path() {
|
||||
return this._artifact.pathAfterFinished();
|
||||
}
|
||||
async saveAs(path) {
|
||||
return this._artifact.saveAs(path);
|
||||
}
|
||||
async failure() {
|
||||
return this._artifact.failure();
|
||||
}
|
||||
async createReadStream() {
|
||||
return this._artifact.createReadStream();
|
||||
}
|
||||
async cancel() {
|
||||
return this._artifact.cancel();
|
||||
}
|
||||
async delete() {
|
||||
return this._artifact.delete();
|
||||
}
|
||||
}
|
||||
exports.Download = Download;
|
||||
124
bin/pac/tools/.playwright/package/lib/client/electron.js
Normal file
124
bin/pac/tools/.playwright/package/lib/client/electron.js
Normal file
@@ -0,0 +1,124 @@
|
||||
"use strict";
|
||||
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
exports.ElectronApplication = exports.Electron = void 0;
|
||||
var _timeoutSettings = require("../common/timeoutSettings");
|
||||
var _browserContext = require("./browserContext");
|
||||
var _channelOwner = require("./channelOwner");
|
||||
var _clientHelper = require("./clientHelper");
|
||||
var _events = require("./events");
|
||||
var _jsHandle = require("./jsHandle");
|
||||
var _waiter = require("./waiter");
|
||||
/**
|
||||
* Copyright (c) Microsoft Corporation.
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
class Electron extends _channelOwner.ChannelOwner {
|
||||
static from(electron) {
|
||||
return electron._object;
|
||||
}
|
||||
constructor(parent, type, guid, initializer) {
|
||||
super(parent, type, guid, initializer);
|
||||
}
|
||||
async launch(options = {}) {
|
||||
const params = {
|
||||
...(await (0, _browserContext.prepareBrowserContextParams)(options)),
|
||||
env: (0, _clientHelper.envObjectToArray)(options.env ? options.env : process.env)
|
||||
};
|
||||
const app = ElectronApplication.from((await this._channel.launch(params)).electronApplication);
|
||||
app._context._options = params;
|
||||
return app;
|
||||
}
|
||||
}
|
||||
exports.Electron = Electron;
|
||||
class ElectronApplication extends _channelOwner.ChannelOwner {
|
||||
static from(electronApplication) {
|
||||
return electronApplication._object;
|
||||
}
|
||||
constructor(parent, type, guid, initializer) {
|
||||
super(parent, type, guid, initializer);
|
||||
this._context = void 0;
|
||||
this._windows = new Set();
|
||||
this._timeoutSettings = new _timeoutSettings.TimeoutSettings();
|
||||
this._isClosed = false;
|
||||
this._context = _browserContext.BrowserContext.from(initializer.context);
|
||||
for (const page of this._context._pages) this._onPage(page);
|
||||
this._context.on(_events.Events.BrowserContext.Page, page => this._onPage(page));
|
||||
this._channel.on('close', () => {
|
||||
this._isClosed = true;
|
||||
this.emit(_events.Events.ElectronApplication.Close);
|
||||
});
|
||||
}
|
||||
process() {
|
||||
return this._toImpl().process();
|
||||
}
|
||||
_onPage(page) {
|
||||
this._windows.add(page);
|
||||
this.emit(_events.Events.ElectronApplication.Window, page);
|
||||
page.once(_events.Events.Page.Close, () => this._windows.delete(page));
|
||||
}
|
||||
windows() {
|
||||
// TODO: add ElectronPage class inherting from Page.
|
||||
return [...this._windows];
|
||||
}
|
||||
async firstWindow(options) {
|
||||
if (this._windows.size) return this._windows.values().next().value;
|
||||
return this.waitForEvent('window', options);
|
||||
}
|
||||
context() {
|
||||
return this._context;
|
||||
}
|
||||
async close() {
|
||||
if (this._isClosed) return;
|
||||
await this._channel.close().catch(() => {});
|
||||
}
|
||||
async waitForEvent(event, optionsOrPredicate = {}) {
|
||||
return this._wrapApiCall(async () => {
|
||||
const timeout = this._timeoutSettings.timeout(typeof optionsOrPredicate === 'function' ? {} : optionsOrPredicate);
|
||||
const predicate = typeof optionsOrPredicate === 'function' ? optionsOrPredicate : optionsOrPredicate.predicate;
|
||||
const waiter = _waiter.Waiter.createForEvent(this, event);
|
||||
waiter.rejectOnTimeout(timeout, `Timeout ${timeout}ms exceeded while waiting for event "${event}"`);
|
||||
if (event !== _events.Events.ElectronApplication.Close) waiter.rejectOnEvent(this, _events.Events.ElectronApplication.Close, new Error('Electron application closed'));
|
||||
const result = await waiter.waitForEvent(this, event, predicate);
|
||||
waiter.dispose();
|
||||
return result;
|
||||
});
|
||||
}
|
||||
async browserWindow(page) {
|
||||
const result = await this._channel.browserWindow({
|
||||
page: page._channel
|
||||
});
|
||||
return _jsHandle.JSHandle.from(result.handle);
|
||||
}
|
||||
async evaluate(pageFunction, arg) {
|
||||
const result = await this._channel.evaluateExpression({
|
||||
expression: String(pageFunction),
|
||||
isFunction: typeof pageFunction === 'function',
|
||||
arg: (0, _jsHandle.serializeArgument)(arg)
|
||||
});
|
||||
return (0, _jsHandle.parseResult)(result.value);
|
||||
}
|
||||
async evaluateHandle(pageFunction, arg) {
|
||||
const result = await this._channel.evaluateExpressionHandle({
|
||||
expression: String(pageFunction),
|
||||
isFunction: typeof pageFunction === 'function',
|
||||
arg: (0, _jsHandle.serializeArgument)(arg)
|
||||
});
|
||||
return _jsHandle.JSHandle.from(result.handle);
|
||||
}
|
||||
}
|
||||
exports.ElectronApplication = ElectronApplication;
|
||||
312
bin/pac/tools/.playwright/package/lib/client/elementHandle.js
Normal file
312
bin/pac/tools/.playwright/package/lib/client/elementHandle.js
Normal file
@@ -0,0 +1,312 @@
|
||||
"use strict";
|
||||
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
exports.ElementHandle = void 0;
|
||||
exports.convertInputFiles = convertInputFiles;
|
||||
exports.convertSelectOptionValues = convertSelectOptionValues;
|
||||
exports.determineScreenshotType = determineScreenshotType;
|
||||
var _frame = require("./frame");
|
||||
var _jsHandle = require("./jsHandle");
|
||||
var _fs = _interopRequireDefault(require("fs"));
|
||||
var _utilsBundle = require("../utilsBundle");
|
||||
var _path = _interopRequireDefault(require("path"));
|
||||
var _utils = require("../utils");
|
||||
var _fileUtils = require("../utils/fileUtils");
|
||||
var _writableStream = require("./writableStream");
|
||||
var _stream = require("stream");
|
||||
var _util = require("util");
|
||||
var _debugLogger = require("../common/debugLogger");
|
||||
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
||||
/**
|
||||
* Copyright (c) Microsoft Corporation.
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
const pipelineAsync = (0, _util.promisify)(_stream.pipeline);
|
||||
class ElementHandle extends _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._elementChannel = void 0;
|
||||
this._elementChannel = this._channel;
|
||||
}
|
||||
asElement() {
|
||||
return this;
|
||||
}
|
||||
async ownerFrame() {
|
||||
return _frame.Frame.fromNullable((await this._elementChannel.ownerFrame()).frame);
|
||||
}
|
||||
async contentFrame() {
|
||||
return _frame.Frame.fromNullable((await this._elementChannel.contentFrame()).frame);
|
||||
}
|
||||
async getAttribute(name) {
|
||||
const value = (await this._elementChannel.getAttribute({
|
||||
name
|
||||
})).value;
|
||||
return value === undefined ? null : value;
|
||||
}
|
||||
async inputValue() {
|
||||
return (await this._elementChannel.inputValue()).value;
|
||||
}
|
||||
async textContent() {
|
||||
const value = (await this._elementChannel.textContent()).value;
|
||||
return value === undefined ? 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, _jsHandle.serializeArgument)(eventInit)
|
||||
});
|
||||
}
|
||||
async scrollIntoViewIfNeeded(options = {}) {
|
||||
await this._elementChannel.scrollIntoViewIfNeeded(options);
|
||||
}
|
||||
async hover(options = {}) {
|
||||
await this._elementChannel.hover(options);
|
||||
}
|
||||
async click(options = {}) {
|
||||
return await this._elementChannel.click(options);
|
||||
}
|
||||
async dblclick(options = {}) {
|
||||
return await this._elementChannel.dblclick(options);
|
||||
}
|
||||
async tap(options = {}) {
|
||||
return await this._elementChannel.tap(options);
|
||||
}
|
||||
async selectOption(values, options = {}) {
|
||||
const result = await this._elementChannel.selectOption({
|
||||
...convertSelectOptionValues(values),
|
||||
...options
|
||||
});
|
||||
return result.values;
|
||||
}
|
||||
async fill(value, options = {}) {
|
||||
return await this._elementChannel.fill({
|
||||
value,
|
||||
...options
|
||||
});
|
||||
}
|
||||
async selectText(options = {}) {
|
||||
await this._elementChannel.selectText(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(files, frame.page().context());
|
||||
if (converted.files) {
|
||||
await this._elementChannel.setInputFiles({
|
||||
files: converted.files,
|
||||
...options
|
||||
});
|
||||
} else {
|
||||
_debugLogger.debugLogger.log('api', 'switching to large files mode');
|
||||
await this._elementChannel.setInputFilePaths({
|
||||
...converted,
|
||||
...options
|
||||
});
|
||||
}
|
||||
}
|
||||
async focus() {
|
||||
await this._elementChannel.focus();
|
||||
}
|
||||
async type(text, options = {}) {
|
||||
await this._elementChannel.type({
|
||||
text,
|
||||
...options
|
||||
});
|
||||
}
|
||||
async press(key, options = {}) {
|
||||
await this._elementChannel.press({
|
||||
key,
|
||||
...options
|
||||
});
|
||||
}
|
||||
async check(options = {}) {
|
||||
return await this._elementChannel.check(options);
|
||||
}
|
||||
async uncheck(options = {}) {
|
||||
return await this._elementChannel.uncheck(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 === undefined ? null : value;
|
||||
}
|
||||
async screenshot(options = {}) {
|
||||
const copy = {
|
||||
...options,
|
||||
mask: undefined
|
||||
};
|
||||
if (!copy.type) copy.type = determineScreenshotType(options);
|
||||
if (options.mask) {
|
||||
copy.mask = options.mask.map(locator => ({
|
||||
frame: locator._frame._channel,
|
||||
selector: locator._selector
|
||||
}));
|
||||
}
|
||||
const result = await this._elementChannel.screenshot(copy);
|
||||
if (options.path) {
|
||||
await (0, _fileUtils.mkdirIfNeeded)(options.path);
|
||||
await _fs.default.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, _jsHandle.serializeArgument)(arg)
|
||||
});
|
||||
return (0, _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, _jsHandle.serializeArgument)(arg)
|
||||
});
|
||||
return (0, _jsHandle.parseResult)(result.value);
|
||||
}
|
||||
async waitForElementState(state, options = {}) {
|
||||
return await this._elementChannel.waitForElementState({
|
||||
state,
|
||||
...options
|
||||
});
|
||||
}
|
||||
async waitForSelector(selector, options = {}) {
|
||||
const result = await this._elementChannel.waitForSelector({
|
||||
selector,
|
||||
...options
|
||||
});
|
||||
return ElementHandle.fromNullable(result.element);
|
||||
}
|
||||
}
|
||||
exports.ElementHandle = ElementHandle;
|
||||
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, _utils.assert)(values[i] !== null, `options[${i}]: expected object, got null`);
|
||||
if (values[0] instanceof ElementHandle) return {
|
||||
elements: values.map(v => v._elementChannel)
|
||||
};
|
||||
if ((0, _utils.isString)(values[0])) return {
|
||||
options: values.map(valueOrLabel => ({
|
||||
valueOrLabel
|
||||
}))
|
||||
};
|
||||
return {
|
||||
options: values
|
||||
};
|
||||
}
|
||||
async function convertInputFiles(files, context) {
|
||||
const items = Array.isArray(files) ? files.slice() : [files];
|
||||
const sizeLimit = 50 * 1024 * 1024;
|
||||
const totalBufferSizeExceedsLimit = items.reduce((size, item) => size + (typeof item === 'object' && item.buffer ? item.buffer.byteLength : 0), 0) > sizeLimit;
|
||||
if (totalBufferSizeExceedsLimit) throw new Error('Cannot set buffer larger than 50Mb, please write it to a file and pass its path instead.');
|
||||
const stats = await Promise.all(items.filter(_utils.isString).map(item => _fs.default.promises.stat(item)));
|
||||
const totalFileSizeExceedsLimit = stats.reduce((acc, stat) => acc + stat.size, 0) > sizeLimit;
|
||||
if (totalFileSizeExceedsLimit) {
|
||||
if (context._connection.isRemote()) {
|
||||
const streams = await Promise.all(items.map(async item => {
|
||||
(0, _utils.assert)((0, _utils.isString)(item));
|
||||
const {
|
||||
writableStream: stream
|
||||
} = await context._channel.createTempFile({
|
||||
name: _path.default.basename(item)
|
||||
});
|
||||
const writable = _writableStream.WritableStream.from(stream);
|
||||
await pipelineAsync(_fs.default.createReadStream(item), writable.stream());
|
||||
return stream;
|
||||
}));
|
||||
return {
|
||||
streams
|
||||
};
|
||||
}
|
||||
return {
|
||||
localPaths: items.map(f => _path.default.resolve(f))
|
||||
};
|
||||
}
|
||||
const filePayloads = await Promise.all(items.map(async item => {
|
||||
if (typeof item === 'string') {
|
||||
return {
|
||||
name: _path.default.basename(item),
|
||||
buffer: await _fs.default.promises.readFile(item)
|
||||
};
|
||||
} else {
|
||||
return {
|
||||
name: item.name,
|
||||
mimeType: item.mimeType,
|
||||
buffer: item.buffer
|
||||
};
|
||||
}
|
||||
}));
|
||||
return {
|
||||
files: filePayloads
|
||||
};
|
||||
}
|
||||
function determineScreenshotType(options) {
|
||||
if (options.path) {
|
||||
const mimeType = _utilsBundle.mime.getType(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;
|
||||
}
|
||||
91
bin/pac/tools/.playwright/package/lib/client/events.js
Normal file
91
bin/pac/tools/.playwright/package/lib/client/events.js
Normal file
@@ -0,0 +1,91 @@
|
||||
"use strict";
|
||||
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
exports.Events = void 0;
|
||||
/**
|
||||
* Copyright 2019 Google Inc. All rights reserved.
|
||||
* Modifications copyright (c) Microsoft Corporation.
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
const Events = {
|
||||
AndroidDevice: {
|
||||
WebView: 'webview',
|
||||
Close: 'close'
|
||||
},
|
||||
AndroidSocket: {
|
||||
Data: 'data',
|
||||
Close: 'close'
|
||||
},
|
||||
AndroidWebView: {
|
||||
Close: 'close'
|
||||
},
|
||||
Browser: {
|
||||
Disconnected: 'disconnected'
|
||||
},
|
||||
BrowserContext: {
|
||||
Console: 'console',
|
||||
Close: 'close',
|
||||
Dialog: 'dialog',
|
||||
Page: 'page',
|
||||
BackgroundPage: 'backgroundpage',
|
||||
ServiceWorker: 'serviceworker',
|
||||
Request: 'request',
|
||||
Response: 'response',
|
||||
RequestFailed: 'requestfailed',
|
||||
RequestFinished: 'requestfinished'
|
||||
},
|
||||
BrowserServer: {
|
||||
Close: 'close'
|
||||
},
|
||||
Page: {
|
||||
Close: 'close',
|
||||
Crash: 'crash',
|
||||
Console: 'console',
|
||||
Dialog: 'dialog',
|
||||
Download: 'download',
|
||||
FileChooser: 'filechooser',
|
||||
DOMContentLoaded: 'domcontentloaded',
|
||||
// Can't use just 'error' due to node.js special treatment of error events.
|
||||
// @see https://nodejs.org/api/events.html#events_error_events
|
||||
PageError: 'pageerror',
|
||||
Request: 'request',
|
||||
Response: 'response',
|
||||
RequestFailed: 'requestfailed',
|
||||
RequestFinished: 'requestfinished',
|
||||
FrameAttached: 'frameattached',
|
||||
FrameDetached: 'framedetached',
|
||||
FrameNavigated: 'framenavigated',
|
||||
Load: 'load',
|
||||
Popup: 'popup',
|
||||
WebSocket: 'websocket',
|
||||
Worker: 'worker'
|
||||
},
|
||||
WebSocket: {
|
||||
Close: 'close',
|
||||
Error: 'socketerror',
|
||||
FrameReceived: 'framereceived',
|
||||
FrameSent: 'framesent'
|
||||
},
|
||||
Worker: {
|
||||
Close: 'close'
|
||||
},
|
||||
ElectronApplication: {
|
||||
Close: 'close',
|
||||
Window: 'window'
|
||||
}
|
||||
};
|
||||
exports.Events = Events;
|
||||
327
bin/pac/tools/.playwright/package/lib/client/fetch.js
Normal file
327
bin/pac/tools/.playwright/package/lib/client/fetch.js
Normal file
@@ -0,0 +1,327 @@
|
||||
"use strict";
|
||||
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
exports.APIResponse = exports.APIRequestContext = exports.APIRequest = void 0;
|
||||
var _fs = _interopRequireDefault(require("fs"));
|
||||
var _path = _interopRequireDefault(require("path"));
|
||||
var util = _interopRequireWildcard(require("util"));
|
||||
var _errors = require("../common/errors");
|
||||
var _utils = require("../utils");
|
||||
var _fileUtils = require("../utils/fileUtils");
|
||||
var _channelOwner = require("./channelOwner");
|
||||
var _network = require("./network");
|
||||
var _tracing = require("./tracing");
|
||||
let _util$inspect$custom;
|
||||
/**
|
||||
* Copyright (c) Microsoft Corporation.
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
|
||||
function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
|
||||
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
||||
class APIRequest {
|
||||
// Instrumentation.
|
||||
|
||||
constructor(playwright) {
|
||||
this._playwright = void 0;
|
||||
this._contexts = new Set();
|
||||
this._defaultContextOptions = void 0;
|
||||
this._playwright = playwright;
|
||||
}
|
||||
async newContext(options = {}) {
|
||||
var _this$_defaultContext;
|
||||
options = {
|
||||
...this._defaultContextOptions,
|
||||
...options
|
||||
};
|
||||
const storageState = typeof options.storageState === 'string' ? JSON.parse(await _fs.default.promises.readFile(options.storageState, 'utf8')) : options.storageState;
|
||||
// We do not expose tracesDir in the API, so do not allow options to accidentally override it.
|
||||
const tracesDir = (_this$_defaultContext = this._defaultContextOptions) === null || _this$_defaultContext === void 0 ? void 0 : _this$_defaultContext.tracesDir;
|
||||
const context = APIRequestContext.from((await this._playwright._channel.newRequest({
|
||||
...options,
|
||||
extraHTTPHeaders: options.extraHTTPHeaders ? (0, _utils.headersObjectToArray)(options.extraHTTPHeaders) : undefined,
|
||||
storageState,
|
||||
tracesDir
|
||||
})).request);
|
||||
this._contexts.add(context);
|
||||
context._request = this;
|
||||
context._tracing._tracesDir = tracesDir;
|
||||
await context._instrumentation.onDidCreateRequestContext(context);
|
||||
return context;
|
||||
}
|
||||
}
|
||||
exports.APIRequest = APIRequest;
|
||||
class APIRequestContext extends _channelOwner.ChannelOwner {
|
||||
static from(channel) {
|
||||
return channel._object;
|
||||
}
|
||||
constructor(parent, type, guid, initializer) {
|
||||
super(parent, type, guid, initializer);
|
||||
this._request = void 0;
|
||||
this._tracing = void 0;
|
||||
this._tracing = _tracing.Tracing.from(initializer.tracing);
|
||||
}
|
||||
async dispose() {
|
||||
var _this$_request;
|
||||
await this._instrumentation.onWillCloseRequestContext(this);
|
||||
await this._channel.dispose();
|
||||
(_this$_request = this._request) === null || _this$_request === void 0 ? void 0 : _this$_request._contexts.delete(this);
|
||||
}
|
||||
async delete(url, options) {
|
||||
return this.fetch(url, {
|
||||
...options,
|
||||
method: 'DELETE'
|
||||
});
|
||||
}
|
||||
async head(url, options) {
|
||||
return this.fetch(url, {
|
||||
...options,
|
||||
method: 'HEAD'
|
||||
});
|
||||
}
|
||||
async get(url, options) {
|
||||
return this.fetch(url, {
|
||||
...options,
|
||||
method: 'GET'
|
||||
});
|
||||
}
|
||||
async patch(url, options) {
|
||||
return this.fetch(url, {
|
||||
...options,
|
||||
method: 'PATCH'
|
||||
});
|
||||
}
|
||||
async post(url, options) {
|
||||
return this.fetch(url, {
|
||||
...options,
|
||||
method: 'POST'
|
||||
});
|
||||
}
|
||||
async put(url, options) {
|
||||
return this.fetch(url, {
|
||||
...options,
|
||||
method: 'PUT'
|
||||
});
|
||||
}
|
||||
async fetch(urlOrRequest, options = {}) {
|
||||
const url = (0, _utils.isString)(urlOrRequest) ? urlOrRequest : undefined;
|
||||
const request = (0, _utils.isString)(urlOrRequest) ? undefined : urlOrRequest;
|
||||
return this._innerFetch({
|
||||
url,
|
||||
request,
|
||||
...options
|
||||
});
|
||||
}
|
||||
async _innerFetch(options = {}) {
|
||||
return this._wrapApiCall(async () => {
|
||||
var _options$request, _options$request2, _options$request3;
|
||||
(0, _utils.assert)(options.request || typeof options.url === 'string', 'First argument must be either URL string or Request');
|
||||
(0, _utils.assert)((options.data === undefined ? 0 : 1) + (options.form === undefined ? 0 : 1) + (options.multipart === undefined ? 0 : 1) <= 1, `Only one of 'data', 'form' or 'multipart' can be specified`);
|
||||
(0, _utils.assert)(options.maxRedirects === undefined || options.maxRedirects >= 0, `'maxRedirects' should be greater than or equal to '0'`);
|
||||
const url = options.url !== undefined ? options.url : options.request.url();
|
||||
const params = objectToArray(options.params);
|
||||
const method = options.method || ((_options$request = options.request) === null || _options$request === void 0 ? void 0 : _options$request.method());
|
||||
const maxRedirects = options.maxRedirects;
|
||||
// Cannot call allHeaders() here as the request may be paused inside route handler.
|
||||
const headersObj = options.headers || ((_options$request2 = options.request) === null || _options$request2 === void 0 ? void 0 : _options$request2.headers());
|
||||
const headers = headersObj ? (0, _utils.headersObjectToArray)(headersObj) : undefined;
|
||||
let jsonData;
|
||||
let formData;
|
||||
let multipartData;
|
||||
let postDataBuffer;
|
||||
if (options.data !== undefined) {
|
||||
if ((0, _utils.isString)(options.data)) {
|
||||
if (isJsonContentType(headers)) jsonData = options.data;else postDataBuffer = Buffer.from(options.data, 'utf8');
|
||||
} else if (Buffer.isBuffer(options.data)) {
|
||||
postDataBuffer = options.data;
|
||||
} else if (typeof options.data === 'object' || typeof options.data === 'number' || typeof options.data === 'boolean') {
|
||||
jsonData = options.data;
|
||||
} else {
|
||||
throw new Error(`Unexpected 'data' type`);
|
||||
}
|
||||
} else if (options.form) {
|
||||
formData = objectToArray(options.form);
|
||||
} else if (options.multipart) {
|
||||
multipartData = [];
|
||||
// Convert file-like values to ServerFilePayload structs.
|
||||
for (const [name, value] of Object.entries(options.multipart)) {
|
||||
if (isFilePayload(value)) {
|
||||
const payload = value;
|
||||
if (!Buffer.isBuffer(payload.buffer)) throw new Error(`Unexpected buffer type of 'data.${name}'`);
|
||||
multipartData.push({
|
||||
name,
|
||||
file: filePayloadToJson(payload)
|
||||
});
|
||||
} else if (value instanceof _fs.default.ReadStream) {
|
||||
multipartData.push({
|
||||
name,
|
||||
file: await readStreamToJson(value)
|
||||
});
|
||||
} else {
|
||||
multipartData.push({
|
||||
name,
|
||||
value: String(value)
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
if (postDataBuffer === undefined && jsonData === undefined && formData === undefined && multipartData === undefined) postDataBuffer = ((_options$request3 = options.request) === null || _options$request3 === void 0 ? void 0 : _options$request3.postDataBuffer()) || undefined;
|
||||
const fixtures = {
|
||||
__testHookLookup: options.__testHookLookup
|
||||
};
|
||||
const result = await this._channel.fetch({
|
||||
url,
|
||||
params,
|
||||
method,
|
||||
headers,
|
||||
postData: postDataBuffer,
|
||||
jsonData,
|
||||
formData,
|
||||
multipartData,
|
||||
timeout: options.timeout,
|
||||
failOnStatusCode: options.failOnStatusCode,
|
||||
ignoreHTTPSErrors: options.ignoreHTTPSErrors,
|
||||
maxRedirects: maxRedirects,
|
||||
...fixtures
|
||||
});
|
||||
return new APIResponse(this, result.response);
|
||||
});
|
||||
}
|
||||
async storageState(options = {}) {
|
||||
const state = await this._channel.storageState();
|
||||
if (options.path) {
|
||||
await (0, _fileUtils.mkdirIfNeeded)(options.path);
|
||||
await _fs.default.promises.writeFile(options.path, JSON.stringify(state, undefined, 2), 'utf8');
|
||||
}
|
||||
return state;
|
||||
}
|
||||
}
|
||||
exports.APIRequestContext = APIRequestContext;
|
||||
_util$inspect$custom = util.inspect.custom;
|
||||
class APIResponse {
|
||||
constructor(context, initializer) {
|
||||
this._initializer = void 0;
|
||||
this._headers = void 0;
|
||||
this._request = void 0;
|
||||
this._request = context;
|
||||
this._initializer = initializer;
|
||||
this._headers = new _network.RawHeaders(this._initializer.headers);
|
||||
}
|
||||
ok() {
|
||||
return this._initializer.status >= 200 && this._initializer.status <= 299;
|
||||
}
|
||||
url() {
|
||||
return this._initializer.url;
|
||||
}
|
||||
status() {
|
||||
return this._initializer.status;
|
||||
}
|
||||
statusText() {
|
||||
return this._initializer.statusText;
|
||||
}
|
||||
headers() {
|
||||
return this._headers.headers();
|
||||
}
|
||||
headersArray() {
|
||||
return this._headers.headersArray();
|
||||
}
|
||||
async body() {
|
||||
try {
|
||||
const result = await this._request._channel.fetchResponseBody({
|
||||
fetchUid: this._fetchUid()
|
||||
});
|
||||
if (result.binary === undefined) throw new Error('Response has been disposed');
|
||||
return result.binary;
|
||||
} catch (e) {
|
||||
if (e.message.includes(_errors.kBrowserOrContextClosedError)) throw new Error('Response has been disposed');
|
||||
throw e;
|
||||
}
|
||||
}
|
||||
async text() {
|
||||
const content = await this.body();
|
||||
return content.toString('utf8');
|
||||
}
|
||||
async json() {
|
||||
const content = await this.text();
|
||||
return JSON.parse(content);
|
||||
}
|
||||
async dispose() {
|
||||
await this._request._channel.disposeAPIResponse({
|
||||
fetchUid: this._fetchUid()
|
||||
});
|
||||
}
|
||||
[_util$inspect$custom]() {
|
||||
const headers = this.headersArray().map(({
|
||||
name,
|
||||
value
|
||||
}) => ` ${name}: ${value}`);
|
||||
return `APIResponse: ${this.status()} ${this.statusText()}\n${headers.join('\n')}`;
|
||||
}
|
||||
_fetchUid() {
|
||||
return this._initializer.fetchUid;
|
||||
}
|
||||
async _fetchLog() {
|
||||
const {
|
||||
log
|
||||
} = await this._request._channel.fetchLog({
|
||||
fetchUid: this._fetchUid()
|
||||
});
|
||||
return log;
|
||||
}
|
||||
}
|
||||
exports.APIResponse = APIResponse;
|
||||
function filePayloadToJson(payload) {
|
||||
return {
|
||||
name: payload.name,
|
||||
mimeType: payload.mimeType,
|
||||
buffer: payload.buffer
|
||||
};
|
||||
}
|
||||
async function readStreamToJson(stream) {
|
||||
const buffer = await new Promise((resolve, reject) => {
|
||||
const chunks = [];
|
||||
stream.on('data', chunk => chunks.push(chunk));
|
||||
stream.on('end', () => resolve(Buffer.concat(chunks)));
|
||||
stream.on('error', err => reject(err));
|
||||
});
|
||||
const streamPath = Buffer.isBuffer(stream.path) ? stream.path.toString('utf8') : stream.path;
|
||||
return {
|
||||
name: _path.default.basename(streamPath),
|
||||
buffer
|
||||
};
|
||||
}
|
||||
function isJsonContentType(headers) {
|
||||
if (!headers) return false;
|
||||
for (const {
|
||||
name,
|
||||
value
|
||||
} of headers) {
|
||||
if (name.toLocaleLowerCase() === 'content-type') return value === 'application/json';
|
||||
}
|
||||
return false;
|
||||
}
|
||||
function objectToArray(map) {
|
||||
if (!map) return undefined;
|
||||
const result = [];
|
||||
for (const [name, value] of Object.entries(map)) result.push({
|
||||
name,
|
||||
value: String(value)
|
||||
});
|
||||
return result;
|
||||
}
|
||||
function isFilePayload(value) {
|
||||
return typeof value === 'object' && value['name'] && value['mimeType'] && value['buffer'];
|
||||
}
|
||||
45
bin/pac/tools/.playwright/package/lib/client/fileChooser.js
Normal file
45
bin/pac/tools/.playwright/package/lib/client/fileChooser.js
Normal file
@@ -0,0 +1,45 @@
|
||||
"use strict";
|
||||
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
exports.FileChooser = void 0;
|
||||
/**
|
||||
* Copyright (c) Microsoft Corporation.
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
class FileChooser {
|
||||
constructor(page, elementHandle, isMultiple) {
|
||||
this._page = void 0;
|
||||
this._elementHandle = void 0;
|
||||
this._isMultiple = void 0;
|
||||
this._page = page;
|
||||
this._elementHandle = elementHandle;
|
||||
this._isMultiple = isMultiple;
|
||||
}
|
||||
element() {
|
||||
return this._elementHandle;
|
||||
}
|
||||
isMultiple() {
|
||||
return this._isMultiple;
|
||||
}
|
||||
page() {
|
||||
return this._page;
|
||||
}
|
||||
async setFiles(files, options) {
|
||||
return this._elementHandle.setInputFiles(files, options);
|
||||
}
|
||||
}
|
||||
exports.FileChooser = FileChooser;
|
||||
515
bin/pac/tools/.playwright/package/lib/client/frame.js
Normal file
515
bin/pac/tools/.playwright/package/lib/client/frame.js
Normal file
@@ -0,0 +1,515 @@
|
||||
"use strict";
|
||||
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
exports.Frame = void 0;
|
||||
exports.verifyLoadState = verifyLoadState;
|
||||
var _utils = require("../utils");
|
||||
var _channelOwner = require("./channelOwner");
|
||||
var _locator = require("./locator");
|
||||
var _locatorUtils = require("../utils/isomorphic/locatorUtils");
|
||||
var _elementHandle = require("./elementHandle");
|
||||
var _jsHandle = require("./jsHandle");
|
||||
var _fs = _interopRequireDefault(require("fs"));
|
||||
var network = _interopRequireWildcard(require("./network"));
|
||||
var _events = require("events");
|
||||
var _waiter = require("./waiter");
|
||||
var _events2 = require("./events");
|
||||
var _types = require("./types");
|
||||
var _network2 = require("../utils/network");
|
||||
var _debugLogger = require("../common/debugLogger");
|
||||
function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
|
||||
function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
|
||||
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
||||
/**
|
||||
* Copyright 2017 Google Inc. All rights reserved.
|
||||
* Modifications copyright (c) Microsoft Corporation.
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
class Frame extends _channelOwner.ChannelOwner {
|
||||
static from(frame) {
|
||||
return frame._object;
|
||||
}
|
||||
static fromNullable(frame) {
|
||||
return frame ? Frame.from(frame) : null;
|
||||
}
|
||||
constructor(parent, type, guid, initializer) {
|
||||
super(parent, type, guid, initializer);
|
||||
this._eventEmitter = void 0;
|
||||
this._loadStates = void 0;
|
||||
this._parentFrame = null;
|
||||
this._url = '';
|
||||
this._name = '';
|
||||
this._detached = false;
|
||||
this._childFrames = new Set();
|
||||
this._page = void 0;
|
||||
this._eventEmitter = new _events.EventEmitter();
|
||||
this._eventEmitter.setMaxListeners(0);
|
||||
this._parentFrame = Frame.fromNullable(initializer.parentFrame);
|
||||
if (this._parentFrame) this._parentFrame._childFrames.add(this);
|
||||
this._name = initializer.name;
|
||||
this._url = initializer.url;
|
||||
this._loadStates = new Set(initializer.loadStates);
|
||||
this._channel.on('loadstate', event => {
|
||||
if (event.add) {
|
||||
this._loadStates.add(event.add);
|
||||
this._eventEmitter.emit('loadstate', event.add);
|
||||
}
|
||||
if (event.remove) this._loadStates.delete(event.remove);
|
||||
if (!this._parentFrame && event.add === 'load' && this._page) this._page.emit(_events2.Events.Page.Load, this._page);
|
||||
if (!this._parentFrame && event.add === 'domcontentloaded' && this._page) this._page.emit(_events2.Events.Page.DOMContentLoaded, this._page);
|
||||
});
|
||||
this._channel.on('navigated', event => {
|
||||
this._url = event.url;
|
||||
this._name = event.name;
|
||||
this._eventEmitter.emit('navigated', event);
|
||||
if (!event.error && this._page) this._page.emit(_events2.Events.Page.FrameNavigated, this);
|
||||
});
|
||||
}
|
||||
page() {
|
||||
return this._page;
|
||||
}
|
||||
async goto(url, options = {}) {
|
||||
const waitUntil = verifyLoadState('waitUntil', options.waitUntil === undefined ? 'load' : options.waitUntil);
|
||||
return network.Response.fromNullable((await this._channel.goto({
|
||||
url,
|
||||
...options,
|
||||
waitUntil
|
||||
})).response);
|
||||
}
|
||||
_setupNavigationWaiter(options) {
|
||||
const waiter = new _waiter.Waiter(this._page, '');
|
||||
if (this._page.isClosed()) waiter.rejectImmediately(new Error('Navigation failed because page was closed!'));
|
||||
waiter.rejectOnEvent(this._page, _events2.Events.Page.Close, new Error('Navigation failed because page was closed!'));
|
||||
waiter.rejectOnEvent(this._page, _events2.Events.Page.Crash, new Error('Navigation failed because page crashed!'));
|
||||
waiter.rejectOnEvent(this._page, _events2.Events.Page.FrameDetached, new Error('Navigating frame was detached!'), frame => frame === this);
|
||||
const timeout = this._page._timeoutSettings.navigationTimeout(options);
|
||||
waiter.rejectOnTimeout(timeout, `Timeout ${timeout}ms exceeded.`);
|
||||
return waiter;
|
||||
}
|
||||
async waitForNavigation(options = {}) {
|
||||
return this._page._wrapApiCall(async () => {
|
||||
const waitUntil = verifyLoadState('waitUntil', options.waitUntil === undefined ? 'load' : options.waitUntil);
|
||||
const waiter = this._setupNavigationWaiter(options);
|
||||
const toUrl = typeof options.url === 'string' ? ` to "${options.url}"` : '';
|
||||
waiter.log(`waiting for navigation${toUrl} until "${waitUntil}"`);
|
||||
const navigatedEvent = await waiter.waitForEvent(this._eventEmitter, 'navigated', event => {
|
||||
var _this$_page;
|
||||
// Any failed navigation results in a rejection.
|
||||
if (event.error) return true;
|
||||
waiter.log(` navigated to "${event.url}"`);
|
||||
return (0, _network2.urlMatches)((_this$_page = this._page) === null || _this$_page === void 0 ? void 0 : _this$_page.context()._options.baseURL, event.url, options.url);
|
||||
});
|
||||
if (navigatedEvent.error) {
|
||||
const e = new Error(navigatedEvent.error);
|
||||
e.stack = '';
|
||||
await waiter.waitForPromise(Promise.reject(e));
|
||||
}
|
||||
if (!this._loadStates.has(waitUntil)) {
|
||||
await waiter.waitForEvent(this._eventEmitter, 'loadstate', s => {
|
||||
waiter.log(` "${s}" event fired`);
|
||||
return s === waitUntil;
|
||||
});
|
||||
}
|
||||
const request = navigatedEvent.newDocument ? network.Request.fromNullable(navigatedEvent.newDocument.request) : null;
|
||||
const response = request ? await waiter.waitForPromise(request._finalRequest()._internalResponse()) : null;
|
||||
waiter.dispose();
|
||||
return response;
|
||||
});
|
||||
}
|
||||
async waitForLoadState(state = 'load', options = {}) {
|
||||
state = verifyLoadState('state', state);
|
||||
return this._page._wrapApiCall(async () => {
|
||||
const waiter = this._setupNavigationWaiter(options);
|
||||
if (this._loadStates.has(state)) {
|
||||
waiter.log(` not waiting, "${state}" event already fired`);
|
||||
} else {
|
||||
await waiter.waitForEvent(this._eventEmitter, 'loadstate', s => {
|
||||
waiter.log(` "${s}" event fired`);
|
||||
return s === state;
|
||||
});
|
||||
}
|
||||
waiter.dispose();
|
||||
});
|
||||
}
|
||||
async waitForURL(url, options = {}) {
|
||||
var _this$_page2;
|
||||
if ((0, _network2.urlMatches)((_this$_page2 = this._page) === null || _this$_page2 === void 0 ? void 0 : _this$_page2.context()._options.baseURL, this.url(), url)) return await this.waitForLoadState(options.waitUntil, options);
|
||||
await this.waitForNavigation({
|
||||
url,
|
||||
...options
|
||||
});
|
||||
}
|
||||
async frameElement() {
|
||||
return _elementHandle.ElementHandle.from((await this._channel.frameElement()).element);
|
||||
}
|
||||
async evaluateHandle(pageFunction, arg) {
|
||||
(0, _jsHandle.assertMaxArguments)(arguments.length, 2);
|
||||
const result = await this._channel.evaluateExpressionHandle({
|
||||
expression: String(pageFunction),
|
||||
isFunction: typeof pageFunction === 'function',
|
||||
arg: (0, _jsHandle.serializeArgument)(arg)
|
||||
});
|
||||
return _jsHandle.JSHandle.from(result.handle);
|
||||
}
|
||||
async evaluate(pageFunction, arg) {
|
||||
(0, _jsHandle.assertMaxArguments)(arguments.length, 2);
|
||||
const result = await this._channel.evaluateExpression({
|
||||
expression: String(pageFunction),
|
||||
isFunction: typeof pageFunction === 'function',
|
||||
arg: (0, _jsHandle.serializeArgument)(arg)
|
||||
});
|
||||
return (0, _jsHandle.parseResult)(result.value);
|
||||
}
|
||||
async _evaluateExposeUtilityScript(pageFunction, arg) {
|
||||
(0, _jsHandle.assertMaxArguments)(arguments.length, 2);
|
||||
const result = await this._channel.evaluateExpression({
|
||||
expression: String(pageFunction),
|
||||
isFunction: typeof pageFunction === 'function',
|
||||
exposeUtilityScript: true,
|
||||
arg: (0, _jsHandle.serializeArgument)(arg)
|
||||
});
|
||||
return (0, _jsHandle.parseResult)(result.value);
|
||||
}
|
||||
async $(selector, options) {
|
||||
const result = await this._channel.querySelector({
|
||||
selector,
|
||||
...options
|
||||
});
|
||||
return _elementHandle.ElementHandle.fromNullable(result.element);
|
||||
}
|
||||
async waitForSelector(selector, options = {}) {
|
||||
if (options.visibility) throw new Error('options.visibility is not supported, did you mean options.state?');
|
||||
if (options.waitFor && options.waitFor !== 'visible') throw new Error('options.waitFor is not supported, did you mean options.state?');
|
||||
const result = await this._channel.waitForSelector({
|
||||
selector,
|
||||
...options
|
||||
});
|
||||
return _elementHandle.ElementHandle.fromNullable(result.element);
|
||||
}
|
||||
async dispatchEvent(selector, type, eventInit, options = {}) {
|
||||
await this._channel.dispatchEvent({
|
||||
selector,
|
||||
type,
|
||||
eventInit: (0, _jsHandle.serializeArgument)(eventInit),
|
||||
...options
|
||||
});
|
||||
}
|
||||
async $eval(selector, pageFunction, arg) {
|
||||
(0, _jsHandle.assertMaxArguments)(arguments.length, 3);
|
||||
const result = await this._channel.evalOnSelector({
|
||||
selector,
|
||||
expression: String(pageFunction),
|
||||
isFunction: typeof pageFunction === 'function',
|
||||
arg: (0, _jsHandle.serializeArgument)(arg)
|
||||
});
|
||||
return (0, _jsHandle.parseResult)(result.value);
|
||||
}
|
||||
async $$eval(selector, pageFunction, arg) {
|
||||
(0, _jsHandle.assertMaxArguments)(arguments.length, 3);
|
||||
const result = await this._channel.evalOnSelectorAll({
|
||||
selector,
|
||||
expression: String(pageFunction),
|
||||
isFunction: typeof pageFunction === 'function',
|
||||
arg: (0, _jsHandle.serializeArgument)(arg)
|
||||
});
|
||||
return (0, _jsHandle.parseResult)(result.value);
|
||||
}
|
||||
async $$(selector) {
|
||||
const result = await this._channel.querySelectorAll({
|
||||
selector
|
||||
});
|
||||
return result.elements.map(e => _elementHandle.ElementHandle.from(e));
|
||||
}
|
||||
async _queryCount(selector) {
|
||||
return (await this._channel.queryCount({
|
||||
selector
|
||||
})).value;
|
||||
}
|
||||
async content() {
|
||||
return (await this._channel.content()).value;
|
||||
}
|
||||
async setContent(html, options = {}) {
|
||||
const waitUntil = verifyLoadState('waitUntil', options.waitUntil === undefined ? 'load' : options.waitUntil);
|
||||
await this._channel.setContent({
|
||||
html,
|
||||
...options,
|
||||
waitUntil
|
||||
});
|
||||
}
|
||||
name() {
|
||||
return this._name || '';
|
||||
}
|
||||
url() {
|
||||
return this._url;
|
||||
}
|
||||
parentFrame() {
|
||||
return this._parentFrame;
|
||||
}
|
||||
childFrames() {
|
||||
return Array.from(this._childFrames);
|
||||
}
|
||||
isDetached() {
|
||||
return this._detached;
|
||||
}
|
||||
async addScriptTag(options = {}) {
|
||||
const copy = {
|
||||
...options
|
||||
};
|
||||
if (copy.path) {
|
||||
copy.content = (await _fs.default.promises.readFile(copy.path)).toString();
|
||||
copy.content += '//# sourceURL=' + copy.path.replace(/\n/g, '');
|
||||
}
|
||||
return _elementHandle.ElementHandle.from((await this._channel.addScriptTag({
|
||||
...copy
|
||||
})).element);
|
||||
}
|
||||
async addStyleTag(options = {}) {
|
||||
const copy = {
|
||||
...options
|
||||
};
|
||||
if (copy.path) {
|
||||
copy.content = (await _fs.default.promises.readFile(copy.path)).toString();
|
||||
copy.content += '/*# sourceURL=' + copy.path.replace(/\n/g, '') + '*/';
|
||||
}
|
||||
return _elementHandle.ElementHandle.from((await this._channel.addStyleTag({
|
||||
...copy
|
||||
})).element);
|
||||
}
|
||||
async click(selector, options = {}) {
|
||||
return await this._channel.click({
|
||||
selector,
|
||||
...options
|
||||
});
|
||||
}
|
||||
async dblclick(selector, options = {}) {
|
||||
return await this._channel.dblclick({
|
||||
selector,
|
||||
...options
|
||||
});
|
||||
}
|
||||
async dragAndDrop(source, target, options = {}) {
|
||||
return await this._channel.dragAndDrop({
|
||||
source,
|
||||
target,
|
||||
...options
|
||||
});
|
||||
}
|
||||
async tap(selector, options = {}) {
|
||||
return await this._channel.tap({
|
||||
selector,
|
||||
...options
|
||||
});
|
||||
}
|
||||
async fill(selector, value, options = {}) {
|
||||
return await this._channel.fill({
|
||||
selector,
|
||||
value,
|
||||
...options
|
||||
});
|
||||
}
|
||||
async _highlight(selector) {
|
||||
return await this._channel.highlight({
|
||||
selector
|
||||
});
|
||||
}
|
||||
locator(selector, options) {
|
||||
return new _locator.Locator(this, selector, options);
|
||||
}
|
||||
getByTestId(testId) {
|
||||
return this.locator((0, _locatorUtils.getByTestIdSelector)((0, _locator.testIdAttributeName)(), testId));
|
||||
}
|
||||
getByAltText(text, options) {
|
||||
return this.locator((0, _locatorUtils.getByAltTextSelector)(text, options));
|
||||
}
|
||||
getByLabel(text, options) {
|
||||
return this.locator((0, _locatorUtils.getByLabelSelector)(text, options));
|
||||
}
|
||||
getByPlaceholder(text, options) {
|
||||
return this.locator((0, _locatorUtils.getByPlaceholderSelector)(text, options));
|
||||
}
|
||||
getByText(text, options) {
|
||||
return this.locator((0, _locatorUtils.getByTextSelector)(text, options));
|
||||
}
|
||||
getByTitle(text, options) {
|
||||
return this.locator((0, _locatorUtils.getByTitleSelector)(text, options));
|
||||
}
|
||||
getByRole(role, options = {}) {
|
||||
return this.locator((0, _locatorUtils.getByRoleSelector)(role, options));
|
||||
}
|
||||
frameLocator(selector) {
|
||||
return new _locator.FrameLocator(this, selector);
|
||||
}
|
||||
async focus(selector, options = {}) {
|
||||
await this._channel.focus({
|
||||
selector,
|
||||
...options
|
||||
});
|
||||
}
|
||||
async textContent(selector, options = {}) {
|
||||
const value = (await this._channel.textContent({
|
||||
selector,
|
||||
...options
|
||||
})).value;
|
||||
return value === undefined ? null : value;
|
||||
}
|
||||
async innerText(selector, options = {}) {
|
||||
return (await this._channel.innerText({
|
||||
selector,
|
||||
...options
|
||||
})).value;
|
||||
}
|
||||
async innerHTML(selector, options = {}) {
|
||||
return (await this._channel.innerHTML({
|
||||
selector,
|
||||
...options
|
||||
})).value;
|
||||
}
|
||||
async getAttribute(selector, name, options = {}) {
|
||||
const value = (await this._channel.getAttribute({
|
||||
selector,
|
||||
name,
|
||||
...options
|
||||
})).value;
|
||||
return value === undefined ? null : value;
|
||||
}
|
||||
async inputValue(selector, options = {}) {
|
||||
return (await this._channel.inputValue({
|
||||
selector,
|
||||
...options
|
||||
})).value;
|
||||
}
|
||||
async isChecked(selector, options = {}) {
|
||||
return (await this._channel.isChecked({
|
||||
selector,
|
||||
...options
|
||||
})).value;
|
||||
}
|
||||
async isDisabled(selector, options = {}) {
|
||||
return (await this._channel.isDisabled({
|
||||
selector,
|
||||
...options
|
||||
})).value;
|
||||
}
|
||||
async isEditable(selector, options = {}) {
|
||||
return (await this._channel.isEditable({
|
||||
selector,
|
||||
...options
|
||||
})).value;
|
||||
}
|
||||
async isEnabled(selector, options = {}) {
|
||||
return (await this._channel.isEnabled({
|
||||
selector,
|
||||
...options
|
||||
})).value;
|
||||
}
|
||||
async isHidden(selector, options = {}) {
|
||||
return (await this._channel.isHidden({
|
||||
selector,
|
||||
...options
|
||||
})).value;
|
||||
}
|
||||
async isVisible(selector, options = {}) {
|
||||
return (await this._channel.isVisible({
|
||||
selector,
|
||||
...options
|
||||
})).value;
|
||||
}
|
||||
async hover(selector, options = {}) {
|
||||
await this._channel.hover({
|
||||
selector,
|
||||
...options
|
||||
});
|
||||
}
|
||||
async selectOption(selector, values, options = {}) {
|
||||
return (await this._channel.selectOption({
|
||||
selector,
|
||||
...(0, _elementHandle.convertSelectOptionValues)(values),
|
||||
...options
|
||||
})).values;
|
||||
}
|
||||
async setInputFiles(selector, files, options = {}) {
|
||||
const converted = await (0, _elementHandle.convertInputFiles)(files, this.page().context());
|
||||
if (converted.files) {
|
||||
await this._channel.setInputFiles({
|
||||
selector,
|
||||
files: converted.files,
|
||||
...options
|
||||
});
|
||||
} else {
|
||||
_debugLogger.debugLogger.log('api', 'switching to large files mode');
|
||||
await this._channel.setInputFilePaths({
|
||||
selector,
|
||||
...converted,
|
||||
...options
|
||||
});
|
||||
}
|
||||
}
|
||||
async type(selector, text, options = {}) {
|
||||
await this._channel.type({
|
||||
selector,
|
||||
text,
|
||||
...options
|
||||
});
|
||||
}
|
||||
async press(selector, key, options = {}) {
|
||||
await this._channel.press({
|
||||
selector,
|
||||
key,
|
||||
...options
|
||||
});
|
||||
}
|
||||
async check(selector, options = {}) {
|
||||
await this._channel.check({
|
||||
selector,
|
||||
...options
|
||||
});
|
||||
}
|
||||
async uncheck(selector, options = {}) {
|
||||
await this._channel.uncheck({
|
||||
selector,
|
||||
...options
|
||||
});
|
||||
}
|
||||
async setChecked(selector, checked, options) {
|
||||
if (checked) await this.check(selector, options);else await this.uncheck(selector, options);
|
||||
}
|
||||
async waitForTimeout(timeout) {
|
||||
await this._channel.waitForTimeout({
|
||||
timeout
|
||||
});
|
||||
}
|
||||
async waitForFunction(pageFunction, arg, options = {}) {
|
||||
if (typeof options.polling === 'string') (0, _utils.assert)(options.polling === 'raf', 'Unknown polling option: ' + options.polling);
|
||||
const result = await this._channel.waitForFunction({
|
||||
...options,
|
||||
pollingInterval: options.polling === 'raf' ? undefined : options.polling,
|
||||
expression: String(pageFunction),
|
||||
isFunction: typeof pageFunction === 'function',
|
||||
arg: (0, _jsHandle.serializeArgument)(arg)
|
||||
});
|
||||
return _jsHandle.JSHandle.from(result.handle);
|
||||
}
|
||||
async title() {
|
||||
return (await this._channel.title()).value;
|
||||
}
|
||||
}
|
||||
exports.Frame = Frame;
|
||||
function verifyLoadState(name, waitUntil) {
|
||||
if (waitUntil === 'networkidle0') waitUntil = 'networkidle';
|
||||
if (!_types.kLifecycleEvents.has(waitUntil)) throw new Error(`${name}: expected one of (load|domcontentloaded|networkidle|commit)`);
|
||||
return waitUntil;
|
||||
}
|
||||
92
bin/pac/tools/.playwright/package/lib/client/harRouter.js
Normal file
92
bin/pac/tools/.playwright/package/lib/client/harRouter.js
Normal file
@@ -0,0 +1,92 @@
|
||||
"use strict";
|
||||
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
exports.HarRouter = void 0;
|
||||
var _debugLogger = require("../common/debugLogger");
|
||||
var _events = require("./events");
|
||||
/**
|
||||
* Copyright (c) Microsoft Corporation.
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
class HarRouter {
|
||||
static async create(localUtils, file, notFoundAction, options) {
|
||||
const {
|
||||
harId,
|
||||
error
|
||||
} = await localUtils._channel.harOpen({
|
||||
file
|
||||
});
|
||||
if (error) throw new Error(error);
|
||||
return new HarRouter(localUtils, harId, notFoundAction, options);
|
||||
}
|
||||
constructor(localUtils, harId, notFoundAction, options) {
|
||||
this._localUtils = void 0;
|
||||
this._harId = void 0;
|
||||
this._notFoundAction = void 0;
|
||||
this._options = void 0;
|
||||
this._localUtils = localUtils;
|
||||
this._harId = harId;
|
||||
this._options = options;
|
||||
this._notFoundAction = notFoundAction;
|
||||
}
|
||||
async _handle(route) {
|
||||
const request = route.request();
|
||||
const response = await this._localUtils._channel.harLookup({
|
||||
harId: this._harId,
|
||||
url: request.url(),
|
||||
method: request.method(),
|
||||
headers: await request.headersArray(),
|
||||
postData: request.postDataBuffer() || undefined,
|
||||
isNavigationRequest: request.isNavigationRequest()
|
||||
});
|
||||
if (response.action === 'redirect') {
|
||||
_debugLogger.debugLogger.log('api', `HAR: ${route.request().url()} redirected to ${response.redirectURL}`);
|
||||
await route._redirectNavigationRequest(response.redirectURL);
|
||||
return;
|
||||
}
|
||||
if (response.action === 'fulfill') {
|
||||
await route.fulfill({
|
||||
status: response.status,
|
||||
headers: Object.fromEntries(response.headers.map(h => [h.name, h.value])),
|
||||
body: response.body
|
||||
});
|
||||
return;
|
||||
}
|
||||
if (response.action === 'error') _debugLogger.debugLogger.log('api', 'HAR: ' + response.message);
|
||||
// Report the error, but fall through to the default handler.
|
||||
|
||||
if (this._notFoundAction === 'abort') {
|
||||
await route.abort();
|
||||
return;
|
||||
}
|
||||
await route.fallback();
|
||||
}
|
||||
async addContextRoute(context) {
|
||||
await context.route(this._options.urlMatch || '**/*', route => this._handle(route));
|
||||
context.once(_events.Events.BrowserContext.Close, () => this.dispose());
|
||||
}
|
||||
async addPageRoute(page) {
|
||||
await page.route(this._options.urlMatch || '**/*', route => this._handle(route));
|
||||
page.once(_events.Events.Page.Close, () => this.dispose());
|
||||
}
|
||||
dispose() {
|
||||
this._localUtils._channel.harClose({
|
||||
harId: this._harId
|
||||
}).catch(() => {});
|
||||
}
|
||||
}
|
||||
exports.HarRouter = HarRouter;
|
||||
111
bin/pac/tools/.playwright/package/lib/client/input.js
Normal file
111
bin/pac/tools/.playwright/package/lib/client/input.js
Normal file
@@ -0,0 +1,111 @@
|
||||
"use strict";
|
||||
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
exports.Touchscreen = exports.Mouse = exports.Keyboard = void 0;
|
||||
/**
|
||||
* Copyright 2017 Google Inc. All rights reserved.
|
||||
* Modifications copyright (c) Microsoft Corporation.
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
class Keyboard {
|
||||
constructor(page) {
|
||||
this._page = void 0;
|
||||
this._page = page;
|
||||
}
|
||||
async down(key) {
|
||||
await this._page._channel.keyboardDown({
|
||||
key
|
||||
});
|
||||
}
|
||||
async up(key) {
|
||||
await this._page._channel.keyboardUp({
|
||||
key
|
||||
});
|
||||
}
|
||||
async insertText(text) {
|
||||
await this._page._channel.keyboardInsertText({
|
||||
text
|
||||
});
|
||||
}
|
||||
async type(text, options = {}) {
|
||||
await this._page._channel.keyboardType({
|
||||
text,
|
||||
...options
|
||||
});
|
||||
}
|
||||
async press(key, options = {}) {
|
||||
await this._page._channel.keyboardPress({
|
||||
key,
|
||||
...options
|
||||
});
|
||||
}
|
||||
}
|
||||
exports.Keyboard = Keyboard;
|
||||
class Mouse {
|
||||
constructor(page) {
|
||||
this._page = void 0;
|
||||
this._page = page;
|
||||
}
|
||||
async move(x, y, options = {}) {
|
||||
await this._page._channel.mouseMove({
|
||||
x,
|
||||
y,
|
||||
...options
|
||||
});
|
||||
}
|
||||
async down(options = {}) {
|
||||
await this._page._channel.mouseDown({
|
||||
...options
|
||||
});
|
||||
}
|
||||
async up(options = {}) {
|
||||
await this._page._channel.mouseUp(options);
|
||||
}
|
||||
async click(x, y, options = {}) {
|
||||
await this._page._channel.mouseClick({
|
||||
x,
|
||||
y,
|
||||
...options
|
||||
});
|
||||
}
|
||||
async dblclick(x, y, options = {}) {
|
||||
await this.click(x, y, {
|
||||
...options,
|
||||
clickCount: 2
|
||||
});
|
||||
}
|
||||
async wheel(deltaX, deltaY) {
|
||||
await this._page._channel.mouseWheel({
|
||||
deltaX,
|
||||
deltaY
|
||||
});
|
||||
}
|
||||
}
|
||||
exports.Mouse = Mouse;
|
||||
class Touchscreen {
|
||||
constructor(page) {
|
||||
this._page = void 0;
|
||||
this._page = page;
|
||||
}
|
||||
async tap(x, y) {
|
||||
await this._page._channel.touchscreenTap({
|
||||
x,
|
||||
y
|
||||
});
|
||||
}
|
||||
}
|
||||
exports.Touchscreen = Touchscreen;
|
||||
@@ -0,0 +1,118 @@
|
||||
"use strict";
|
||||
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
exports.JoiningEventEmitter = void 0;
|
||||
var _events = require("events");
|
||||
var _multimap = require("../utils/multimap");
|
||||
/**
|
||||
* Copyright (c) Microsoft Corporation.
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
const originalListener = Symbol('originalListener');
|
||||
const wrapperListener = Symbol('wrapperListener');
|
||||
class JoiningEventEmitter {
|
||||
constructor() {
|
||||
this._emitterDelegate = new _events.EventEmitter();
|
||||
this._pendingPromises = new _multimap.MultiMap();
|
||||
}
|
||||
addListener(event, listener) {
|
||||
this._emitterDelegate.addListener(event, this._wrap(event, listener));
|
||||
return this;
|
||||
}
|
||||
on(event, listener) {
|
||||
this._emitterDelegate.on(event, this._wrap(event, listener));
|
||||
return this;
|
||||
}
|
||||
once(event, listener) {
|
||||
const onceWrapper = (...args) => {
|
||||
listener(...args);
|
||||
this.off(event, onceWrapper);
|
||||
};
|
||||
this.on(event, onceWrapper);
|
||||
return this;
|
||||
}
|
||||
removeListener(event, listener) {
|
||||
this._emitterDelegate.removeListener(event, this._wrapper(listener));
|
||||
return this;
|
||||
}
|
||||
off(event, listener) {
|
||||
this._emitterDelegate.off(event, this._wrapper(listener));
|
||||
return this;
|
||||
}
|
||||
removeAllListeners(event) {
|
||||
this._emitterDelegate.removeAllListeners(event);
|
||||
return this;
|
||||
}
|
||||
setMaxListeners(n) {
|
||||
this._emitterDelegate.setMaxListeners(n);
|
||||
return this;
|
||||
}
|
||||
getMaxListeners() {
|
||||
return this._emitterDelegate.getMaxListeners();
|
||||
}
|
||||
listeners(event) {
|
||||
return this._emitterDelegate.listeners(event).map(f => this._original(f));
|
||||
}
|
||||
rawListeners(event) {
|
||||
return this._emitterDelegate.rawListeners(event).map(f => this._original(f));
|
||||
}
|
||||
emit(event, ...args) {
|
||||
return this._emitterDelegate.emit(event, ...args);
|
||||
}
|
||||
listenerCount(event) {
|
||||
return this._emitterDelegate.listenerCount(event);
|
||||
}
|
||||
prependListener(event, listener) {
|
||||
this._emitterDelegate.prependListener(event, this._wrap(event, listener));
|
||||
return this;
|
||||
}
|
||||
prependOnceListener(event, listener) {
|
||||
const onceWrapper = (...args) => {
|
||||
listener(...args);
|
||||
this.off(event, onceWrapper);
|
||||
};
|
||||
this.prependListener(event, onceWrapper);
|
||||
return this;
|
||||
}
|
||||
eventNames() {
|
||||
return this._emitterDelegate.eventNames();
|
||||
}
|
||||
async _joinPendingEventHandlers() {
|
||||
await Promise.all([...this._pendingPromises.values()]);
|
||||
}
|
||||
_wrap(event, listener) {
|
||||
const wrapper = (...args) => {
|
||||
const result = listener(...args);
|
||||
if (result instanceof Promise) {
|
||||
this._pendingPromises.set(event, result);
|
||||
result.finally(() => this._pendingPromises.delete(event, result));
|
||||
}
|
||||
};
|
||||
wrapper[originalListener] = listener;
|
||||
listener[wrapperListener] = wrapper;
|
||||
return wrapper;
|
||||
}
|
||||
_wrapper(listener) {
|
||||
var _wrapperListener;
|
||||
// Fallback to original listener if not wrapped to ensure backwards compatibility Node.js's event emitter
|
||||
return (_wrapperListener = listener[wrapperListener]) !== null && _wrapperListener !== void 0 ? _wrapperListener : listener;
|
||||
}
|
||||
_original(wrapper) {
|
||||
return wrapper[originalListener];
|
||||
}
|
||||
}
|
||||
exports.JoiningEventEmitter = JoiningEventEmitter;
|
||||
119
bin/pac/tools/.playwright/package/lib/client/jsHandle.js
Normal file
119
bin/pac/tools/.playwright/package/lib/client/jsHandle.js
Normal file
@@ -0,0 +1,119 @@
|
||||
"use strict";
|
||||
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
exports.JSHandle = void 0;
|
||||
exports.assertMaxArguments = assertMaxArguments;
|
||||
exports.parseResult = parseResult;
|
||||
exports.serializeArgument = serializeArgument;
|
||||
var _channelOwner = require("./channelOwner");
|
||||
var _serializers = require("../protocol/serializers");
|
||||
/**
|
||||
* Copyright (c) Microsoft Corporation.
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
class JSHandle extends _channelOwner.ChannelOwner {
|
||||
static from(handle) {
|
||||
return handle._object;
|
||||
}
|
||||
constructor(parent, type, guid, initializer) {
|
||||
super(parent, type, guid, initializer);
|
||||
this._preview = void 0;
|
||||
this._preview = this._initializer.preview;
|
||||
this._channel.on('previewUpdated', ({
|
||||
preview
|
||||
}) => this._preview = preview);
|
||||
}
|
||||
async evaluate(pageFunction, arg) {
|
||||
const result = await this._channel.evaluateExpression({
|
||||
expression: String(pageFunction),
|
||||
isFunction: typeof pageFunction === 'function',
|
||||
arg: serializeArgument(arg)
|
||||
});
|
||||
return parseResult(result.value);
|
||||
}
|
||||
async evaluateHandle(pageFunction, arg) {
|
||||
const result = await this._channel.evaluateExpressionHandle({
|
||||
expression: String(pageFunction),
|
||||
isFunction: typeof pageFunction === 'function',
|
||||
arg: serializeArgument(arg)
|
||||
});
|
||||
return JSHandle.from(result.handle);
|
||||
}
|
||||
async getProperty(propertyName) {
|
||||
const result = await this._channel.getProperty({
|
||||
name: propertyName
|
||||
});
|
||||
return JSHandle.from(result.handle);
|
||||
}
|
||||
async getProperties() {
|
||||
const map = new Map();
|
||||
for (const {
|
||||
name,
|
||||
value
|
||||
} of (await this._channel.getPropertyList()).properties) map.set(name, JSHandle.from(value));
|
||||
return map;
|
||||
}
|
||||
async jsonValue() {
|
||||
return parseResult((await this._channel.jsonValue()).value);
|
||||
}
|
||||
asElement() {
|
||||
return null;
|
||||
}
|
||||
async dispose() {
|
||||
return await this._channel.dispose();
|
||||
}
|
||||
async _objectCount() {
|
||||
return this._wrapApiCall(async () => {
|
||||
const {
|
||||
count
|
||||
} = await this._channel.objectCount();
|
||||
return count;
|
||||
});
|
||||
}
|
||||
toString() {
|
||||
return this._preview;
|
||||
}
|
||||
}
|
||||
|
||||
// This function takes care of converting all JSHandles to their channels,
|
||||
// so that generic channel serializer converts them to guids.
|
||||
exports.JSHandle = JSHandle;
|
||||
function serializeArgument(arg) {
|
||||
const handles = [];
|
||||
const pushHandle = channel => {
|
||||
handles.push(channel);
|
||||
return handles.length - 1;
|
||||
};
|
||||
const value = (0, _serializers.serializeValue)(arg, value => {
|
||||
if (value instanceof JSHandle) return {
|
||||
h: pushHandle(value._channel)
|
||||
};
|
||||
return {
|
||||
fallThrough: value
|
||||
};
|
||||
});
|
||||
return {
|
||||
value,
|
||||
handles
|
||||
};
|
||||
}
|
||||
function parseResult(value) {
|
||||
return (0, _serializers.parseSerializedValue)(value, undefined);
|
||||
}
|
||||
function assertMaxArguments(count, max) {
|
||||
if (count > max) throw new Error('Too many arguments. If you need to pass more than 1 argument to the function wrap them in an object.');
|
||||
}
|
||||
35
bin/pac/tools/.playwright/package/lib/client/jsonPipe.js
Normal file
35
bin/pac/tools/.playwright/package/lib/client/jsonPipe.js
Normal file
@@ -0,0 +1,35 @@
|
||||
"use strict";
|
||||
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
exports.JsonPipe = void 0;
|
||||
var _channelOwner = require("./channelOwner");
|
||||
/**
|
||||
* Copyright (c) Microsoft Corporation.
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
class JsonPipe extends _channelOwner.ChannelOwner {
|
||||
static from(jsonPipe) {
|
||||
return jsonPipe._object;
|
||||
}
|
||||
constructor(parent, type, guid, initializer) {
|
||||
super(parent, type, guid, initializer);
|
||||
}
|
||||
channel() {
|
||||
return this._channel;
|
||||
}
|
||||
}
|
||||
exports.JsonPipe = JsonPipe;
|
||||
29
bin/pac/tools/.playwright/package/lib/client/localUtils.js
Normal file
29
bin/pac/tools/.playwright/package/lib/client/localUtils.js
Normal file
@@ -0,0 +1,29 @@
|
||||
"use strict";
|
||||
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
exports.LocalUtils = void 0;
|
||||
var _channelOwner = require("./channelOwner");
|
||||
/**
|
||||
* Copyright (c) Microsoft Corporation.
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
class LocalUtils extends _channelOwner.ChannelOwner {
|
||||
constructor(parent, type, guid, initializer) {
|
||||
super(parent, type, guid, initializer);
|
||||
}
|
||||
}
|
||||
exports.LocalUtils = LocalUtils;
|
||||
429
bin/pac/tools/.playwright/package/lib/client/locator.js
Normal file
429
bin/pac/tools/.playwright/package/lib/client/locator.js
Normal file
@@ -0,0 +1,429 @@
|
||||
"use strict";
|
||||
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
exports.Locator = exports.FrameLocator = void 0;
|
||||
exports.setTestIdAttribute = setTestIdAttribute;
|
||||
exports.testIdAttributeName = testIdAttributeName;
|
||||
var util = _interopRequireWildcard(require("util"));
|
||||
var _utils = require("../utils");
|
||||
var _elementHandle = require("./elementHandle");
|
||||
var _jsHandle = require("./jsHandle");
|
||||
var _stringUtils = require("../utils/isomorphic/stringUtils");
|
||||
var _locatorUtils = require("../utils/isomorphic/locatorUtils");
|
||||
let _util$inspect$custom;
|
||||
/**
|
||||
* Copyright (c) Microsoft Corporation.
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
|
||||
function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
|
||||
_util$inspect$custom = util.inspect.custom;
|
||||
class Locator {
|
||||
constructor(frame, selector, options) {
|
||||
this._frame = void 0;
|
||||
this._selector = void 0;
|
||||
this._frame = frame;
|
||||
this._selector = selector;
|
||||
if (options !== null && options !== void 0 && options.hasText) this._selector += ` >> internal:has-text=${(0, _stringUtils.escapeForTextSelector)(options.hasText, false)}`;
|
||||
if (options !== null && options !== void 0 && options.hasNotText) this._selector += ` >> internal:has-not-text=${(0, _stringUtils.escapeForTextSelector)(options.hasNotText, false)}`;
|
||||
if (options !== null && options !== void 0 && options.has) {
|
||||
const locator = options.has;
|
||||
if (locator._frame !== frame) throw new Error(`Inner "has" locator must belong to the same frame.`);
|
||||
this._selector += ` >> internal:has=` + JSON.stringify(locator._selector);
|
||||
}
|
||||
if (options !== null && options !== void 0 && options.hasNot) {
|
||||
const locator = options.hasNot;
|
||||
if (locator._frame !== frame) throw new Error(`Inner "hasNot" locator must belong to the same frame.`);
|
||||
this._selector += ` >> internal:has-not=` + JSON.stringify(locator._selector);
|
||||
}
|
||||
}
|
||||
async _withElement(task, timeout) {
|
||||
timeout = this._frame.page()._timeoutSettings.timeout({
|
||||
timeout
|
||||
});
|
||||
const deadline = timeout ? (0, _utils.monotonicTime)() + timeout : 0;
|
||||
return this._frame._wrapApiCall(async () => {
|
||||
const result = await this._frame._channel.waitForSelector({
|
||||
selector: this._selector,
|
||||
strict: true,
|
||||
state: 'attached',
|
||||
timeout
|
||||
});
|
||||
const handle = _elementHandle.ElementHandle.fromNullable(result.element);
|
||||
if (!handle) throw new Error(`Could not resolve ${this._selector} to DOM Element`);
|
||||
try {
|
||||
return await task(handle, deadline ? deadline - (0, _utils.monotonicTime)() : 0);
|
||||
} finally {
|
||||
await handle.dispose();
|
||||
}
|
||||
});
|
||||
}
|
||||
page() {
|
||||
return this._frame.page();
|
||||
}
|
||||
async boundingBox(options) {
|
||||
return this._withElement(h => h.boundingBox(), options === null || options === void 0 ? void 0 : options.timeout);
|
||||
}
|
||||
async check(options = {}) {
|
||||
return this._frame.check(this._selector, {
|
||||
strict: true,
|
||||
...options
|
||||
});
|
||||
}
|
||||
async click(options = {}) {
|
||||
return this._frame.click(this._selector, {
|
||||
strict: true,
|
||||
...options
|
||||
});
|
||||
}
|
||||
async dblclick(options = {}) {
|
||||
return this._frame.dblclick(this._selector, {
|
||||
strict: true,
|
||||
...options
|
||||
});
|
||||
}
|
||||
async dispatchEvent(type, eventInit = {}, options) {
|
||||
return this._frame.dispatchEvent(this._selector, type, eventInit, {
|
||||
strict: true,
|
||||
...options
|
||||
});
|
||||
}
|
||||
async dragTo(target, options = {}) {
|
||||
return this._frame.dragAndDrop(this._selector, target._selector, {
|
||||
strict: true,
|
||||
...options
|
||||
});
|
||||
}
|
||||
async evaluate(pageFunction, arg, options) {
|
||||
return this._withElement(h => h.evaluate(pageFunction, arg), options === null || options === void 0 ? void 0 : options.timeout);
|
||||
}
|
||||
async evaluateAll(pageFunction, arg) {
|
||||
return this._frame.$$eval(this._selector, pageFunction, arg);
|
||||
}
|
||||
async evaluateHandle(pageFunction, arg, options) {
|
||||
return this._withElement(h => h.evaluateHandle(pageFunction, arg), options === null || options === void 0 ? void 0 : options.timeout);
|
||||
}
|
||||
async fill(value, options = {}) {
|
||||
return this._frame.fill(this._selector, value, {
|
||||
strict: true,
|
||||
...options
|
||||
});
|
||||
}
|
||||
async clear(options = {}) {
|
||||
return this.fill('', options);
|
||||
}
|
||||
async _highlight() {
|
||||
// VS Code extension uses this one, keep it for now.
|
||||
return this._frame._highlight(this._selector);
|
||||
}
|
||||
async highlight() {
|
||||
return this._frame._highlight(this._selector);
|
||||
}
|
||||
locator(selectorOrLocator, options) {
|
||||
if ((0, _utils.isString)(selectorOrLocator)) return new Locator(this._frame, this._selector + ' >> ' + selectorOrLocator, options);
|
||||
if (selectorOrLocator._frame !== this._frame) throw new Error(`Locators must belong to the same frame.`);
|
||||
return new Locator(this._frame, this._selector + ' >> ' + selectorOrLocator._selector, options);
|
||||
}
|
||||
getByTestId(testId) {
|
||||
return this.locator((0, _locatorUtils.getByTestIdSelector)(testIdAttributeName(), testId));
|
||||
}
|
||||
getByAltText(text, options) {
|
||||
return this.locator((0, _locatorUtils.getByAltTextSelector)(text, options));
|
||||
}
|
||||
getByLabel(text, options) {
|
||||
return this.locator((0, _locatorUtils.getByLabelSelector)(text, options));
|
||||
}
|
||||
getByPlaceholder(text, options) {
|
||||
return this.locator((0, _locatorUtils.getByPlaceholderSelector)(text, options));
|
||||
}
|
||||
getByText(text, options) {
|
||||
return this.locator((0, _locatorUtils.getByTextSelector)(text, options));
|
||||
}
|
||||
getByTitle(text, options) {
|
||||
return this.locator((0, _locatorUtils.getByTitleSelector)(text, options));
|
||||
}
|
||||
getByRole(role, options = {}) {
|
||||
return this.locator((0, _locatorUtils.getByRoleSelector)(role, options));
|
||||
}
|
||||
frameLocator(selector) {
|
||||
return new FrameLocator(this._frame, this._selector + ' >> ' + selector);
|
||||
}
|
||||
filter(options) {
|
||||
return new Locator(this._frame, this._selector, options);
|
||||
}
|
||||
async elementHandle(options) {
|
||||
return await this._frame.waitForSelector(this._selector, {
|
||||
strict: true,
|
||||
state: 'attached',
|
||||
...options
|
||||
});
|
||||
}
|
||||
async elementHandles() {
|
||||
return this._frame.$$(this._selector);
|
||||
}
|
||||
first() {
|
||||
return new Locator(this._frame, this._selector + ' >> nth=0');
|
||||
}
|
||||
last() {
|
||||
return new Locator(this._frame, this._selector + ` >> nth=-1`);
|
||||
}
|
||||
nth(index) {
|
||||
return new Locator(this._frame, this._selector + ` >> nth=${index}`);
|
||||
}
|
||||
and(locator) {
|
||||
if (locator._frame !== this._frame) throw new Error(`Locators must belong to the same frame.`);
|
||||
return new Locator(this._frame, this._selector + ` >> internal:and=` + JSON.stringify(locator._selector));
|
||||
}
|
||||
or(locator) {
|
||||
if (locator._frame !== this._frame) throw new Error(`Locators must belong to the same frame.`);
|
||||
return new Locator(this._frame, this._selector + ` >> internal:or=` + JSON.stringify(locator._selector));
|
||||
}
|
||||
async focus(options) {
|
||||
return this._frame.focus(this._selector, {
|
||||
strict: true,
|
||||
...options
|
||||
});
|
||||
}
|
||||
async blur(options) {
|
||||
await this._frame._channel.blur({
|
||||
selector: this._selector,
|
||||
strict: true,
|
||||
...options
|
||||
});
|
||||
}
|
||||
async count() {
|
||||
return this._frame._queryCount(this._selector);
|
||||
}
|
||||
async getAttribute(name, options) {
|
||||
return this._frame.getAttribute(this._selector, name, {
|
||||
strict: true,
|
||||
...options
|
||||
});
|
||||
}
|
||||
async hover(options = {}) {
|
||||
return this._frame.hover(this._selector, {
|
||||
strict: true,
|
||||
...options
|
||||
});
|
||||
}
|
||||
async innerHTML(options) {
|
||||
return this._frame.innerHTML(this._selector, {
|
||||
strict: true,
|
||||
...options
|
||||
});
|
||||
}
|
||||
async innerText(options) {
|
||||
return this._frame.innerText(this._selector, {
|
||||
strict: true,
|
||||
...options
|
||||
});
|
||||
}
|
||||
async inputValue(options) {
|
||||
return this._frame.inputValue(this._selector, {
|
||||
strict: true,
|
||||
...options
|
||||
});
|
||||
}
|
||||
async isChecked(options) {
|
||||
return this._frame.isChecked(this._selector, {
|
||||
strict: true,
|
||||
...options
|
||||
});
|
||||
}
|
||||
async isDisabled(options) {
|
||||
return this._frame.isDisabled(this._selector, {
|
||||
strict: true,
|
||||
...options
|
||||
});
|
||||
}
|
||||
async isEditable(options) {
|
||||
return this._frame.isEditable(this._selector, {
|
||||
strict: true,
|
||||
...options
|
||||
});
|
||||
}
|
||||
async isEnabled(options) {
|
||||
return this._frame.isEnabled(this._selector, {
|
||||
strict: true,
|
||||
...options
|
||||
});
|
||||
}
|
||||
async isHidden(options) {
|
||||
return this._frame.isHidden(this._selector, {
|
||||
strict: true,
|
||||
...options
|
||||
});
|
||||
}
|
||||
async isVisible(options) {
|
||||
return this._frame.isVisible(this._selector, {
|
||||
strict: true,
|
||||
...options
|
||||
});
|
||||
}
|
||||
async press(key, options = {}) {
|
||||
return this._frame.press(this._selector, key, {
|
||||
strict: true,
|
||||
...options
|
||||
});
|
||||
}
|
||||
async screenshot(options = {}) {
|
||||
return this._withElement((h, timeout) => h.screenshot({
|
||||
...options,
|
||||
timeout
|
||||
}), options.timeout);
|
||||
}
|
||||
async scrollIntoViewIfNeeded(options = {}) {
|
||||
return this._withElement((h, timeout) => h.scrollIntoViewIfNeeded({
|
||||
...options,
|
||||
timeout
|
||||
}), options.timeout);
|
||||
}
|
||||
async selectOption(values, options = {}) {
|
||||
return this._frame.selectOption(this._selector, values, {
|
||||
strict: true,
|
||||
...options
|
||||
});
|
||||
}
|
||||
async selectText(options = {}) {
|
||||
return this._withElement((h, timeout) => h.selectText({
|
||||
...options,
|
||||
timeout
|
||||
}), options.timeout);
|
||||
}
|
||||
async setChecked(checked, options) {
|
||||
if (checked) await this.check(options);else await this.uncheck(options);
|
||||
}
|
||||
async setInputFiles(files, options = {}) {
|
||||
return this._frame.setInputFiles(this._selector, files, {
|
||||
strict: true,
|
||||
...options
|
||||
});
|
||||
}
|
||||
async tap(options = {}) {
|
||||
return this._frame.tap(this._selector, {
|
||||
strict: true,
|
||||
...options
|
||||
});
|
||||
}
|
||||
async textContent(options) {
|
||||
return this._frame.textContent(this._selector, {
|
||||
strict: true,
|
||||
...options
|
||||
});
|
||||
}
|
||||
async type(text, options = {}) {
|
||||
return this._frame.type(this._selector, text, {
|
||||
strict: true,
|
||||
...options
|
||||
});
|
||||
}
|
||||
async uncheck(options = {}) {
|
||||
return this._frame.uncheck(this._selector, {
|
||||
strict: true,
|
||||
...options
|
||||
});
|
||||
}
|
||||
async all() {
|
||||
return new Array(await this.count()).fill(0).map((e, i) => this.nth(i));
|
||||
}
|
||||
async allInnerTexts() {
|
||||
return this._frame.$$eval(this._selector, ee => ee.map(e => e.innerText));
|
||||
}
|
||||
async allTextContents() {
|
||||
return this._frame.$$eval(this._selector, ee => ee.map(e => e.textContent || ''));
|
||||
}
|
||||
async waitFor(options) {
|
||||
await this._frame._channel.waitForSelector({
|
||||
selector: this._selector,
|
||||
strict: true,
|
||||
omitReturnValue: true,
|
||||
...options
|
||||
});
|
||||
}
|
||||
async _expect(expression, options) {
|
||||
const params = {
|
||||
selector: this._selector,
|
||||
expression,
|
||||
...options,
|
||||
isNot: !!options.isNot
|
||||
};
|
||||
params.expectedValue = (0, _jsHandle.serializeArgument)(options.expectedValue);
|
||||
const result = await this._frame._channel.expect(params);
|
||||
if (result.received !== undefined) result.received = (0, _jsHandle.parseResult)(result.received);
|
||||
return result;
|
||||
}
|
||||
[_util$inspect$custom]() {
|
||||
return this.toString();
|
||||
}
|
||||
toString() {
|
||||
return `Locator@${this._selector}`;
|
||||
}
|
||||
}
|
||||
exports.Locator = Locator;
|
||||
class FrameLocator {
|
||||
constructor(frame, selector) {
|
||||
this._frame = void 0;
|
||||
this._frameSelector = void 0;
|
||||
this._frame = frame;
|
||||
this._frameSelector = selector;
|
||||
}
|
||||
locator(selectorOrLocator, options) {
|
||||
if ((0, _utils.isString)(selectorOrLocator)) return new Locator(this._frame, this._frameSelector + ' >> internal:control=enter-frame >> ' + selectorOrLocator, options);
|
||||
if (selectorOrLocator._frame !== this._frame) throw new Error(`Locators must belong to the same frame.`);
|
||||
return new Locator(this._frame, this._frameSelector + ' >> internal:control=enter-frame >> ' + selectorOrLocator._selector, options);
|
||||
}
|
||||
getByTestId(testId) {
|
||||
return this.locator((0, _locatorUtils.getByTestIdSelector)(testIdAttributeName(), testId));
|
||||
}
|
||||
getByAltText(text, options) {
|
||||
return this.locator((0, _locatorUtils.getByAltTextSelector)(text, options));
|
||||
}
|
||||
getByLabel(text, options) {
|
||||
return this.locator((0, _locatorUtils.getByLabelSelector)(text, options));
|
||||
}
|
||||
getByPlaceholder(text, options) {
|
||||
return this.locator((0, _locatorUtils.getByPlaceholderSelector)(text, options));
|
||||
}
|
||||
getByText(text, options) {
|
||||
return this.locator((0, _locatorUtils.getByTextSelector)(text, options));
|
||||
}
|
||||
getByTitle(text, options) {
|
||||
return this.locator((0, _locatorUtils.getByTitleSelector)(text, options));
|
||||
}
|
||||
getByRole(role, options = {}) {
|
||||
return this.locator((0, _locatorUtils.getByRoleSelector)(role, options));
|
||||
}
|
||||
frameLocator(selector) {
|
||||
return new FrameLocator(this._frame, this._frameSelector + ' >> internal:control=enter-frame >> ' + selector);
|
||||
}
|
||||
first() {
|
||||
return new FrameLocator(this._frame, this._frameSelector + ' >> nth=0');
|
||||
}
|
||||
last() {
|
||||
return new FrameLocator(this._frame, this._frameSelector + ` >> nth=-1`);
|
||||
}
|
||||
nth(index) {
|
||||
return new FrameLocator(this._frame, this._frameSelector + ` >> nth=${index}`);
|
||||
}
|
||||
}
|
||||
exports.FrameLocator = FrameLocator;
|
||||
let _testIdAttributeName = 'data-testid';
|
||||
function testIdAttributeName() {
|
||||
return _testIdAttributeName;
|
||||
}
|
||||
function setTestIdAttribute(attributeName) {
|
||||
_testIdAttributeName = attributeName;
|
||||
}
|
||||
552
bin/pac/tools/.playwright/package/lib/client/network.js
Normal file
552
bin/pac/tools/.playwright/package/lib/client/network.js
Normal file
@@ -0,0 +1,552 @@
|
||||
"use strict";
|
||||
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
exports.WebSocket = exports.RouteHandler = exports.Route = exports.Response = exports.Request = exports.RawHeaders = void 0;
|
||||
exports.validateHeaders = validateHeaders;
|
||||
var _url = require("url");
|
||||
var _channelOwner = require("./channelOwner");
|
||||
var _frame = require("./frame");
|
||||
var _worker = require("./worker");
|
||||
var _fs = _interopRequireDefault(require("fs"));
|
||||
var _utilsBundle = require("../utilsBundle");
|
||||
var _utils = require("../utils");
|
||||
var _manualPromise = require("../utils/manualPromise");
|
||||
var _events = require("./events");
|
||||
var _waiter = require("./waiter");
|
||||
var _network = require("../utils/network");
|
||||
var _multimap = require("../utils/multimap");
|
||||
var _fetch = require("./fetch");
|
||||
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
||||
/**
|
||||
* Copyright (c) Microsoft Corporation.
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
class Request extends _channelOwner.ChannelOwner {
|
||||
static from(request) {
|
||||
return request._object;
|
||||
}
|
||||
static fromNullable(request) {
|
||||
return request ? Request.from(request) : null;
|
||||
}
|
||||
constructor(parent, type, guid, initializer) {
|
||||
super(parent, type, guid, initializer);
|
||||
this._redirectedFrom = null;
|
||||
this._redirectedTo = null;
|
||||
this._failureText = null;
|
||||
this._provisionalHeaders = void 0;
|
||||
this._actualHeadersPromise = void 0;
|
||||
this._timing = void 0;
|
||||
this._fallbackOverrides = {};
|
||||
this._redirectedFrom = Request.fromNullable(initializer.redirectedFrom);
|
||||
if (this._redirectedFrom) this._redirectedFrom._redirectedTo = this;
|
||||
this._provisionalHeaders = new RawHeaders(initializer.headers);
|
||||
this._fallbackOverrides.postDataBuffer = initializer.postData;
|
||||
this._timing = {
|
||||
startTime: 0,
|
||||
domainLookupStart: -1,
|
||||
domainLookupEnd: -1,
|
||||
connectStart: -1,
|
||||
secureConnectionStart: -1,
|
||||
connectEnd: -1,
|
||||
requestStart: -1,
|
||||
responseStart: -1,
|
||||
responseEnd: -1
|
||||
};
|
||||
}
|
||||
url() {
|
||||
return this._fallbackOverrides.url || this._initializer.url;
|
||||
}
|
||||
resourceType() {
|
||||
return this._initializer.resourceType;
|
||||
}
|
||||
method() {
|
||||
return this._fallbackOverrides.method || this._initializer.method;
|
||||
}
|
||||
postData() {
|
||||
var _this$_fallbackOverri;
|
||||
return ((_this$_fallbackOverri = this._fallbackOverrides.postDataBuffer) === null || _this$_fallbackOverri === void 0 ? void 0 : _this$_fallbackOverri.toString('utf-8')) || null;
|
||||
}
|
||||
postDataBuffer() {
|
||||
return this._fallbackOverrides.postDataBuffer || null;
|
||||
}
|
||||
postDataJSON() {
|
||||
const postData = this.postData();
|
||||
if (!postData) return null;
|
||||
const contentType = this.headers()['content-type'];
|
||||
if (contentType === 'application/x-www-form-urlencoded') {
|
||||
const entries = {};
|
||||
const parsed = new _url.URLSearchParams(postData);
|
||||
for (const [k, v] of parsed.entries()) entries[k] = v;
|
||||
return entries;
|
||||
}
|
||||
try {
|
||||
return JSON.parse(postData);
|
||||
} catch (e) {
|
||||
throw new Error('POST data is not a valid JSON object: ' + postData);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @deprecated
|
||||
*/
|
||||
headers() {
|
||||
if (this._fallbackOverrides.headers) return RawHeaders._fromHeadersObjectLossy(this._fallbackOverrides.headers).headers();
|
||||
return this._provisionalHeaders.headers();
|
||||
}
|
||||
_context() {
|
||||
// TODO: make sure this works for service worker requests.
|
||||
return this.frame().page().context();
|
||||
}
|
||||
_actualHeaders() {
|
||||
if (this._fallbackOverrides.headers) return Promise.resolve(RawHeaders._fromHeadersObjectLossy(this._fallbackOverrides.headers));
|
||||
if (!this._actualHeadersPromise) {
|
||||
this._actualHeadersPromise = this._wrapApiCall(async () => {
|
||||
return new RawHeaders((await this._channel.rawRequestHeaders()).headers);
|
||||
});
|
||||
}
|
||||
return this._actualHeadersPromise;
|
||||
}
|
||||
async allHeaders() {
|
||||
return (await this._actualHeaders()).headers();
|
||||
}
|
||||
async headersArray() {
|
||||
return (await this._actualHeaders()).headersArray();
|
||||
}
|
||||
async headerValue(name) {
|
||||
return (await this._actualHeaders()).get(name);
|
||||
}
|
||||
async response() {
|
||||
return Response.fromNullable((await this._channel.response()).response);
|
||||
}
|
||||
async _internalResponse() {
|
||||
return this._wrapApiCall(async () => {
|
||||
return Response.fromNullable((await this._channel.response()).response);
|
||||
}, true);
|
||||
}
|
||||
frame() {
|
||||
if (!this._initializer.frame) {
|
||||
(0, _utils.assert)(this.serviceWorker());
|
||||
throw new Error('Service Worker requests do not have an associated frame.');
|
||||
}
|
||||
return _frame.Frame.from(this._initializer.frame);
|
||||
}
|
||||
serviceWorker() {
|
||||
return this._initializer.serviceWorker ? _worker.Worker.from(this._initializer.serviceWorker) : null;
|
||||
}
|
||||
isNavigationRequest() {
|
||||
return this._initializer.isNavigationRequest;
|
||||
}
|
||||
redirectedFrom() {
|
||||
return this._redirectedFrom;
|
||||
}
|
||||
redirectedTo() {
|
||||
return this._redirectedTo;
|
||||
}
|
||||
failure() {
|
||||
if (this._failureText === null) return null;
|
||||
return {
|
||||
errorText: this._failureText
|
||||
};
|
||||
}
|
||||
timing() {
|
||||
return this._timing;
|
||||
}
|
||||
async sizes() {
|
||||
const response = await this.response();
|
||||
if (!response) throw new Error('Unable to fetch sizes for failed request');
|
||||
return (await response._channel.sizes()).sizes;
|
||||
}
|
||||
_setResponseEndTiming(responseEndTiming) {
|
||||
this._timing.responseEnd = responseEndTiming;
|
||||
if (this._timing.responseStart === -1) this._timing.responseStart = responseEndTiming;
|
||||
}
|
||||
_finalRequest() {
|
||||
return this._redirectedTo ? this._redirectedTo._finalRequest() : this;
|
||||
}
|
||||
_applyFallbackOverrides(overrides) {
|
||||
if (overrides.url) this._fallbackOverrides.url = overrides.url;
|
||||
if (overrides.method) this._fallbackOverrides.method = overrides.method;
|
||||
if (overrides.headers) this._fallbackOverrides.headers = overrides.headers;
|
||||
if ((0, _utils.isString)(overrides.postData)) this._fallbackOverrides.postDataBuffer = Buffer.from(overrides.postData, 'utf-8');else if (overrides.postData instanceof Buffer) this._fallbackOverrides.postDataBuffer = overrides.postData;else if (overrides.postData) this._fallbackOverrides.postDataBuffer = Buffer.from(JSON.stringify(overrides.postData), 'utf-8');
|
||||
}
|
||||
_fallbackOverridesForContinue() {
|
||||
return this._fallbackOverrides;
|
||||
}
|
||||
_targetClosedRace() {
|
||||
var _this$serviceWorker, _this$frame$_page;
|
||||
return ((_this$serviceWorker = this.serviceWorker()) === null || _this$serviceWorker === void 0 ? void 0 : _this$serviceWorker._closedRace) || ((_this$frame$_page = this.frame()._page) === null || _this$frame$_page === void 0 ? void 0 : _this$frame$_page._closedOrCrashedRace) || new _manualPromise.ScopedRace();
|
||||
}
|
||||
}
|
||||
exports.Request = Request;
|
||||
class Route extends _channelOwner.ChannelOwner {
|
||||
static from(route) {
|
||||
return route._object;
|
||||
}
|
||||
constructor(parent, type, guid, initializer) {
|
||||
super(parent, type, guid, initializer);
|
||||
this._handlingPromise = null;
|
||||
}
|
||||
request() {
|
||||
return Request.from(this._initializer.request);
|
||||
}
|
||||
_raceWithTargetClose(promise) {
|
||||
// When page closes or crashes, we catch any potential rejects from this Route.
|
||||
// Note that page could be missing when routing popup's initial request that
|
||||
// does not have a Page initialized just yet.
|
||||
return this.request()._targetClosedRace().safeRace(promise);
|
||||
}
|
||||
_startHandling() {
|
||||
this._handlingPromise = new _manualPromise.ManualPromise();
|
||||
return this._handlingPromise;
|
||||
}
|
||||
async fallback(options = {}) {
|
||||
this._checkNotHandled();
|
||||
this.request()._applyFallbackOverrides(options);
|
||||
this._reportHandled(false);
|
||||
}
|
||||
async abort(errorCode) {
|
||||
this._checkNotHandled();
|
||||
await this._raceWithTargetClose(this._channel.abort({
|
||||
requestUrl: this.request()._initializer.url,
|
||||
errorCode
|
||||
}));
|
||||
this._reportHandled(true);
|
||||
}
|
||||
async _redirectNavigationRequest(url) {
|
||||
this._checkNotHandled();
|
||||
await this._raceWithTargetClose(this._channel.redirectNavigationRequest({
|
||||
url
|
||||
}));
|
||||
this._reportHandled(true);
|
||||
}
|
||||
async fetch(options = {}) {
|
||||
return await this._wrapApiCall(async () => {
|
||||
const context = this.request()._context();
|
||||
return context.request._innerFetch({
|
||||
request: this.request(),
|
||||
data: options.postData,
|
||||
...options
|
||||
});
|
||||
});
|
||||
}
|
||||
async fulfill(options = {}) {
|
||||
this._checkNotHandled();
|
||||
await this._wrapApiCall(async () => {
|
||||
await this._innerFulfill(options);
|
||||
this._reportHandled(true);
|
||||
});
|
||||
}
|
||||
async _innerFulfill(options = {}) {
|
||||
let fetchResponseUid;
|
||||
let {
|
||||
status: statusOption,
|
||||
headers: headersOption,
|
||||
body
|
||||
} = options;
|
||||
if (options.json !== undefined) {
|
||||
(0, _utils.assert)(options.body === undefined, 'Can specify either body or json parameters');
|
||||
body = JSON.stringify(options.json);
|
||||
}
|
||||
if (options.response instanceof _fetch.APIResponse) {
|
||||
var _statusOption, _headersOption;
|
||||
(_statusOption = statusOption) !== null && _statusOption !== void 0 ? _statusOption : statusOption = options.response.status();
|
||||
(_headersOption = headersOption) !== null && _headersOption !== void 0 ? _headersOption : headersOption = options.response.headers();
|
||||
if (body === undefined && options.path === undefined) {
|
||||
if (options.response._request._connection === this._connection) fetchResponseUid = options.response._fetchUid();else body = await options.response.body();
|
||||
}
|
||||
}
|
||||
let isBase64 = false;
|
||||
let length = 0;
|
||||
if (options.path) {
|
||||
const buffer = await _fs.default.promises.readFile(options.path);
|
||||
body = buffer.toString('base64');
|
||||
isBase64 = true;
|
||||
length = buffer.length;
|
||||
} else if ((0, _utils.isString)(body)) {
|
||||
isBase64 = false;
|
||||
length = Buffer.byteLength(body);
|
||||
} else if (body) {
|
||||
length = body.length;
|
||||
body = body.toString('base64');
|
||||
isBase64 = true;
|
||||
}
|
||||
const headers = {};
|
||||
for (const header of Object.keys(headersOption || {})) headers[header.toLowerCase()] = String(headersOption[header]);
|
||||
if (options.contentType) headers['content-type'] = String(options.contentType);else if (options.json) headers['content-type'] = 'application/json';else if (options.path) headers['content-type'] = _utilsBundle.mime.getType(options.path) || 'application/octet-stream';
|
||||
if (length && !('content-length' in headers)) headers['content-length'] = String(length);
|
||||
await this._raceWithTargetClose(this._channel.fulfill({
|
||||
requestUrl: this.request()._initializer.url,
|
||||
status: statusOption || 200,
|
||||
headers: (0, _utils.headersObjectToArray)(headers),
|
||||
body,
|
||||
isBase64,
|
||||
fetchResponseUid
|
||||
}));
|
||||
}
|
||||
async continue(options = {}) {
|
||||
this._checkNotHandled();
|
||||
this.request()._applyFallbackOverrides(options);
|
||||
await this._innerContinue();
|
||||
this._reportHandled(true);
|
||||
}
|
||||
_checkNotHandled() {
|
||||
if (!this._handlingPromise) throw new Error('Route is already handled!');
|
||||
}
|
||||
_reportHandled(done) {
|
||||
const chain = this._handlingPromise;
|
||||
this._handlingPromise = null;
|
||||
chain.resolve(done);
|
||||
}
|
||||
async _innerContinue(internal = false) {
|
||||
const options = this.request()._fallbackOverridesForContinue();
|
||||
return await this._wrapApiCall(async () => {
|
||||
await this._raceWithTargetClose(this._channel.continue({
|
||||
requestUrl: this.request()._initializer.url,
|
||||
url: options.url,
|
||||
method: options.method,
|
||||
headers: options.headers ? (0, _utils.headersObjectToArray)(options.headers) : undefined,
|
||||
postData: options.postDataBuffer,
|
||||
isFallback: internal
|
||||
}));
|
||||
}, !!internal);
|
||||
}
|
||||
}
|
||||
exports.Route = Route;
|
||||
class Response extends _channelOwner.ChannelOwner {
|
||||
static from(response) {
|
||||
return response._object;
|
||||
}
|
||||
static fromNullable(response) {
|
||||
return response ? Response.from(response) : null;
|
||||
}
|
||||
constructor(parent, type, guid, initializer) {
|
||||
super(parent, type, guid, initializer);
|
||||
this._provisionalHeaders = void 0;
|
||||
this._actualHeadersPromise = void 0;
|
||||
this._request = void 0;
|
||||
this._finishedPromise = new _manualPromise.ManualPromise();
|
||||
this._provisionalHeaders = new RawHeaders(initializer.headers);
|
||||
this._request = Request.from(this._initializer.request);
|
||||
Object.assign(this._request._timing, this._initializer.timing);
|
||||
}
|
||||
url() {
|
||||
return this._initializer.url;
|
||||
}
|
||||
ok() {
|
||||
// Status 0 is for file:// URLs
|
||||
return this._initializer.status === 0 || this._initializer.status >= 200 && this._initializer.status <= 299;
|
||||
}
|
||||
status() {
|
||||
return this._initializer.status;
|
||||
}
|
||||
statusText() {
|
||||
return this._initializer.statusText;
|
||||
}
|
||||
fromServiceWorker() {
|
||||
return this._initializer.fromServiceWorker;
|
||||
}
|
||||
|
||||
/**
|
||||
* @deprecated
|
||||
*/
|
||||
headers() {
|
||||
return this._provisionalHeaders.headers();
|
||||
}
|
||||
async _actualHeaders() {
|
||||
if (!this._actualHeadersPromise) {
|
||||
this._actualHeadersPromise = (async () => {
|
||||
return new RawHeaders((await this._channel.rawResponseHeaders()).headers);
|
||||
})();
|
||||
}
|
||||
return this._actualHeadersPromise;
|
||||
}
|
||||
async allHeaders() {
|
||||
return (await this._actualHeaders()).headers();
|
||||
}
|
||||
async headersArray() {
|
||||
return (await this._actualHeaders()).headersArray().slice();
|
||||
}
|
||||
async headerValue(name) {
|
||||
return (await this._actualHeaders()).get(name);
|
||||
}
|
||||
async headerValues(name) {
|
||||
return (await this._actualHeaders()).getAll(name);
|
||||
}
|
||||
async finished() {
|
||||
return this.request()._targetClosedRace().race(this._finishedPromise);
|
||||
}
|
||||
async body() {
|
||||
return (await this._channel.body()).binary;
|
||||
}
|
||||
async text() {
|
||||
const content = await this.body();
|
||||
return content.toString('utf8');
|
||||
}
|
||||
async json() {
|
||||
const content = await this.text();
|
||||
return JSON.parse(content);
|
||||
}
|
||||
request() {
|
||||
return this._request;
|
||||
}
|
||||
frame() {
|
||||
return this._request.frame();
|
||||
}
|
||||
async serverAddr() {
|
||||
return (await this._channel.serverAddr()).value || null;
|
||||
}
|
||||
async securityDetails() {
|
||||
return (await this._channel.securityDetails()).value || null;
|
||||
}
|
||||
}
|
||||
exports.Response = Response;
|
||||
class WebSocket extends _channelOwner.ChannelOwner {
|
||||
static from(webSocket) {
|
||||
return webSocket._object;
|
||||
}
|
||||
constructor(parent, type, guid, initializer) {
|
||||
super(parent, type, guid, initializer);
|
||||
this._page = void 0;
|
||||
this._isClosed = void 0;
|
||||
this._isClosed = false;
|
||||
this._page = parent;
|
||||
this._channel.on('frameSent', event => {
|
||||
if (event.opcode === 1) this.emit(_events.Events.WebSocket.FrameSent, {
|
||||
payload: event.data
|
||||
});else if (event.opcode === 2) this.emit(_events.Events.WebSocket.FrameSent, {
|
||||
payload: Buffer.from(event.data, 'base64')
|
||||
});
|
||||
});
|
||||
this._channel.on('frameReceived', event => {
|
||||
if (event.opcode === 1) this.emit(_events.Events.WebSocket.FrameReceived, {
|
||||
payload: event.data
|
||||
});else if (event.opcode === 2) this.emit(_events.Events.WebSocket.FrameReceived, {
|
||||
payload: Buffer.from(event.data, 'base64')
|
||||
});
|
||||
});
|
||||
this._channel.on('socketError', ({
|
||||
error
|
||||
}) => this.emit(_events.Events.WebSocket.Error, error));
|
||||
this._channel.on('close', () => {
|
||||
this._isClosed = true;
|
||||
this.emit(_events.Events.WebSocket.Close, this);
|
||||
});
|
||||
}
|
||||
url() {
|
||||
return this._initializer.url;
|
||||
}
|
||||
isClosed() {
|
||||
return this._isClosed;
|
||||
}
|
||||
async waitForEvent(event, optionsOrPredicate = {}) {
|
||||
return this._wrapApiCall(async () => {
|
||||
const timeout = this._page._timeoutSettings.timeout(typeof optionsOrPredicate === 'function' ? {} : optionsOrPredicate);
|
||||
const predicate = typeof optionsOrPredicate === 'function' ? optionsOrPredicate : optionsOrPredicate.predicate;
|
||||
const waiter = _waiter.Waiter.createForEvent(this, event);
|
||||
waiter.rejectOnTimeout(timeout, `Timeout ${timeout}ms exceeded while waiting for event "${event}"`);
|
||||
if (event !== _events.Events.WebSocket.Error) waiter.rejectOnEvent(this, _events.Events.WebSocket.Error, new Error('Socket error'));
|
||||
if (event !== _events.Events.WebSocket.Close) waiter.rejectOnEvent(this, _events.Events.WebSocket.Close, new Error('Socket closed'));
|
||||
waiter.rejectOnEvent(this._page, _events.Events.Page.Close, new Error('Page closed'));
|
||||
const result = await waiter.waitForEvent(this, event, predicate);
|
||||
waiter.dispose();
|
||||
return result;
|
||||
});
|
||||
}
|
||||
}
|
||||
exports.WebSocket = WebSocket;
|
||||
function validateHeaders(headers) {
|
||||
for (const key of Object.keys(headers)) {
|
||||
const value = headers[key];
|
||||
if (!Object.is(value, undefined) && !(0, _utils.isString)(value)) throw new Error(`Expected value of header "${key}" to be String, but "${typeof value}" is found.`);
|
||||
}
|
||||
}
|
||||
class RouteHandler {
|
||||
constructor(baseURL, url, handler, times = Number.MAX_SAFE_INTEGER) {
|
||||
this.handledCount = 0;
|
||||
this._baseURL = void 0;
|
||||
this._times = void 0;
|
||||
this.url = void 0;
|
||||
this.handler = void 0;
|
||||
this._baseURL = baseURL;
|
||||
this._times = times;
|
||||
this.url = url;
|
||||
this.handler = handler;
|
||||
}
|
||||
static prepareInterceptionPatterns(handlers) {
|
||||
const patterns = [];
|
||||
let all = false;
|
||||
for (const handler of handlers) {
|
||||
if ((0, _utils.isString)(handler.url)) patterns.push({
|
||||
glob: handler.url
|
||||
});else if ((0, _utils.isRegExp)(handler.url)) patterns.push({
|
||||
regexSource: handler.url.source,
|
||||
regexFlags: handler.url.flags
|
||||
});else all = true;
|
||||
}
|
||||
if (all) return [{
|
||||
glob: '**/*'
|
||||
}];
|
||||
return patterns;
|
||||
}
|
||||
matches(requestURL) {
|
||||
return (0, _network.urlMatches)(this._baseURL, requestURL, this.url);
|
||||
}
|
||||
async handle(route) {
|
||||
++this.handledCount;
|
||||
const handledPromise = route._startHandling();
|
||||
// Extract handler into a variable to avoid [RouteHandler.handler] in the stack.
|
||||
const handler = this.handler;
|
||||
const [handled] = await Promise.all([handledPromise, handler(route, route.request())]);
|
||||
return handled;
|
||||
}
|
||||
willExpire() {
|
||||
return this.handledCount + 1 >= this._times;
|
||||
}
|
||||
}
|
||||
exports.RouteHandler = RouteHandler;
|
||||
class RawHeaders {
|
||||
static _fromHeadersObjectLossy(headers) {
|
||||
const headersArray = Object.entries(headers).map(([name, value]) => ({
|
||||
name,
|
||||
value
|
||||
})).filter(header => header.value !== undefined);
|
||||
return new RawHeaders(headersArray);
|
||||
}
|
||||
constructor(headers) {
|
||||
this._headersArray = void 0;
|
||||
this._headersMap = new _multimap.MultiMap();
|
||||
this._headersArray = headers;
|
||||
for (const header of headers) this._headersMap.set(header.name.toLowerCase(), header.value);
|
||||
}
|
||||
get(name) {
|
||||
const values = this.getAll(name);
|
||||
if (!values || !values.length) return null;
|
||||
return values.join(name.toLowerCase() === 'set-cookie' ? '\n' : ', ');
|
||||
}
|
||||
getAll(name) {
|
||||
return [...this._headersMap.get(name.toLowerCase())];
|
||||
}
|
||||
headers() {
|
||||
const result = {};
|
||||
for (const name of this._headersMap.keys()) result[name] = this.get(name);
|
||||
return result;
|
||||
}
|
||||
headersArray() {
|
||||
return this._headersArray;
|
||||
}
|
||||
}
|
||||
exports.RawHeaders = RawHeaders;
|
||||
655
bin/pac/tools/.playwright/package/lib/client/page.js
Normal file
655
bin/pac/tools/.playwright/package/lib/client/page.js
Normal file
@@ -0,0 +1,655 @@
|
||||
"use strict";
|
||||
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
exports.Page = exports.BindingCall = void 0;
|
||||
var _fs = _interopRequireDefault(require("fs"));
|
||||
var _path = _interopRequireDefault(require("path"));
|
||||
var _errors = require("../common/errors");
|
||||
var _network = require("../utils/network");
|
||||
var _timeoutSettings = require("../common/timeoutSettings");
|
||||
var _serializers = require("../protocol/serializers");
|
||||
var _utils = require("../utils");
|
||||
var _fileUtils = require("../utils/fileUtils");
|
||||
var _accessibility = require("./accessibility");
|
||||
var _artifact = require("./artifact");
|
||||
var _channelOwner = require("./channelOwner");
|
||||
var _clientHelper = require("./clientHelper");
|
||||
var _coverage = require("./coverage");
|
||||
var _download = require("./download");
|
||||
var _elementHandle = require("./elementHandle");
|
||||
var _events = require("./events");
|
||||
var _fileChooser = require("./fileChooser");
|
||||
var _frame = require("./frame");
|
||||
var _input = require("./input");
|
||||
var _jsHandle = require("./jsHandle");
|
||||
var _network2 = require("./network");
|
||||
var _video = require("./video");
|
||||
var _waiter = require("./waiter");
|
||||
var _worker = require("./worker");
|
||||
var _harRouter = require("./harRouter");
|
||||
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
||||
/**
|
||||
* Copyright 2017 Google Inc. All rights reserved.
|
||||
* Modifications copyright (c) Microsoft Corporation.
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
class Page extends _channelOwner.ChannelOwner {
|
||||
static from(page) {
|
||||
return page._object;
|
||||
}
|
||||
static fromNullable(page) {
|
||||
return page ? Page.from(page) : null;
|
||||
}
|
||||
constructor(parent, type, guid, initializer) {
|
||||
super(parent, type, guid, initializer);
|
||||
this._browserContext = void 0;
|
||||
this._ownedContext = void 0;
|
||||
this._mainFrame = void 0;
|
||||
this._frames = new Set();
|
||||
this._workers = new Set();
|
||||
this._closed = false;
|
||||
this._closedOrCrashedRace = new _utils.ScopedRace();
|
||||
this._viewportSize = void 0;
|
||||
this._routes = [];
|
||||
this.accessibility = void 0;
|
||||
this.coverage = void 0;
|
||||
this.keyboard = void 0;
|
||||
this.mouse = void 0;
|
||||
this.request = void 0;
|
||||
this.touchscreen = void 0;
|
||||
this._bindings = new Map();
|
||||
this._timeoutSettings = void 0;
|
||||
this._video = null;
|
||||
this._opener = void 0;
|
||||
this._browserContext = parent;
|
||||
this._timeoutSettings = new _timeoutSettings.TimeoutSettings(this._browserContext._timeoutSettings);
|
||||
this.accessibility = new _accessibility.Accessibility(this._channel);
|
||||
this.keyboard = new _input.Keyboard(this);
|
||||
this.mouse = new _input.Mouse(this);
|
||||
this.request = this._browserContext.request;
|
||||
this.touchscreen = new _input.Touchscreen(this);
|
||||
this._mainFrame = _frame.Frame.from(initializer.mainFrame);
|
||||
this._mainFrame._page = this;
|
||||
this._frames.add(this._mainFrame);
|
||||
this._viewportSize = initializer.viewportSize || null;
|
||||
this._closed = initializer.isClosed;
|
||||
this._opener = Page.fromNullable(initializer.opener);
|
||||
this._channel.on('bindingCall', ({
|
||||
binding
|
||||
}) => this._onBinding(BindingCall.from(binding)));
|
||||
this._channel.on('close', () => this._onClose());
|
||||
this._channel.on('crash', () => this._onCrash());
|
||||
this._channel.on('download', ({
|
||||
url,
|
||||
suggestedFilename,
|
||||
artifact
|
||||
}) => {
|
||||
const artifactObject = _artifact.Artifact.from(artifact);
|
||||
this.emit(_events.Events.Page.Download, new _download.Download(this, url, suggestedFilename, artifactObject));
|
||||
});
|
||||
this._channel.on('fileChooser', ({
|
||||
element,
|
||||
isMultiple
|
||||
}) => this.emit(_events.Events.Page.FileChooser, new _fileChooser.FileChooser(this, _elementHandle.ElementHandle.from(element), isMultiple)));
|
||||
this._channel.on('frameAttached', ({
|
||||
frame
|
||||
}) => this._onFrameAttached(_frame.Frame.from(frame)));
|
||||
this._channel.on('frameDetached', ({
|
||||
frame
|
||||
}) => this._onFrameDetached(_frame.Frame.from(frame)));
|
||||
this._channel.on('pageError', ({
|
||||
error
|
||||
}) => this.emit(_events.Events.Page.PageError, (0, _serializers.parseError)(error)));
|
||||
this._channel.on('route', ({
|
||||
route
|
||||
}) => this._onRoute(_network2.Route.from(route)));
|
||||
this._channel.on('video', ({
|
||||
artifact
|
||||
}) => {
|
||||
const artifactObject = _artifact.Artifact.from(artifact);
|
||||
this._forceVideo()._artifactReady(artifactObject);
|
||||
});
|
||||
this._channel.on('webSocket', ({
|
||||
webSocket
|
||||
}) => this.emit(_events.Events.Page.WebSocket, _network2.WebSocket.from(webSocket)));
|
||||
this._channel.on('worker', ({
|
||||
worker
|
||||
}) => this._onWorker(_worker.Worker.from(worker)));
|
||||
this.coverage = new _coverage.Coverage(this._channel);
|
||||
this.once(_events.Events.Page.Close, () => this._closedOrCrashedRace.scopeClosed(new Error(_errors.kBrowserOrContextClosedError)));
|
||||
this.once(_events.Events.Page.Crash, () => this._closedOrCrashedRace.scopeClosed(new Error(_errors.kBrowserOrContextClosedError)));
|
||||
this._setEventToSubscriptionMapping(new Map([[_events.Events.Page.Console, 'console'], [_events.Events.Page.Dialog, 'dialog'], [_events.Events.Page.Request, 'request'], [_events.Events.Page.Response, 'response'], [_events.Events.Page.RequestFinished, 'requestFinished'], [_events.Events.Page.RequestFailed, 'requestFailed'], [_events.Events.Page.FileChooser, 'fileChooser']]));
|
||||
}
|
||||
_onFrameAttached(frame) {
|
||||
frame._page = this;
|
||||
this._frames.add(frame);
|
||||
if (frame._parentFrame) frame._parentFrame._childFrames.add(frame);
|
||||
this.emit(_events.Events.Page.FrameAttached, frame);
|
||||
}
|
||||
_onFrameDetached(frame) {
|
||||
this._frames.delete(frame);
|
||||
frame._detached = true;
|
||||
if (frame._parentFrame) frame._parentFrame._childFrames.delete(frame);
|
||||
this.emit(_events.Events.Page.FrameDetached, frame);
|
||||
}
|
||||
async _onRoute(route) {
|
||||
const routeHandlers = this._routes.slice();
|
||||
for (const routeHandler of routeHandlers) {
|
||||
if (!routeHandler.matches(route.request().url())) continue;
|
||||
if (routeHandler.willExpire()) this._routes.splice(this._routes.indexOf(routeHandler), 1);
|
||||
const handled = await routeHandler.handle(route);
|
||||
if (!this._routes.length) this._wrapApiCall(() => this._updateInterceptionPatterns(), true).catch(() => {});
|
||||
if (handled) return;
|
||||
}
|
||||
await this._browserContext._onRoute(route);
|
||||
}
|
||||
async _onBinding(bindingCall) {
|
||||
const func = this._bindings.get(bindingCall._initializer.name);
|
||||
if (func) {
|
||||
await bindingCall.call(func);
|
||||
return;
|
||||
}
|
||||
await this._browserContext._onBinding(bindingCall);
|
||||
}
|
||||
_onWorker(worker) {
|
||||
this._workers.add(worker);
|
||||
worker._page = this;
|
||||
this.emit(_events.Events.Page.Worker, worker);
|
||||
}
|
||||
_onClose() {
|
||||
this._closed = true;
|
||||
this._browserContext._pages.delete(this);
|
||||
this._browserContext._backgroundPages.delete(this);
|
||||
this.emit(_events.Events.Page.Close, this);
|
||||
}
|
||||
_onCrash() {
|
||||
this.emit(_events.Events.Page.Crash, this);
|
||||
}
|
||||
context() {
|
||||
return this._browserContext;
|
||||
}
|
||||
async opener() {
|
||||
if (!this._opener || this._opener.isClosed()) return null;
|
||||
return this._opener;
|
||||
}
|
||||
mainFrame() {
|
||||
return this._mainFrame;
|
||||
}
|
||||
frame(frameSelector) {
|
||||
const name = (0, _utils.isString)(frameSelector) ? frameSelector : frameSelector.name;
|
||||
const url = (0, _utils.isObject)(frameSelector) ? frameSelector.url : undefined;
|
||||
(0, _utils.assert)(name || url, 'Either name or url matcher should be specified');
|
||||
return this.frames().find(f => {
|
||||
if (name) return f.name() === name;
|
||||
return (0, _network.urlMatches)(this._browserContext._options.baseURL, f.url(), url);
|
||||
}) || null;
|
||||
}
|
||||
frames() {
|
||||
return [...this._frames];
|
||||
}
|
||||
setDefaultNavigationTimeout(timeout) {
|
||||
this._timeoutSettings.setDefaultNavigationTimeout(timeout);
|
||||
this._wrapApiCall(async () => {
|
||||
this._channel.setDefaultNavigationTimeoutNoReply({
|
||||
timeout
|
||||
}).catch(() => {});
|
||||
}, true);
|
||||
}
|
||||
setDefaultTimeout(timeout) {
|
||||
this._timeoutSettings.setDefaultTimeout(timeout);
|
||||
this._wrapApiCall(async () => {
|
||||
this._channel.setDefaultTimeoutNoReply({
|
||||
timeout
|
||||
}).catch(() => {});
|
||||
}, true);
|
||||
}
|
||||
_forceVideo() {
|
||||
if (!this._video) this._video = new _video.Video(this, this._connection);
|
||||
return this._video;
|
||||
}
|
||||
video() {
|
||||
// Note: we are creating Video object lazily, because we do not know
|
||||
// BrowserContextOptions when constructing the page - it is assigned
|
||||
// too late during launchPersistentContext.
|
||||
if (!this._browserContext._options.recordVideo) return null;
|
||||
return this._forceVideo();
|
||||
}
|
||||
async $(selector, options) {
|
||||
return this._mainFrame.$(selector, options);
|
||||
}
|
||||
async waitForSelector(selector, options) {
|
||||
return this._mainFrame.waitForSelector(selector, options);
|
||||
}
|
||||
async dispatchEvent(selector, type, eventInit, options) {
|
||||
return this._mainFrame.dispatchEvent(selector, type, eventInit, options);
|
||||
}
|
||||
async evaluateHandle(pageFunction, arg) {
|
||||
(0, _jsHandle.assertMaxArguments)(arguments.length, 2);
|
||||
return this._mainFrame.evaluateHandle(pageFunction, arg);
|
||||
}
|
||||
async $eval(selector, pageFunction, arg) {
|
||||
(0, _jsHandle.assertMaxArguments)(arguments.length, 3);
|
||||
return this._mainFrame.$eval(selector, pageFunction, arg);
|
||||
}
|
||||
async $$eval(selector, pageFunction, arg) {
|
||||
(0, _jsHandle.assertMaxArguments)(arguments.length, 3);
|
||||
return this._mainFrame.$$eval(selector, pageFunction, arg);
|
||||
}
|
||||
async $$(selector) {
|
||||
return this._mainFrame.$$(selector);
|
||||
}
|
||||
async addScriptTag(options = {}) {
|
||||
return this._mainFrame.addScriptTag(options);
|
||||
}
|
||||
async addStyleTag(options = {}) {
|
||||
return this._mainFrame.addStyleTag(options);
|
||||
}
|
||||
async exposeFunction(name, callback) {
|
||||
await this._channel.exposeBinding({
|
||||
name
|
||||
});
|
||||
const binding = (source, ...args) => callback(...args);
|
||||
this._bindings.set(name, binding);
|
||||
}
|
||||
async exposeBinding(name, callback, options = {}) {
|
||||
await this._channel.exposeBinding({
|
||||
name,
|
||||
needsHandle: options.handle
|
||||
});
|
||||
this._bindings.set(name, callback);
|
||||
}
|
||||
async setExtraHTTPHeaders(headers) {
|
||||
(0, _network2.validateHeaders)(headers);
|
||||
await this._channel.setExtraHTTPHeaders({
|
||||
headers: (0, _utils.headersObjectToArray)(headers)
|
||||
});
|
||||
}
|
||||
url() {
|
||||
return this._mainFrame.url();
|
||||
}
|
||||
async content() {
|
||||
return this._mainFrame.content();
|
||||
}
|
||||
async setContent(html, options) {
|
||||
return this._mainFrame.setContent(html, options);
|
||||
}
|
||||
async goto(url, options) {
|
||||
return this._mainFrame.goto(url, options);
|
||||
}
|
||||
async reload(options = {}) {
|
||||
const waitUntil = (0, _frame.verifyLoadState)('waitUntil', options.waitUntil === undefined ? 'load' : options.waitUntil);
|
||||
return _network2.Response.fromNullable((await this._channel.reload({
|
||||
...options,
|
||||
waitUntil
|
||||
})).response);
|
||||
}
|
||||
async waitForLoadState(state, options) {
|
||||
return this._mainFrame.waitForLoadState(state, options);
|
||||
}
|
||||
async waitForNavigation(options) {
|
||||
return this._mainFrame.waitForNavigation(options);
|
||||
}
|
||||
async waitForURL(url, options) {
|
||||
return this._mainFrame.waitForURL(url, options);
|
||||
}
|
||||
async waitForRequest(urlOrPredicate, options = {}) {
|
||||
const predicate = request => {
|
||||
if ((0, _utils.isString)(urlOrPredicate) || (0, _utils.isRegExp)(urlOrPredicate)) return (0, _network.urlMatches)(this._browserContext._options.baseURL, request.url(), urlOrPredicate);
|
||||
return urlOrPredicate(request);
|
||||
};
|
||||
const trimmedUrl = trimUrl(urlOrPredicate);
|
||||
const logLine = trimmedUrl ? `waiting for request ${trimmedUrl}` : undefined;
|
||||
return this._waitForEvent(_events.Events.Page.Request, {
|
||||
predicate,
|
||||
timeout: options.timeout
|
||||
}, logLine);
|
||||
}
|
||||
async waitForResponse(urlOrPredicate, options = {}) {
|
||||
const predicate = response => {
|
||||
if ((0, _utils.isString)(urlOrPredicate) || (0, _utils.isRegExp)(urlOrPredicate)) return (0, _network.urlMatches)(this._browserContext._options.baseURL, response.url(), urlOrPredicate);
|
||||
return urlOrPredicate(response);
|
||||
};
|
||||
const trimmedUrl = trimUrl(urlOrPredicate);
|
||||
const logLine = trimmedUrl ? `waiting for response ${trimmedUrl}` : undefined;
|
||||
return this._waitForEvent(_events.Events.Page.Response, {
|
||||
predicate,
|
||||
timeout: options.timeout
|
||||
}, logLine);
|
||||
}
|
||||
async waitForEvent(event, optionsOrPredicate = {}) {
|
||||
return this._waitForEvent(event, optionsOrPredicate, `waiting for event "${event}"`);
|
||||
}
|
||||
async _waitForEvent(event, optionsOrPredicate, logLine) {
|
||||
return this._wrapApiCall(async () => {
|
||||
const timeout = this._timeoutSettings.timeout(typeof optionsOrPredicate === 'function' ? {} : optionsOrPredicate);
|
||||
const predicate = typeof optionsOrPredicate === 'function' ? optionsOrPredicate : optionsOrPredicate.predicate;
|
||||
const waiter = _waiter.Waiter.createForEvent(this, event);
|
||||
if (logLine) waiter.log(logLine);
|
||||
waiter.rejectOnTimeout(timeout, `Timeout ${timeout}ms exceeded while waiting for event "${event}"`);
|
||||
if (event !== _events.Events.Page.Crash) waiter.rejectOnEvent(this, _events.Events.Page.Crash, new Error('Page crashed'));
|
||||
if (event !== _events.Events.Page.Close) waiter.rejectOnEvent(this, _events.Events.Page.Close, new Error('Page closed'));
|
||||
const result = await waiter.waitForEvent(this, event, predicate);
|
||||
waiter.dispose();
|
||||
return result;
|
||||
});
|
||||
}
|
||||
async goBack(options = {}) {
|
||||
const waitUntil = (0, _frame.verifyLoadState)('waitUntil', options.waitUntil === undefined ? 'load' : options.waitUntil);
|
||||
return _network2.Response.fromNullable((await this._channel.goBack({
|
||||
...options,
|
||||
waitUntil
|
||||
})).response);
|
||||
}
|
||||
async goForward(options = {}) {
|
||||
const waitUntil = (0, _frame.verifyLoadState)('waitUntil', options.waitUntil === undefined ? 'load' : options.waitUntil);
|
||||
return _network2.Response.fromNullable((await this._channel.goForward({
|
||||
...options,
|
||||
waitUntil
|
||||
})).response);
|
||||
}
|
||||
async emulateMedia(options = {}) {
|
||||
await this._channel.emulateMedia({
|
||||
media: options.media === null ? 'no-override' : options.media,
|
||||
colorScheme: options.colorScheme === null ? 'no-override' : options.colorScheme,
|
||||
reducedMotion: options.reducedMotion === null ? 'no-override' : options.reducedMotion,
|
||||
forcedColors: options.forcedColors === null ? 'no-override' : options.forcedColors
|
||||
});
|
||||
}
|
||||
async setViewportSize(viewportSize) {
|
||||
this._viewportSize = viewportSize;
|
||||
await this._channel.setViewportSize({
|
||||
viewportSize
|
||||
});
|
||||
}
|
||||
viewportSize() {
|
||||
return this._viewportSize;
|
||||
}
|
||||
async evaluate(pageFunction, arg) {
|
||||
(0, _jsHandle.assertMaxArguments)(arguments.length, 2);
|
||||
return this._mainFrame.evaluate(pageFunction, arg);
|
||||
}
|
||||
async addInitScript(script, arg) {
|
||||
const source = await (0, _clientHelper.evaluationScript)(script, arg);
|
||||
await this._channel.addInitScript({
|
||||
source
|
||||
});
|
||||
}
|
||||
async route(url, handler, options = {}) {
|
||||
this._routes.unshift(new _network2.RouteHandler(this._browserContext._options.baseURL, url, handler, options.times));
|
||||
await this._updateInterceptionPatterns();
|
||||
}
|
||||
async routeFromHAR(har, options = {}) {
|
||||
if (options.update) {
|
||||
await this._browserContext._recordIntoHAR(har, this, options);
|
||||
return;
|
||||
}
|
||||
const harRouter = await _harRouter.HarRouter.create(this._connection.localUtils(), har, options.notFound || 'abort', {
|
||||
urlMatch: options.url
|
||||
});
|
||||
harRouter.addPageRoute(this);
|
||||
}
|
||||
async unroute(url, handler) {
|
||||
this._routes = this._routes.filter(route => !(0, _utils.urlMatchesEqual)(route.url, url) || handler && route.handler !== handler);
|
||||
await this._updateInterceptionPatterns();
|
||||
}
|
||||
async _updateInterceptionPatterns() {
|
||||
const patterns = _network2.RouteHandler.prepareInterceptionPatterns(this._routes);
|
||||
await this._channel.setNetworkInterceptionPatterns({
|
||||
patterns
|
||||
});
|
||||
}
|
||||
async screenshot(options = {}) {
|
||||
const copy = {
|
||||
...options,
|
||||
mask: undefined
|
||||
};
|
||||
if (!copy.type) copy.type = (0, _elementHandle.determineScreenshotType)(options);
|
||||
if (options.mask) {
|
||||
copy.mask = options.mask.map(locator => ({
|
||||
frame: locator._frame._channel,
|
||||
selector: locator._selector
|
||||
}));
|
||||
}
|
||||
const result = await this._channel.screenshot(copy);
|
||||
if (options.path) {
|
||||
await (0, _fileUtils.mkdirIfNeeded)(options.path);
|
||||
await _fs.default.promises.writeFile(options.path, result.binary);
|
||||
}
|
||||
return result.binary;
|
||||
}
|
||||
async _expectScreenshot(options) {
|
||||
var _options$screenshotOp, _options$screenshotOp2;
|
||||
const mask = (_options$screenshotOp = options.screenshotOptions) !== null && _options$screenshotOp !== void 0 && _options$screenshotOp.mask ? (_options$screenshotOp2 = options.screenshotOptions) === null || _options$screenshotOp2 === void 0 ? void 0 : _options$screenshotOp2.mask.map(locator => ({
|
||||
frame: locator._frame._channel,
|
||||
selector: locator._selector
|
||||
})) : undefined;
|
||||
const locator = options.locator ? {
|
||||
frame: options.locator._frame._channel,
|
||||
selector: options.locator._selector
|
||||
} : undefined;
|
||||
return await this._channel.expectScreenshot({
|
||||
...options,
|
||||
isNot: !!options.isNot,
|
||||
locator,
|
||||
screenshotOptions: {
|
||||
...options.screenshotOptions,
|
||||
mask
|
||||
}
|
||||
});
|
||||
}
|
||||
async title() {
|
||||
return this._mainFrame.title();
|
||||
}
|
||||
async bringToFront() {
|
||||
await this._channel.bringToFront();
|
||||
}
|
||||
async close(options = {
|
||||
runBeforeUnload: undefined
|
||||
}) {
|
||||
try {
|
||||
if (this._ownedContext) await this._ownedContext.close();else await this._channel.close(options);
|
||||
} catch (e) {
|
||||
if ((0, _errors.isSafeCloseError)(e) && !options.runBeforeUnload) return;
|
||||
throw e;
|
||||
}
|
||||
}
|
||||
isClosed() {
|
||||
return this._closed;
|
||||
}
|
||||
async click(selector, options) {
|
||||
return this._mainFrame.click(selector, options);
|
||||
}
|
||||
async dragAndDrop(source, target, options) {
|
||||
return this._mainFrame.dragAndDrop(source, target, options);
|
||||
}
|
||||
async dblclick(selector, options) {
|
||||
return this._mainFrame.dblclick(selector, options);
|
||||
}
|
||||
async tap(selector, options) {
|
||||
return this._mainFrame.tap(selector, options);
|
||||
}
|
||||
async fill(selector, value, options) {
|
||||
return this._mainFrame.fill(selector, value, options);
|
||||
}
|
||||
locator(selector, options) {
|
||||
return this.mainFrame().locator(selector, options);
|
||||
}
|
||||
getByTestId(testId) {
|
||||
return this.mainFrame().getByTestId(testId);
|
||||
}
|
||||
getByAltText(text, options) {
|
||||
return this.mainFrame().getByAltText(text, options);
|
||||
}
|
||||
getByLabel(text, options) {
|
||||
return this.mainFrame().getByLabel(text, options);
|
||||
}
|
||||
getByPlaceholder(text, options) {
|
||||
return this.mainFrame().getByPlaceholder(text, options);
|
||||
}
|
||||
getByText(text, options) {
|
||||
return this.mainFrame().getByText(text, options);
|
||||
}
|
||||
getByTitle(text, options) {
|
||||
return this.mainFrame().getByTitle(text, options);
|
||||
}
|
||||
getByRole(role, options = {}) {
|
||||
return this.mainFrame().getByRole(role, options);
|
||||
}
|
||||
frameLocator(selector) {
|
||||
return this.mainFrame().frameLocator(selector);
|
||||
}
|
||||
async focus(selector, options) {
|
||||
return this._mainFrame.focus(selector, options);
|
||||
}
|
||||
async textContent(selector, options) {
|
||||
return this._mainFrame.textContent(selector, options);
|
||||
}
|
||||
async innerText(selector, options) {
|
||||
return this._mainFrame.innerText(selector, options);
|
||||
}
|
||||
async innerHTML(selector, options) {
|
||||
return this._mainFrame.innerHTML(selector, options);
|
||||
}
|
||||
async getAttribute(selector, name, options) {
|
||||
return this._mainFrame.getAttribute(selector, name, options);
|
||||
}
|
||||
async inputValue(selector, options) {
|
||||
return this._mainFrame.inputValue(selector, options);
|
||||
}
|
||||
async isChecked(selector, options) {
|
||||
return this._mainFrame.isChecked(selector, options);
|
||||
}
|
||||
async isDisabled(selector, options) {
|
||||
return this._mainFrame.isDisabled(selector, options);
|
||||
}
|
||||
async isEditable(selector, options) {
|
||||
return this._mainFrame.isEditable(selector, options);
|
||||
}
|
||||
async isEnabled(selector, options) {
|
||||
return this._mainFrame.isEnabled(selector, options);
|
||||
}
|
||||
async isHidden(selector, options) {
|
||||
return this._mainFrame.isHidden(selector, options);
|
||||
}
|
||||
async isVisible(selector, options) {
|
||||
return this._mainFrame.isVisible(selector, options);
|
||||
}
|
||||
async hover(selector, options) {
|
||||
return this._mainFrame.hover(selector, options);
|
||||
}
|
||||
async selectOption(selector, values, options) {
|
||||
return this._mainFrame.selectOption(selector, values, options);
|
||||
}
|
||||
async setInputFiles(selector, files, options) {
|
||||
return this._mainFrame.setInputFiles(selector, files, options);
|
||||
}
|
||||
async type(selector, text, options) {
|
||||
return this._mainFrame.type(selector, text, options);
|
||||
}
|
||||
async press(selector, key, options) {
|
||||
return this._mainFrame.press(selector, key, options);
|
||||
}
|
||||
async check(selector, options) {
|
||||
return this._mainFrame.check(selector, options);
|
||||
}
|
||||
async uncheck(selector, options) {
|
||||
return this._mainFrame.uncheck(selector, options);
|
||||
}
|
||||
async setChecked(selector, checked, options) {
|
||||
return this._mainFrame.setChecked(selector, checked, options);
|
||||
}
|
||||
async waitForTimeout(timeout) {
|
||||
return this._mainFrame.waitForTimeout(timeout);
|
||||
}
|
||||
async waitForFunction(pageFunction, arg, options) {
|
||||
return this._mainFrame.waitForFunction(pageFunction, arg, options);
|
||||
}
|
||||
workers() {
|
||||
return [...this._workers];
|
||||
}
|
||||
async pause() {
|
||||
var _this$_instrumentatio;
|
||||
if (require('inspector').url()) return;
|
||||
const defaultNavigationTimeout = this._browserContext._timeoutSettings.defaultNavigationTimeout();
|
||||
const defaultTimeout = this._browserContext._timeoutSettings.defaultTimeout();
|
||||
this._browserContext.setDefaultNavigationTimeout(0);
|
||||
this._browserContext.setDefaultTimeout(0);
|
||||
(_this$_instrumentatio = this._instrumentation) === null || _this$_instrumentatio === void 0 ? void 0 : _this$_instrumentatio.onWillPause();
|
||||
await this._closedOrCrashedRace.safeRace(this.context()._channel.pause());
|
||||
this._browserContext.setDefaultNavigationTimeout(defaultNavigationTimeout);
|
||||
this._browserContext.setDefaultTimeout(defaultTimeout);
|
||||
}
|
||||
async pdf(options = {}) {
|
||||
const transportOptions = {
|
||||
...options
|
||||
};
|
||||
if (transportOptions.margin) transportOptions.margin = {
|
||||
...transportOptions.margin
|
||||
};
|
||||
if (typeof options.width === 'number') transportOptions.width = options.width + 'px';
|
||||
if (typeof options.height === 'number') transportOptions.height = options.height + 'px';
|
||||
for (const margin of ['top', 'right', 'bottom', 'left']) {
|
||||
const index = margin;
|
||||
if (options.margin && typeof options.margin[index] === 'number') transportOptions.margin[index] = transportOptions.margin[index] + 'px';
|
||||
}
|
||||
const result = await this._channel.pdf(transportOptions);
|
||||
if (options.path) {
|
||||
await _fs.default.promises.mkdir(_path.default.dirname(options.path), {
|
||||
recursive: true
|
||||
});
|
||||
await _fs.default.promises.writeFile(options.path, result.pdf);
|
||||
}
|
||||
return result.pdf;
|
||||
}
|
||||
}
|
||||
exports.Page = Page;
|
||||
class BindingCall extends _channelOwner.ChannelOwner {
|
||||
static from(channel) {
|
||||
return channel._object;
|
||||
}
|
||||
constructor(parent, type, guid, initializer) {
|
||||
super(parent, type, guid, initializer);
|
||||
}
|
||||
async call(func) {
|
||||
try {
|
||||
const frame = _frame.Frame.from(this._initializer.frame);
|
||||
const source = {
|
||||
context: frame._page.context(),
|
||||
page: frame._page,
|
||||
frame
|
||||
};
|
||||
let result;
|
||||
if (this._initializer.handle) result = await func(source, _jsHandle.JSHandle.from(this._initializer.handle));else result = await func(source, ...this._initializer.args.map(_jsHandle.parseResult));
|
||||
this._channel.resolve({
|
||||
result: (0, _jsHandle.serializeArgument)(result)
|
||||
}).catch(() => {});
|
||||
} catch (e) {
|
||||
this._channel.reject({
|
||||
error: (0, _serializers.serializeError)(e)
|
||||
}).catch(() => {});
|
||||
}
|
||||
}
|
||||
}
|
||||
exports.BindingCall = BindingCall;
|
||||
function trimEnd(s) {
|
||||
if (s.length > 50) s = s.substring(0, 50) + '\u2026';
|
||||
return s;
|
||||
}
|
||||
function trimUrl(param) {
|
||||
if ((0, _utils.isRegExp)(param)) return `/${trimEnd(param.source)}/${param.flags}`;
|
||||
if ((0, _utils.isString)(param)) return `"${trimEnd(param)}"`;
|
||||
}
|
||||
77
bin/pac/tools/.playwright/package/lib/client/playwright.js
Normal file
77
bin/pac/tools/.playwright/package/lib/client/playwright.js
Normal file
@@ -0,0 +1,77 @@
|
||||
"use strict";
|
||||
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
exports.Playwright = void 0;
|
||||
var _errors = require("../common/errors");
|
||||
var _android = require("./android");
|
||||
var _browserType = require("./browserType");
|
||||
var _channelOwner = require("./channelOwner");
|
||||
var _electron = require("./electron");
|
||||
var _fetch = require("./fetch");
|
||||
var _selectors = require("./selectors");
|
||||
/**
|
||||
* Copyright (c) Microsoft Corporation.
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
class Playwright extends _channelOwner.ChannelOwner {
|
||||
constructor(parent, type, guid, initializer) {
|
||||
super(parent, type, guid, initializer);
|
||||
this._android = void 0;
|
||||
this._electron = void 0;
|
||||
this.chromium = void 0;
|
||||
this.firefox = void 0;
|
||||
this.webkit = void 0;
|
||||
this.devices = void 0;
|
||||
this.selectors = void 0;
|
||||
this.request = void 0;
|
||||
this.errors = void 0;
|
||||
this.request = new _fetch.APIRequest(this);
|
||||
this.chromium = _browserType.BrowserType.from(initializer.chromium);
|
||||
this.chromium._playwright = this;
|
||||
this.firefox = _browserType.BrowserType.from(initializer.firefox);
|
||||
this.firefox._playwright = this;
|
||||
this.webkit = _browserType.BrowserType.from(initializer.webkit);
|
||||
this.webkit._playwright = this;
|
||||
this._android = _android.Android.from(initializer.android);
|
||||
this._electron = _electron.Electron.from(initializer.electron);
|
||||
this.devices = {};
|
||||
for (const {
|
||||
name,
|
||||
descriptor
|
||||
} of initializer.deviceDescriptors) this.devices[name] = descriptor;
|
||||
this.selectors = new _selectors.Selectors();
|
||||
this.errors = {
|
||||
TimeoutError: _errors.TimeoutError
|
||||
};
|
||||
const selectorsOwner = _selectors.SelectorsOwner.from(initializer.selectors);
|
||||
this.selectors._addChannel(selectorsOwner);
|
||||
this._connection.on('close', () => {
|
||||
this.selectors._removeChannel(selectorsOwner);
|
||||
});
|
||||
global._playwrightInstance = this;
|
||||
}
|
||||
_setSelectors(selectors) {
|
||||
const selectorsOwner = _selectors.SelectorsOwner.from(this._initializer.selectors);
|
||||
this.selectors._removeChannel(selectorsOwner);
|
||||
this.selectors = selectors;
|
||||
this.selectors._addChannel(selectorsOwner);
|
||||
}
|
||||
static from(channel) {
|
||||
return channel._object;
|
||||
}
|
||||
}
|
||||
exports.Playwright = Playwright;
|
||||
67
bin/pac/tools/.playwright/package/lib/client/selectors.js
Normal file
67
bin/pac/tools/.playwright/package/lib/client/selectors.js
Normal file
@@ -0,0 +1,67 @@
|
||||
"use strict";
|
||||
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
exports.SelectorsOwner = exports.Selectors = void 0;
|
||||
var _clientHelper = require("./clientHelper");
|
||||
var _channelOwner = require("./channelOwner");
|
||||
var _locator = require("./locator");
|
||||
/**
|
||||
* Copyright (c) Microsoft Corporation.
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
class Selectors {
|
||||
constructor() {
|
||||
this._channels = new Set();
|
||||
this._registrations = [];
|
||||
}
|
||||
async register(name, script, options = {}) {
|
||||
const source = await (0, _clientHelper.evaluationScript)(script, undefined, false);
|
||||
const params = {
|
||||
...options,
|
||||
name,
|
||||
source
|
||||
};
|
||||
for (const channel of this._channels) await channel._channel.register(params);
|
||||
this._registrations.push(params);
|
||||
}
|
||||
setTestIdAttribute(attributeName) {
|
||||
(0, _locator.setTestIdAttribute)(attributeName);
|
||||
for (const channel of this._channels) channel._channel.setTestIdAttributeName({
|
||||
testIdAttributeName: attributeName
|
||||
}).catch(() => {});
|
||||
}
|
||||
_addChannel(channel) {
|
||||
this._channels.add(channel);
|
||||
for (const params of this._registrations) {
|
||||
// This should not fail except for connection closure, but just in case we catch.
|
||||
channel._channel.register(params).catch(() => {});
|
||||
channel._channel.setTestIdAttributeName({
|
||||
testIdAttributeName: (0, _locator.testIdAttributeName)()
|
||||
}).catch(() => {});
|
||||
}
|
||||
}
|
||||
_removeChannel(channel) {
|
||||
this._channels.delete(channel);
|
||||
}
|
||||
}
|
||||
exports.Selectors = Selectors;
|
||||
class SelectorsOwner extends _channelOwner.ChannelOwner {
|
||||
static from(browser) {
|
||||
return browser._object;
|
||||
}
|
||||
}
|
||||
exports.SelectorsOwner = SelectorsOwner;
|
||||
54
bin/pac/tools/.playwright/package/lib/client/stream.js
Normal file
54
bin/pac/tools/.playwright/package/lib/client/stream.js
Normal file
@@ -0,0 +1,54 @@
|
||||
"use strict";
|
||||
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
exports.Stream = void 0;
|
||||
var _stream = require("stream");
|
||||
var _channelOwner = require("./channelOwner");
|
||||
/**
|
||||
* Copyright (c) Microsoft Corporation.
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
class Stream extends _channelOwner.ChannelOwner {
|
||||
static from(Stream) {
|
||||
return Stream._object;
|
||||
}
|
||||
constructor(parent, type, guid, initializer) {
|
||||
super(parent, type, guid, initializer);
|
||||
}
|
||||
stream() {
|
||||
return new StreamImpl(this._channel);
|
||||
}
|
||||
}
|
||||
exports.Stream = Stream;
|
||||
class StreamImpl extends _stream.Readable {
|
||||
constructor(channel) {
|
||||
super();
|
||||
this._channel = void 0;
|
||||
this._channel = channel;
|
||||
}
|
||||
async _read() {
|
||||
const result = await this._channel.read({
|
||||
size: 1024 * 1024
|
||||
});
|
||||
if (result.binary.byteLength) this.push(result.binary);else this.push(null);
|
||||
}
|
||||
_destroy(error, callback) {
|
||||
// Stream might be destroyed after the connection was closed.
|
||||
this._channel.close().catch(e => null);
|
||||
super._destroy(error, callback);
|
||||
}
|
||||
}
|
||||
128
bin/pac/tools/.playwright/package/lib/client/tracing.js
Normal file
128
bin/pac/tools/.playwright/package/lib/client/tracing.js
Normal file
@@ -0,0 +1,128 @@
|
||||
"use strict";
|
||||
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
exports.Tracing = void 0;
|
||||
var _artifact = require("./artifact");
|
||||
var _channelOwner = require("./channelOwner");
|
||||
/**
|
||||
* Copyright (c) Microsoft Corporation.
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
class Tracing extends _channelOwner.ChannelOwner {
|
||||
static from(channel) {
|
||||
return channel._object;
|
||||
}
|
||||
constructor(parent, type, guid, initializer) {
|
||||
super(parent, type, guid, initializer);
|
||||
this._includeSources = false;
|
||||
this._tracesDir = void 0;
|
||||
this._stacksId = void 0;
|
||||
this._isTracing = false;
|
||||
}
|
||||
async start(options = {}) {
|
||||
this._includeSources = !!options.sources;
|
||||
const traceName = await this._wrapApiCall(async () => {
|
||||
await this._channel.tracingStart(options);
|
||||
const response = await this._channel.tracingStartChunk({
|
||||
name: options.name,
|
||||
title: options.title
|
||||
});
|
||||
return response.traceName;
|
||||
});
|
||||
await this._startCollectingStacks(traceName);
|
||||
}
|
||||
async startChunk(options = {}) {
|
||||
const {
|
||||
traceName
|
||||
} = await this._channel.tracingStartChunk(options);
|
||||
await this._startCollectingStacks(traceName);
|
||||
}
|
||||
async _startCollectingStacks(traceName) {
|
||||
if (!this._isTracing) {
|
||||
this._isTracing = true;
|
||||
this._connection.setIsTracing(true);
|
||||
}
|
||||
const result = await this._connection.localUtils()._channel.tracingStarted({
|
||||
tracesDir: this._tracesDir,
|
||||
traceName
|
||||
});
|
||||
this._stacksId = result.stacksId;
|
||||
}
|
||||
async stopChunk(options = {}) {
|
||||
await this._doStopChunk(options.path);
|
||||
}
|
||||
async stop(options = {}) {
|
||||
await this._wrapApiCall(async () => {
|
||||
await this._doStopChunk(options.path);
|
||||
await this._channel.tracingStop();
|
||||
});
|
||||
}
|
||||
async _doStopChunk(filePath) {
|
||||
if (this._isTracing) {
|
||||
this._isTracing = false;
|
||||
this._connection.setIsTracing(false);
|
||||
}
|
||||
if (!filePath) {
|
||||
// Not interested in artifacts.
|
||||
await this._channel.tracingStopChunk({
|
||||
mode: 'discard'
|
||||
});
|
||||
if (this._stacksId) await this._connection.localUtils()._channel.traceDiscarded({
|
||||
stacksId: this._stacksId
|
||||
});
|
||||
return;
|
||||
}
|
||||
const isLocal = !this._connection.isRemote();
|
||||
if (isLocal) {
|
||||
const result = await this._channel.tracingStopChunk({
|
||||
mode: 'entries'
|
||||
});
|
||||
await this._connection.localUtils()._channel.zip({
|
||||
zipFile: filePath,
|
||||
entries: result.entries,
|
||||
mode: 'write',
|
||||
stacksId: this._stacksId,
|
||||
includeSources: this._includeSources
|
||||
});
|
||||
return;
|
||||
}
|
||||
const result = await this._channel.tracingStopChunk({
|
||||
mode: 'archive'
|
||||
});
|
||||
|
||||
// The artifact may be missing if the browser closed while stopping tracing.
|
||||
if (!result.artifact) {
|
||||
if (this._stacksId) await this._connection.localUtils()._channel.traceDiscarded({
|
||||
stacksId: this._stacksId
|
||||
});
|
||||
return;
|
||||
}
|
||||
|
||||
// Save trace to the final local file.
|
||||
const artifact = _artifact.Artifact.from(result.artifact);
|
||||
await artifact.saveAs(filePath);
|
||||
await artifact.delete();
|
||||
await this._connection.localUtils()._channel.zip({
|
||||
zipFile: filePath,
|
||||
entries: [],
|
||||
mode: 'append',
|
||||
stacksId: this._stacksId,
|
||||
includeSources: this._includeSources
|
||||
});
|
||||
}
|
||||
}
|
||||
exports.Tracing = Tracing;
|
||||
25
bin/pac/tools/.playwright/package/lib/client/types.js
Normal file
25
bin/pac/tools/.playwright/package/lib/client/types.js
Normal file
@@ -0,0 +1,25 @@
|
||||
"use strict";
|
||||
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
exports.kLifecycleEvents = void 0;
|
||||
/**
|
||||
* Copyright 2018 Google Inc. All rights reserved.
|
||||
* Modifications copyright (c) Microsoft Corporation.
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
const kLifecycleEvents = new Set(['load', 'domcontentloaded', 'networkidle', 'commit']);
|
||||
exports.kLifecycleEvents = kLifecycleEvents;
|
||||
51
bin/pac/tools/.playwright/package/lib/client/video.js
Normal file
51
bin/pac/tools/.playwright/package/lib/client/video.js
Normal file
@@ -0,0 +1,51 @@
|
||||
"use strict";
|
||||
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
exports.Video = void 0;
|
||||
var _utils = require("../utils");
|
||||
/**
|
||||
* Copyright (c) Microsoft Corporation.
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
class Video {
|
||||
constructor(page, connection) {
|
||||
this._artifact = null;
|
||||
this._artifactReadyPromise = new _utils.ManualPromise();
|
||||
this._isRemote = false;
|
||||
this._isRemote = connection.isRemote();
|
||||
this._artifact = page._closedOrCrashedRace.safeRace(this._artifactReadyPromise);
|
||||
}
|
||||
_artifactReady(artifact) {
|
||||
this._artifactReadyPromise.resolve(artifact);
|
||||
}
|
||||
async path() {
|
||||
if (this._isRemote) throw new Error(`Path is not available when connecting remotely. Use saveAs() to save a local copy.`);
|
||||
const artifact = await this._artifact;
|
||||
if (!artifact) throw new Error('Page did not produce any video frames');
|
||||
return artifact._initializer.absolutePath;
|
||||
}
|
||||
async saveAs(path) {
|
||||
const artifact = await this._artifact;
|
||||
if (!artifact) throw new Error('Page did not produce any video frames');
|
||||
return artifact.saveAs(path);
|
||||
}
|
||||
async delete() {
|
||||
const artifact = await this._artifact;
|
||||
if (artifact) await artifact.delete();
|
||||
}
|
||||
}
|
||||
exports.Video = Video;
|
||||
158
bin/pac/tools/.playwright/package/lib/client/waiter.js
Normal file
158
bin/pac/tools/.playwright/package/lib/client/waiter.js
Normal file
@@ -0,0 +1,158 @@
|
||||
"use strict";
|
||||
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
exports.Waiter = void 0;
|
||||
var _stackTrace = require("../utils/stackTrace");
|
||||
var _errors = require("../common/errors");
|
||||
var _utils = require("../utils");
|
||||
/**
|
||||
* Copyright (c) Microsoft Corporation.
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
class Waiter {
|
||||
constructor(channelOwner, event) {
|
||||
this._dispose = void 0;
|
||||
this._failures = [];
|
||||
this._immediateError = void 0;
|
||||
this._logs = [];
|
||||
this._channelOwner = void 0;
|
||||
this._waitId = void 0;
|
||||
this._error = void 0;
|
||||
this._waitId = (0, _utils.createGuid)();
|
||||
this._channelOwner = channelOwner;
|
||||
this._channelOwner._channel.waitForEventInfo({
|
||||
info: {
|
||||
waitId: this._waitId,
|
||||
phase: 'before',
|
||||
event
|
||||
}
|
||||
}).catch(() => {});
|
||||
this._dispose = [() => this._channelOwner._wrapApiCall(async () => {
|
||||
await this._channelOwner._channel.waitForEventInfo({
|
||||
info: {
|
||||
waitId: this._waitId,
|
||||
phase: 'after',
|
||||
error: this._error
|
||||
}
|
||||
});
|
||||
}, true).catch(() => {})];
|
||||
}
|
||||
static createForEvent(channelOwner, event) {
|
||||
return new Waiter(channelOwner, event);
|
||||
}
|
||||
async waitForEvent(emitter, event, predicate) {
|
||||
const {
|
||||
promise,
|
||||
dispose
|
||||
} = waitForEvent(emitter, event, predicate);
|
||||
return this.waitForPromise(promise, dispose);
|
||||
}
|
||||
rejectOnEvent(emitter, event, error, predicate) {
|
||||
const {
|
||||
promise,
|
||||
dispose
|
||||
} = waitForEvent(emitter, event, predicate);
|
||||
this._rejectOn(promise.then(() => {
|
||||
throw error;
|
||||
}), dispose);
|
||||
}
|
||||
rejectOnTimeout(timeout, message) {
|
||||
if (!timeout) return;
|
||||
const {
|
||||
promise,
|
||||
dispose
|
||||
} = waitForTimeout(timeout);
|
||||
this._rejectOn(promise.then(() => {
|
||||
throw new _errors.TimeoutError(message);
|
||||
}), dispose);
|
||||
}
|
||||
rejectImmediately(error) {
|
||||
this._immediateError = error;
|
||||
}
|
||||
dispose() {
|
||||
for (const dispose of this._dispose) dispose();
|
||||
}
|
||||
async waitForPromise(promise, dispose) {
|
||||
try {
|
||||
if (this._immediateError) throw this._immediateError;
|
||||
const result = await Promise.race([promise, ...this._failures]);
|
||||
if (dispose) dispose();
|
||||
return result;
|
||||
} catch (e) {
|
||||
if (dispose) dispose();
|
||||
this._error = e.message;
|
||||
this.dispose();
|
||||
(0, _stackTrace.rewriteErrorMessage)(e, e.message + formatLogRecording(this._logs));
|
||||
throw e;
|
||||
}
|
||||
}
|
||||
log(s) {
|
||||
this._logs.push(s);
|
||||
this._channelOwner._wrapApiCall(async () => {
|
||||
await this._channelOwner._channel.waitForEventInfo({
|
||||
info: {
|
||||
waitId: this._waitId,
|
||||
phase: 'log',
|
||||
message: s
|
||||
}
|
||||
}).catch(() => {});
|
||||
}, true);
|
||||
}
|
||||
_rejectOn(promise, dispose) {
|
||||
this._failures.push(promise);
|
||||
if (dispose) this._dispose.push(dispose);
|
||||
}
|
||||
}
|
||||
exports.Waiter = Waiter;
|
||||
function waitForEvent(emitter, event, predicate) {
|
||||
let listener;
|
||||
const promise = new Promise((resolve, reject) => {
|
||||
listener = async eventArg => {
|
||||
try {
|
||||
if (predicate && !(await predicate(eventArg))) return;
|
||||
emitter.removeListener(event, listener);
|
||||
resolve(eventArg);
|
||||
} catch (e) {
|
||||
emitter.removeListener(event, listener);
|
||||
reject(e);
|
||||
}
|
||||
};
|
||||
emitter.addListener(event, listener);
|
||||
});
|
||||
const dispose = () => emitter.removeListener(event, listener);
|
||||
return {
|
||||
promise,
|
||||
dispose
|
||||
};
|
||||
}
|
||||
function waitForTimeout(timeout) {
|
||||
let timeoutId;
|
||||
const promise = new Promise(resolve => timeoutId = setTimeout(resolve, timeout));
|
||||
const dispose = () => clearTimeout(timeoutId);
|
||||
return {
|
||||
promise,
|
||||
dispose
|
||||
};
|
||||
}
|
||||
function formatLogRecording(log) {
|
||||
if (!log.length) return '';
|
||||
const header = ` logs `;
|
||||
const headerLength = 60;
|
||||
const leftLength = (headerLength - header.length) / 2;
|
||||
const rightLength = headerLength - header.length - leftLength;
|
||||
return `\n${'='.repeat(leftLength)}${header}${'='.repeat(rightLength)}\n${log.join('\n')}\n${'='.repeat(headerLength)}`;
|
||||
}
|
||||
69
bin/pac/tools/.playwright/package/lib/client/worker.js
Normal file
69
bin/pac/tools/.playwright/package/lib/client/worker.js
Normal file
@@ -0,0 +1,69 @@
|
||||
"use strict";
|
||||
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
exports.Worker = void 0;
|
||||
var _events = require("./events");
|
||||
var _channelOwner = require("./channelOwner");
|
||||
var _jsHandle = require("./jsHandle");
|
||||
var _utils = require("../utils");
|
||||
var _errors = require("../common/errors");
|
||||
/**
|
||||
* Copyright (c) Microsoft Corporation.
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
class Worker extends _channelOwner.ChannelOwner {
|
||||
// Set for web workers.
|
||||
// Set for service workers.
|
||||
|
||||
static from(worker) {
|
||||
return worker._object;
|
||||
}
|
||||
constructor(parent, type, guid, initializer) {
|
||||
super(parent, type, guid, initializer);
|
||||
this._page = void 0;
|
||||
this._context = void 0;
|
||||
this._closedRace = new _utils.ScopedRace();
|
||||
this._channel.on('close', () => {
|
||||
if (this._page) this._page._workers.delete(this);
|
||||
if (this._context) this._context._serviceWorkers.delete(this);
|
||||
this.emit(_events.Events.Worker.Close, this);
|
||||
});
|
||||
this.once(_events.Events.Worker.Close, () => this._closedRace.scopeClosed(new Error(_errors.kBrowserOrContextClosedError)));
|
||||
}
|
||||
url() {
|
||||
return this._initializer.url;
|
||||
}
|
||||
async evaluate(pageFunction, arg) {
|
||||
(0, _jsHandle.assertMaxArguments)(arguments.length, 2);
|
||||
const result = await this._channel.evaluateExpression({
|
||||
expression: String(pageFunction),
|
||||
isFunction: typeof pageFunction === 'function',
|
||||
arg: (0, _jsHandle.serializeArgument)(arg)
|
||||
});
|
||||
return (0, _jsHandle.parseResult)(result.value);
|
||||
}
|
||||
async evaluateHandle(pageFunction, arg) {
|
||||
(0, _jsHandle.assertMaxArguments)(arguments.length, 2);
|
||||
const result = await this._channel.evaluateExpressionHandle({
|
||||
expression: String(pageFunction),
|
||||
isFunction: typeof pageFunction === 'function',
|
||||
arg: (0, _jsHandle.serializeArgument)(arg)
|
||||
});
|
||||
return _jsHandle.JSHandle.from(result.handle);
|
||||
}
|
||||
}
|
||||
exports.Worker = Worker;
|
||||
@@ -0,0 +1,54 @@
|
||||
"use strict";
|
||||
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
exports.WritableStream = void 0;
|
||||
var _stream = require("stream");
|
||||
var _channelOwner = require("./channelOwner");
|
||||
/**
|
||||
* Copyright (c) Microsoft Corporation.
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
class WritableStream extends _channelOwner.ChannelOwner {
|
||||
static from(Stream) {
|
||||
return Stream._object;
|
||||
}
|
||||
constructor(parent, type, guid, initializer) {
|
||||
super(parent, type, guid, initializer);
|
||||
}
|
||||
stream() {
|
||||
return new WritableStreamImpl(this._channel);
|
||||
}
|
||||
}
|
||||
exports.WritableStream = WritableStream;
|
||||
class WritableStreamImpl extends _stream.Writable {
|
||||
constructor(channel) {
|
||||
super();
|
||||
this._channel = void 0;
|
||||
this._channel = channel;
|
||||
}
|
||||
async _write(chunk, encoding, callback) {
|
||||
const error = await this._channel.write({
|
||||
binary: typeof chunk === 'string' ? Buffer.from(chunk) : chunk
|
||||
}).catch(e => e);
|
||||
callback(error || null);
|
||||
}
|
||||
async _final(callback) {
|
||||
// Stream might be destroyed after the connection was closed.
|
||||
const error = await this._channel.close().catch(e => e);
|
||||
callback(error || null);
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user