rebrowser-playwright-core 1.47.2

package/lib/server/recorder/recorderApp.js

@@ -0,0 +1,190 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.RecorderApp = exports.EmptyRecorderApp = void 0;
+var _fs = _interopRequireDefault(require("fs"));
+var _path = _interopRequireDefault(require("path"));
+var _progress = require("../progress");
+var _events = require("events");
+var _instrumentation = require("../instrumentation");
+var _utils = require("../../utils");
+var _utilsBundle = require("../../utilsBundle");
+var _launchApp = require("../launchApp");
+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 EmptyRecorderApp extends _events.EventEmitter {
+  async close() {}
+  async setPaused(paused) {}
+  async setMode(mode) {}
+  async setFileIfNeeded(file) {}
+  async setSelector(selector, userGesture) {}
+  async updateCallLogs(callLogs) {}
+  async setSources(sources) {}
+}
+exports.EmptyRecorderApp = EmptyRecorderApp;
+class RecorderApp extends _events.EventEmitter {
+  constructor(recorder, page, wsEndpoint) {
+    super();
+    this._page = void 0;
+    this.wsEndpoint = void 0;
+    this._recorder = void 0;
+    this.setMaxListeners(0);
+    this._recorder = recorder;
+    this._page = page;
+    this.wsEndpoint = wsEndpoint;
+  }
+  async close() {
+    await this._page.context().close({
+      reason: 'Recorder window closed'
+    });
+  }
+  async _init() {
+    await (0, _launchApp.syncLocalStorageWithSettings)(this._page, 'recorder');
+    await this._page._setServerRequestInterceptor(route => {
+      if (!route.request().url().startsWith('https://playwright/')) return false;
+      const uri = route.request().url().substring('https://playwright/'.length);
+      const file = require.resolve('../../vite/recorder/' + uri);
+      _fs.default.promises.readFile(file).then(buffer => {
+        route.fulfill({
+          requestUrl: route.request().url(),
+          status: 200,
+          headers: [{
+            name: 'Content-Type',
+            value: _utilsBundle.mime.getType(_path.default.extname(file)) || 'application/octet-stream'
+          }],
+          body: buffer.toString('base64'),
+          isBase64: true
+        }).catch(() => {});
+      });
+      return true;
+    });
+    await this._page.exposeBinding('dispatch', false, (_, data) => this.emit('event', data));
+    this._page.once('close', () => {
+      this.emit('close');
+      this._page.context().close({
+        reason: 'Recorder window closed'
+      }).catch(() => {});
+    });
+    const mainFrame = this._page.mainFrame();
+    await mainFrame.goto((0, _instrumentation.serverSideCallMetadata)(), 'https://playwright/index.html');
+  }
+  static factory(context) {
+    return async recorder => {
+      if (process.env.PW_CODEGEN_NO_INSPECTOR) return new EmptyRecorderApp();
+      return await RecorderApp._open(recorder, context);
+    };
+  }
+  static async _open(recorder, inspectedContext) {
+    const sdkLanguage = inspectedContext.attribution.playwright.options.sdkLanguage;
+    const headed = !!inspectedContext._browser.options.headful;
+    const recorderPlaywright = require('../playwright').createPlaywright({
+      sdkLanguage: 'javascript',
+      isInternalPlaywright: true
+    });
+    const {
+      context,
+      page
+    } = await (0, _launchApp.launchApp)(recorderPlaywright.chromium, {
+      sdkLanguage,
+      windowSize: {
+        width: 600,
+        height: 600
+      },
+      windowPosition: {
+        x: 1020,
+        y: 10
+      },
+      persistentContextOptions: {
+        noDefaultViewport: true,
+        headless: !!process.env.PWTEST_CLI_HEADLESS || (0, _utils.isUnderTest)() && !headed,
+        useWebSocket: !!process.env.PWTEST_RECORDER_PORT,
+        handleSIGINT: false,
+        args: process.env.PWTEST_RECORDER_PORT ? [`--remote-debugging-port=${process.env.PWTEST_RECORDER_PORT}`] : [],
+        executablePath: inspectedContext._browser.options.isChromium ? inspectedContext._browser.options.customExecutablePath : undefined
+      }
+    });
+    const controller = new _progress.ProgressController((0, _instrumentation.serverSideCallMetadata)(), context._browser);
+    await controller.run(async progress => {
+      await context._browser._defaultContext._loadDefaultContextAsIs(progress);
+    });
+    const result = new RecorderApp(recorder, page, context._browser.options.wsEndpoint);
+    await result._init();
+    return result;
+  }
+  async setMode(mode) {
+    await this._page.mainFrame().evaluateExpression((mode => {
+      window.playwrightSetMode(mode);
+    }).toString(), {
+      isFunction: true
+    }, mode).catch(() => {});
+  }
+  async setFileIfNeeded(file) {
+    await this._page.mainFrame().evaluateExpression((file => {
+      window.playwrightSetFileIfNeeded(file);
+    }).toString(), {
+      isFunction: true
+    }, file).catch(() => {});
+  }
+  async setPaused(paused) {
+    await this._page.mainFrame().evaluateExpression((paused => {
+      window.playwrightSetPaused(paused);
+    }).toString(), {
+      isFunction: true
+    }, paused).catch(() => {});
+  }
+  async setSources(sources) {
+    await this._page.mainFrame().evaluateExpression((sources => {
+      window.playwrightSetSources(sources);
+    }).toString(), {
+      isFunction: true
+    }, sources).catch(() => {});
+
+    // Testing harness for runCLI mode.
+    if (process.env.PWTEST_CLI_IS_UNDER_TEST && sources.length) process._didSetSourcesForTest(sources[0].text);
+  }
+  async setSelector(selector, userGesture) {
+    if (userGesture) {
+      var _this$_recorder;
+      if (((_this$_recorder = this._recorder) === null || _this$_recorder === void 0 ? void 0 : _this$_recorder.mode()) === 'inspecting') {
+        this._recorder.setMode('standby');
+        this._page.bringToFront();
+      } else {
+        var _this$_recorder2;
+        (_this$_recorder2 = this._recorder) === null || _this$_recorder2 === void 0 || _this$_recorder2.setMode('recording');
+      }
+    }
+    await this._page.mainFrame().evaluateExpression((data => {
+      window.playwrightSetSelector(data.selector, data.userGesture);
+    }).toString(), {
+      isFunction: true
+    }, {
+      selector,
+      userGesture
+    }).catch(() => {});
+  }
+  async updateCallLogs(callLogs) {
+    await this._page.mainFrame().evaluateExpression((callLogs => {
+      window.playwrightUpdateLogs(callLogs);
+    }).toString(), {
+      isFunction: true
+    }, callLogs).catch(() => {});
+  }
+}
+exports.RecorderApp = RecorderApp;

