patchright-core 1.48.2

package/lib/server/recorder/recorderApp.js

@@ -0,0 +1,196 @@
+"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 {
+  constructor(...args) {
+    super(...args);
+    this.wsEndpointForTest = void 0;
+  }
+  async close() {}
+  async setPaused(paused) {}
+  async setMode(mode) {}
+  async setRunningFile(file) {}
+  async setSelector(selector, userGesture) {}
+  async updateCallLogs(callLogs) {}
+  async setSources(sources) {}
+  async setActions(actions, sources) {}
+}
+exports.EmptyRecorderApp = EmptyRecorderApp;
+class RecorderApp extends _events.EventEmitter {
+  constructor(recorder, page, wsEndpoint) {
+    super();
+    this._page = void 0;
+    this.wsEndpointForTest = void 0;
+    this._recorder = void 0;
+    this.setMaxListeners(0);
+    this._recorder = recorder;
+    this._page = page;
+    this.wsEndpointForTest = 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({
+          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: (0, _utils.isUnderTest)(),
+        handleSIGINT: recorder.handleSIGINT,
+        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 setRunningFile(file) {
+    await this._page.mainFrame().evaluateExpression((file => {
+      window.playwrightSetRunningFile(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) {
+      if (process._didSetSourcesForTest(sources[0].text)) this.close();
+    }
+  }
+  async setActions(actions, sources) {}
+  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,116 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.RecorderCollection = void 0;
+var _events = require("events");
+var _time = require("../../utils/time");
+var _recorderUtils = require("./recorderUtils");
+var _errors = require("../errors");
+var _recorderRunner = require("./recorderRunner");
+var _debug = require("../../utils/debug");
+/**
+ * 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(pageAliases) {
+    super();
+    this._actions = [];
+    this._enabled = false;
+    this._pageAliases = void 0;
+    this._pageAliases = pageAliases;
+  }
+  restart() {
+    this._actions = [];
+    this._fireChange();
+  }
+  setEnabled(enabled) {
+    this._enabled = enabled;
+  }
+  async performAction(actionInContext) {
+    await this._addAction(actionInContext, async callMetadata => {
+      await (0, _recorderRunner.performAction)(callMetadata, this._pageAliases, actionInContext);
+    });
+  }
+  addRecordedAction(actionInContext) {
+    if (['openPage', 'closePage'].includes(actionInContext.action.name)) {
+      this._actions.push(actionInContext);
+      this._fireChange();
+      return;
+    }
+    this._addAction(actionInContext).catch(() => {});
+  }
+  async _addAction(actionInContext, callback) {
+    if (!this._enabled) return;
+    if (actionInContext.action.name === 'openPage' || actionInContext.action.name === 'closePage') {
+      this._actions.push(actionInContext);
+      this._fireChange();
+      return;
+    }
+    const {
+      callMetadata,
+      mainFrame
+    } = (0, _recorderUtils.callMetadataForAction)(this._pageAliases, actionInContext);
+    await mainFrame.instrumentation.onBeforeCall(mainFrame, callMetadata);
+    this._actions.push(actionInContext);
+    this._fireChange();
+    const error = await (callback === null || callback === void 0 ? void 0 : callback(callMetadata).catch(e => e));
+    callMetadata.endTime = (0, _time.monotonicTime)();
+    actionInContext.endTime = callMetadata.endTime;
+    callMetadata.error = error ? (0, _errors.serializeError)(error) : undefined;
+    // Do not wait for onAfterCall so that performAction returned immediately after the action.
+    mainFrame.instrumentation.onAfterCall(mainFrame, callMetadata).then(() => {
+      this._fireChange();
+    }).catch(() => {});
+  }
+  signal(pageAlias, frame, signal) {
+    if (!this._enabled) return;
+    if (signal.name === 'navigation' && frame._page.mainFrame() === frame) {
+      const timestamp = (0, _time.monotonicTime)();
+      const lastAction = this._actions[this._actions.length - 1];
+      const signalThreshold = (0, _debug.isUnderTest)() ? 500 : 5000;
+      let generateGoto = false;
+      if (!lastAction) generateGoto = true;else if (lastAction.action.name !== 'click' && lastAction.action.name !== 'press') generateGoto = true;else if (timestamp - lastAction.startTime > signalThreshold) generateGoto = true;
+      if (generateGoto) {
+        this.addRecordedAction({
+          frame: {
+            pageAlias,
+            framePath: []
+          },
+          action: {
+            name: 'navigate',
+            url: frame.url(),
+            signals: []
+          },
+          startTime: timestamp,
+          endTime: timestamp
+        });
+      }
+      return;
+    }
+    if (this._actions.length) {
+      this._actions[this._actions.length - 1].action.signals.push(signal);
+      this._fireChange();
+      return;
+    }
+  }
+  _fireChange() {
+    if (!this._enabled) return;
+    this.emit('change', (0, _recorderUtils.collapseActions)(this._actions));
+  }
+}
+exports.RecorderCollection = RecorderCollection;

package/lib/server/recorder/recorderFrontend.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/lib/server/recorder/recorderInTraceViewer.js

@@ -0,0 +1,144 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.RecorderInTraceViewer = void 0;
+var _path = _interopRequireDefault(require("path"));
+var _events = require("events");
+var _traceViewer = require("../trace/viewer/traceViewer");
+var _manualPromise = require("../../utils/manualPromise");
+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 RecorderInTraceViewer extends _events.EventEmitter {
+  static factory(context) {
+    return async recorder => {
+      const transport = new RecorderTransport();
+      const trace = _path.default.join(context._browser.options.tracesDir, 'trace');
+      const {
+        wsEndpointForTest,
+        tracePage,
+        traceServer
+      } = await openApp(trace, {
+        transport,
+        headless: !context._browser.options.headful
+      });
+      return new RecorderInTraceViewer(transport, tracePage, traceServer, wsEndpointForTest);
+    };
+  }
+  constructor(transport, tracePage, traceServer, wsEndpointForTest) {
+    super();
+    this.wsEndpointForTest = void 0;
+    this._transport = void 0;
+    this._tracePage = void 0;
+    this._traceServer = void 0;
+    this._transport = transport;
+    this._transport.eventSink.resolve(this);
+    this._tracePage = tracePage;
+    this._traceServer = traceServer;
+    this.wsEndpointForTest = wsEndpointForTest;
+    this._tracePage.once('close', () => {
+      this.close();
+    });
+  }
+  async close() {
+    await this._tracePage.context().close({
+      reason: 'Recorder window closed'
+    });
+    await this._traceServer.stop();
+  }
+  async setPaused(paused) {
+    this._transport.deliverEvent('setPaused', {
+      paused
+    });
+  }
+  async setMode(mode) {
+    this._transport.deliverEvent('setMode', {
+      mode
+    });
+  }
+  async setRunningFile(file) {
+    this._transport.deliverEvent('setRunningFile', {
+      file
+    });
+  }
+  async setSelector(selector, userGesture) {
+    this._transport.deliverEvent('setSelector', {
+      selector,
+      userGesture
+    });
+  }
+  async updateCallLogs(callLogs) {
+    this._transport.deliverEvent('updateCallLogs', {
+      callLogs
+    });
+  }
+  async setSources(sources) {
+    this._transport.deliverEvent('setSources', {
+      sources
+    });
+    if (process.env.PWTEST_CLI_IS_UNDER_TEST && sources.length) {
+      if (process._didSetSourcesForTest(sources[0].text)) this.close();
+    }
+  }
+  async setActions(actions, sources) {
+    this._transport.deliverEvent('setActions', {
+      actions,
+      sources
+    });
+  }
+}
+exports.RecorderInTraceViewer = RecorderInTraceViewer;
+async function openApp(trace, options) {
+  const traceServer = await (0, _traceViewer.startTraceViewerServer)(options);
+  await (0, _traceViewer.installRootRedirect)(traceServer, [trace], {
+    ...options,
+    webApp: 'recorder.html'
+  });
+  const page = await (0, _traceViewer.openTraceViewerApp)(traceServer.urlPrefix('precise'), 'chromium', options);
+  return {
+    wsEndpointForTest: page.context()._browser.options.wsEndpoint,
+    tracePage: page,
+    traceServer
+  };
+}
+class RecorderTransport {
+  constructor() {
+    this._connected = new _manualPromise.ManualPromise();
+    this.eventSink = new _manualPromise.ManualPromise();
+    this.sendEvent = void 0;
+    this.close = void 0;
+  }
+  onconnect() {
+    this._connected.resolve();
+  }
+  async dispatch(method, params) {
+    const eventSink = await this.eventSink;
+    eventSink.emit('event', {
+      event: method,
+      params
+    });
+  }
+  onclose() {}
+  deliverEvent(method, params) {
+    this._connected.then(() => {
+      var _this$sendEvent;
+      return (_this$sendEvent = this.sendEvent) === null || _this$sendEvent === void 0 ? void 0 : _this$sendEvent.call(this, method, params);
+    });
+  }
+}

package/lib/server/recorder/recorderRunner.js

@@ -0,0 +1,155 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.performAction = performAction;
+exports.toClickOptions = toClickOptions;
+var _utils = require("../../utils");
+var _language = require("../codegen/language");
+var _recorderUtils = require("./recorderUtils");
+var _recorderUtils2 = require("../../utils/isomorphic/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 performAction(callMetadata, pageAliases, actionInContext) {
+  const mainFrame = (0, _recorderUtils.mainFrameForAction)(pageAliases, actionInContext);
+  const {
+    action
+  } = actionInContext;
+  const kActionTimeout = 5000;
+  if (action.name === 'navigate') {
+    await mainFrame.goto(callMetadata, action.url, {
+      timeout: kActionTimeout
+    });
+    return;
+  }
+  if (action.name === 'openPage') throw Error('Not reached');
+  if (action.name === 'closePage') {
+    await mainFrame._page.close(callMetadata);
+    return;
+  }
+  const selector = (0, _recorderUtils2.buildFullSelector)(actionInContext.frame.framePath, action.selector);
+  if (action.name === 'click') {
+    const options = toClickOptions(action);
+    await mainFrame.click(callMetadata, selector, {
+      ...options,
+      timeout: kActionTimeout,
+      strict: true
+    });
+    return;
+  }
+  if (action.name === 'press') {
+    const modifiers = (0, _language.toKeyboardModifiers)(action.modifiers);
+    const shortcut = [...modifiers, action.key].join('+');
+    await mainFrame.press(callMetadata, selector, shortcut, {
+      timeout: kActionTimeout,
+      strict: true
+    });
+    return;
+  }
+  if (action.name === 'fill') {
+    await mainFrame.fill(callMetadata, selector, action.text, {
+      timeout: kActionTimeout,
+      strict: true
+    });
+    return;
+  }
+  if (action.name === 'setInputFiles') {
+    await mainFrame.setInputFiles(callMetadata, selector, {
+      selector,
+      payloads: [],
+      timeout: kActionTimeout,
+      strict: true
+    });
+    return;
+  }
+  if (action.name === 'check') {
+    await mainFrame.check(callMetadata, selector, {
+      timeout: kActionTimeout,
+      strict: true
+    });
+    return;
+  }
+  if (action.name === 'uncheck') {
+    await mainFrame.uncheck(callMetadata, selector, {
+      timeout: kActionTimeout,
+      strict: true
+    });
+    return;
+  }
+  if (action.name === 'select') {
+    const values = action.options.map(value => ({
+      value
+    }));
+    await mainFrame.selectOption(callMetadata, selector, [], values, {
+      timeout: kActionTimeout,
+      strict: true
+    });
+    return;
+  }
+  if (action.name === 'assertChecked') {
+    await mainFrame.expect(callMetadata, selector, {
+      selector,
+      expression: 'to.be.checked',
+      isNot: !action.checked,
+      timeout: kActionTimeout
+    });
+    return;
+  }
+  if (action.name === 'assertText') {
+    await mainFrame.expect(callMetadata, selector, {
+      selector,
+      expression: 'to.have.text',
+      expectedText: (0, _utils.serializeExpectedTextValues)([action.text], {
+        matchSubstring: true,
+        normalizeWhiteSpace: true
+      }),
+      isNot: false,
+      timeout: kActionTimeout
+    });
+    return;
+  }
+  if (action.name === 'assertValue') {
+    await mainFrame.expect(callMetadata, selector, {
+      selector,
+      expression: 'to.have.value',
+      expectedValue: action.value,
+      isNot: false,
+      timeout: kActionTimeout
+    });
+    return;
+  }
+  if (action.name === 'assertVisible') {
+    await mainFrame.expect(callMetadata, selector, {
+      selector,
+      expression: 'to.be.visible',
+      isNot: false,
+      timeout: kActionTimeout
+    });
+    return;
+  }
+  throw new Error('Internal error: unexpected action ' + action.name);
+}
+function toClickOptions(action) {
+  const modifiers = (0, _language.toKeyboardModifiers)(action.modifiers);
+  const options = {};
+  if (action.button !== 'left') options.button = action.button;
+  if (modifiers.length) options.modifiers = modifiers;
+  if (action.clickCount > 1) options.clickCount = action.clickCount;
+  if (action.position) options.position = action.position;
+  return options;
+}