package/lib/server/recorder/recorderCollection.js

@@ -0,0 +1,127 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.RecorderCollection = void 0;
+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 RecorderCollection extends _events.EventEmitter {
+  constructor(enabled) {
+    super();
+    this._currentAction = null;
+    this._lastAction = null;
+    this._actions = [];
+    this._enabled = void 0;
+    this._enabled = enabled;
+    this.restart();
+  }
+  restart() {
+    this._currentAction = null;
+    this._lastAction = null;
+    this._actions = [];
+    this.emit('change');
+  }
+  actions() {
+    return this._actions;
+  }
+  setEnabled(enabled) {
+    this._enabled = enabled;
+  }
+  addAction(action) {
+    if (!this._enabled) return;
+    this.willPerformAction(action);
+    this.didPerformAction(action);
+  }
+  willPerformAction(action) {
+    if (!this._enabled) return;
+    this._currentAction = action;
+  }
+  performedActionFailed(action) {
+    if (!this._enabled) return;
+    if (this._currentAction === action) this._currentAction = null;
+  }
+  didPerformAction(actionInContext) {
+    if (!this._enabled) return;
+    const action = actionInContext.action;
+    let eraseLastAction = false;
+    if (this._lastAction && this._lastAction.frame.pageAlias === actionInContext.frame.pageAlias) {
+      const lastAction = this._lastAction.action;
+      // We augment last action based on the type.
+      if (this._lastAction && action.name === 'fill' && lastAction.name === 'fill') {
+        if (action.selector === lastAction.selector) eraseLastAction = true;
+      }
+      if (lastAction && action.name === 'click' && lastAction.name === 'click') {
+        if (action.selector === lastAction.selector && action.clickCount > lastAction.clickCount) eraseLastAction = true;
+      }
+      if (lastAction && action.name === 'navigate' && lastAction.name === 'navigate') {
+        if (action.url === lastAction.url) {
+          // Already at a target URL.
+          this._currentAction = null;
+          return;
+        }
+      }
+      // Check and uncheck erase click.
+      if (lastAction && (action.name === 'check' || action.name === 'uncheck') && lastAction.name === 'click') {
+        if (action.selector === lastAction.selector) eraseLastAction = true;
+      }
+    }
+    this._lastAction = actionInContext;
+    this._currentAction = null;
+    if (eraseLastAction) this._actions.pop();
+    this._actions.push(actionInContext);
+    this.emit('change');
+  }
+  commitLastAction() {
+    if (!this._enabled) return;
+    const action = this._lastAction;
+    if (action) action.committed = true;
+  }
+  signal(pageAlias, frame, signal) {
+    if (!this._enabled) return;
+
+    // Signal either arrives while action is being performed or shortly after.
+    if (this._currentAction) {
+      this._currentAction.action.signals.push(signal);
+      return;
+    }
+    if (this._lastAction && (!this._lastAction.committed || signal.name !== 'navigation')) {
+      const signals = this._lastAction.action.signals;
+      if (signal.name === 'navigation' && signals.length && signals[signals.length - 1].name === 'download') return;
+      if (signal.name === 'download' && signals.length && signals[signals.length - 1].name === 'navigation') signals.length = signals.length - 1;
+      this._lastAction.action.signals.push(signal);
+      this.emit('change');
+      return;
+    }
+    if (signal.name === 'navigation' && frame._page.mainFrame() === frame) {
+      this.addAction({
+        frame: {
+          pageAlias,
+          framePath: []
+        },
+        committed: true,
+        action: {
+          name: 'navigate',
+          url: frame.url(),
+          signals: []
+        }
+      });
+    }
+  }
+}
+exports.RecorderCollection = RecorderCollection;

package/lib/server/recorder/recorderRunner.js

@@ -0,0 +1,177 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.performAction = performAction;
+var _utils = require("../../utils");
+var _language = require("../codegen/language");
+var _recorderUtils = require("./recorderUtils");
+/**
+ * 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.
+ */
+
+async function innerPerformAction(mainFrame, action, params, cb) {
+  const callMetadata = {
+    id: `call@${(0, _utils.createGuid)()}`,
+    apiName: 'frame.' + action,
+    objectId: mainFrame.guid,
+    pageId: mainFrame._page.guid,
+    frameId: mainFrame.guid,
+    startTime: (0, _utils.monotonicTime)(),
+    endTime: 0,
+    type: 'Frame',
+    method: action,
+    params,
+    log: []
+  };
+  try {
+    await mainFrame.instrumentation.onBeforeCall(mainFrame, callMetadata);
+    await cb(callMetadata);
+  } catch (e) {
+    callMetadata.endTime = (0, _utils.monotonicTime)();
+    await mainFrame.instrumentation.onAfterCall(mainFrame, callMetadata);
+    return false;
+  }
+  callMetadata.endTime = (0, _utils.monotonicTime)();
+  await mainFrame.instrumentation.onAfterCall(mainFrame, callMetadata);
+  return true;
+}
+async function performAction(pageAliases, actionInContext) {
+  var _find;
+  const pageAlias = actionInContext.frame.pageAlias;
+  const page = (_find = [...pageAliases.entries()].find(([, alias]) => pageAlias === alias)) === null || _find === void 0 ? void 0 : _find[0];
+  if (!page) throw new Error('Internal error: page not found');
+  const mainFrame = page.mainFrame();
+  const {
+    action
+  } = actionInContext;
+  const kActionTimeout = 5000;
+  if (action.name === 'navigate') return await innerPerformAction(mainFrame, 'goto', {
+    url: action.url
+  }, callMetadata => mainFrame.goto(callMetadata, action.url, {
+    timeout: kActionTimeout
+  }));
+  if (action.name === 'openPage') throw Error('Not reached');
+  if (action.name === 'closePage') return await innerPerformAction(mainFrame, 'close', {}, callMetadata => mainFrame._page.close(callMetadata));
+  const selector = (0, _recorderUtils.buildFullSelector)(actionInContext.frame.framePath, action.selector);
+  if (action.name === 'click') {
+    const options = (0, _language.toClickOptions)(action);
+    return await innerPerformAction(mainFrame, 'click', {
+      selector
+    }, callMetadata => mainFrame.click(callMetadata, selector, {
+      ...options,
+      timeout: kActionTimeout,
+      strict: true
+    }));
+  }
+  if (action.name === 'press') {
+    const modifiers = (0, _language.toKeyboardModifiers)(action.modifiers);
+    const shortcut = [...modifiers, action.key].join('+');
+    return await innerPerformAction(mainFrame, 'press', {
+      selector,
+      key: shortcut
+    }, callMetadata => mainFrame.press(callMetadata, selector, shortcut, {
+      timeout: kActionTimeout,
+      strict: true
+    }));
+  }
+  if (action.name === 'fill') return await innerPerformAction(mainFrame, 'fill', {
+    selector,
+    text: action.text
+  }, callMetadata => mainFrame.fill(callMetadata, selector, action.text, {
+    timeout: kActionTimeout,
+    strict: true
+  }));
+  if (action.name === 'setInputFiles') return await innerPerformAction(mainFrame, 'setInputFiles', {
+    selector,
+    files: action.files
+  }, callMetadata => mainFrame.setInputFiles(callMetadata, selector, {
+    selector,
+    payloads: [],
+    timeout: kActionTimeout,
+    strict: true
+  }));
+  if (action.name === 'check') return await innerPerformAction(mainFrame, 'check', {
+    selector
+  }, callMetadata => mainFrame.check(callMetadata, selector, {
+    timeout: kActionTimeout,
+    strict: true
+  }));
+  if (action.name === 'uncheck') return await innerPerformAction(mainFrame, 'uncheck', {
+    selector
+  }, callMetadata => mainFrame.uncheck(callMetadata, selector, {
+    timeout: kActionTimeout,
+    strict: true
+  }));
+  if (action.name === 'select') {
+    const values = action.options.map(value => ({
+      value
+    }));
+    return await innerPerformAction(mainFrame, 'selectOption', {
+      selector,
+      values
+    }, callMetadata => mainFrame.selectOption(callMetadata, selector, [], values, {
+      timeout: kActionTimeout,
+      strict: true
+    }));
+  }
+  if (action.name === 'assertChecked') {
+    return await innerPerformAction(mainFrame, 'expect', {
+      selector
+    }, callMetadata => mainFrame.expect(callMetadata, selector, {
+      selector,
+      expression: 'to.be.checked',
+      isNot: !action.checked,
+      timeout: kActionTimeout
+    }));
+  }
+  if (action.name === 'assertText') {
+    return await innerPerformAction(mainFrame, 'expect', {
+      selector
+    }, callMetadata => mainFrame.expect(callMetadata, selector, {
+      selector,
+      expression: 'to.have.text',
+      expectedText: (0, _utils.serializeExpectedTextValues)([action.text], {
+        matchSubstring: true,
+        normalizeWhiteSpace: true
+      }),
+      isNot: false,
+      timeout: kActionTimeout
+    }));
+  }
+  if (action.name === 'assertValue') {
+    return await innerPerformAction(mainFrame, 'expect', {
+      selector
+    }, callMetadata => mainFrame.expect(callMetadata, selector, {
+      selector,
+      expression: 'to.have.value',
+      expectedValue: action.value,
+      isNot: false,
+      timeout: kActionTimeout
+    }));
+  }
+  if (action.name === 'assertVisible') {
+    return await innerPerformAction(mainFrame, 'expect', {
+      selector
+    }, callMetadata => mainFrame.expect(callMetadata, selector, {
+      selector,
+      expression: 'to.be.visible',
+      isNot: false,
+      timeout: kActionTimeout
+    }));
+  }
+  throw new Error('Internal error: unexpected action ' + action.name);
+}

package/lib/server/recorder/recorderUtils.js

@@ -0,0 +1,71 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.buildFullSelector = buildFullSelector;
+exports.frameForAction = frameForAction;
+exports.mainFrameForAction = mainFrameForAction;
+exports.metadataToCallLog = metadataToCallLog;
+/**
+ * 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 metadataToCallLog(metadata, status) {
+  var _metadata$params, _metadata$params2, _metadata$error;
+  let title = metadata.apiName || metadata.method;
+  if (metadata.method === 'waitForEventInfo') title += `(${metadata.params.info.event})`;
+  title = title.replace('object.expect', 'expect');
+  if (metadata.error) status = 'error';
+  const params = {
+    url: (_metadata$params = metadata.params) === null || _metadata$params === void 0 ? void 0 : _metadata$params.url,
+    selector: (_metadata$params2 = metadata.params) === null || _metadata$params2 === void 0 ? void 0 : _metadata$params2.selector
+  };
+  let duration = metadata.endTime ? metadata.endTime - metadata.startTime : undefined;
+  if (typeof duration === 'number' && metadata.pauseStartTime && metadata.pauseEndTime) {
+    duration -= metadata.pauseEndTime - metadata.pauseStartTime;
+    duration = Math.max(duration, 0);
+  }
+  const callLog = {
+    id: metadata.id,
+    messages: metadata.log,
+    title,
+    status,
+    error: (_metadata$error = metadata.error) === null || _metadata$error === void 0 || (_metadata$error = _metadata$error.error) === null || _metadata$error === void 0 ? void 0 : _metadata$error.message,
+    params,
+    duration
+  };
+  return callLog;
+}
+function buildFullSelector(framePath, selector) {
+  return [...framePath, selector].join(' >> internal:control=enter-frame >> ');
+}
+function mainFrameForAction(pageAliases, actionInContext) {
+  var _find;
+  const pageAlias = actionInContext.frame.pageAlias;
+  const page = (_find = [...pageAliases.entries()].find(([, alias]) => pageAlias === alias)) === null || _find === void 0 ? void 0 : _find[0];
+  if (!page) throw new Error('Internal error: page not found');
+  return page.mainFrame();
+}
+async function frameForAction(pageAliases, actionInContext, action) {
+  var _find2;
+  const pageAlias = actionInContext.frame.pageAlias;
+  const page = (_find2 = [...pageAliases.entries()].find(([, alias]) => pageAlias === alias)) === null || _find2 === void 0 ? void 0 : _find2[0];
+  if (!page) throw new Error('Internal error: page not found');
+  const fullSelector = buildFullSelector(actionInContext.frame.framePath, action.selector);
+  const result = await page.mainFrame().selectors.resolveFrameForSelector(fullSelector);
+  if (!result) throw new Error('Internal error: frame not found');
+  return result.frame;
+}

package/lib/server/recorder/throttledFile.js

@@ -0,0 +1,46 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ThrottledFile = void 0;
+var fs = _interopRequireWildcard(require("fs"));
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+/**
+ * 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 ThrottledFile {
+  constructor(file) {
+    this._file = void 0;
+    this._timer = void 0;
+    this._text = void 0;
+    this._file = file;
+  }
+  setContent(text) {
+    this._text = text;
+    if (!this._timer) this._timer = setTimeout(() => this.flush(), 250);
+  }
+  flush() {
+    if (this._timer) {
+      clearTimeout(this._timer);
+      this._timer = undefined;
+    }
+    if (this._text) fs.writeFileSync(this._file, this._text);
+    this._text = undefined;
+  }
+}
+exports.ThrottledFile = ThrottledFile;