rebrowser-playwright-core 1.47.100 → 1.49.0

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 elementPicked(elementInfo, userGesture) {
+    this._transport.deliverEvent('elementPicked', {
+      elementInfo,
+      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

@@ -4,9 +4,11 @@ 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.
  *
@@ -23,125 +25,93 @@ var _recorderUtils = require("./recorderUtils");
  * 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();
+async function performAction(callMetadata, pageAliases, actionInContext) {
+  const mainFrame = (0, _recorderUtils.mainFrameForAction)(pageAliases, actionInContext);
   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 === 'navigate') {
+    await mainFrame.goto(callMetadata, action.url, {
+      timeout: kActionTimeout
+    });
+    return;
+  }
   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 === 'closePage') {
+    await mainFrame._page.close(callMetadata);
+    return;
+  }
+  const selector = (0, _recorderUtils2.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, {
+    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('+');
-    return await innerPerformAction(mainFrame, 'press', {
+    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,
-      key: shortcut
-    }, callMetadata => mainFrame.press(callMetadata, selector, shortcut, {
+      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 === '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, {
+    await mainFrame.selectOption(callMetadata, selector, [], values, {
       timeout: kActionTimeout,
       strict: true
-    }));
+    });
+    return;
   }
   if (action.name === 'assertChecked') {
-    return await innerPerformAction(mainFrame, 'expect', {
-      selector
-    }, callMetadata => mainFrame.expect(callMetadata, selector, {
+    await mainFrame.expect(callMetadata, selector, {
       selector,
       expression: 'to.be.checked',
       isNot: !action.checked,
       timeout: kActionTimeout
-    }));
+    });
+    return;
   }
   if (action.name === 'assertText') {
-    return await innerPerformAction(mainFrame, 'expect', {
-      selector
-    }, callMetadata => mainFrame.expect(callMetadata, selector, {
+    await mainFrame.expect(callMetadata, selector, {
       selector,
       expression: 'to.have.text',
       expectedText: (0, _utils.serializeExpectedTextValues)([action.text], {
@@ -150,28 +120,36 @@ async function performAction(pageAliases, actionInContext) {
       }),
       isNot: false,
       timeout: kActionTimeout
-    }));
+    });
+    return;
   }
   if (action.name === 'assertValue') {
-    return await innerPerformAction(mainFrame, 'expect', {
-      selector
-    }, callMetadata => mainFrame.expect(callMetadata, selector, {
+    await mainFrame.expect(callMetadata, selector, {
       selector,
       expression: 'to.have.value',
       expectedValue: action.value,
       isNot: false,
       timeout: kActionTimeout
-    }));
+    });
+    return;
   }
   if (action.name === 'assertVisible') {
-    return await innerPerformAction(mainFrame, 'expect', {
-      selector
-    }, callMetadata => mainFrame.expect(callMetadata, selector, {
+    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;
 }

package/lib/server/recorder/recorderUtils.js

@@ -3,10 +3,13 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.buildFullSelector = buildFullSelector;
+exports.callMetadataForAction = callMetadataForAction;
+exports.collapseActions = collapseActions;
 exports.frameForAction = frameForAction;
 exports.mainFrameForAction = mainFrameForAction;
 exports.metadataToCallLog = metadataToCallLog;
+var _utils = require("../../utils");
+var _recorderUtils = require("../../utils/isomorphic/recorderUtils");
 /**
  * Copyright (c) Microsoft Corporation.
  *
@@ -49,14 +52,11 @@ function metadataToCallLog(metadata, status) {
   };
   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');
+  if (!page) throw new Error(`Internal error: page ${pageAlias} not found in [${[...pageAliases.values()]}]`);
   return page.mainFrame();
 }
 async function frameForAction(pageAliases, actionInContext, action) {
@@ -64,8 +64,50 @@ async function frameForAction(pageAliases, actionInContext, action) {
   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 fullSelector = (0, _recorderUtils.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;
+}
+function callMetadataForAction(pageAliases, actionInContext) {
+  const mainFrame = mainFrameForAction(pageAliases, actionInContext);
+  const {
+    method,
+    apiName,
+    params
+  } = (0, _recorderUtils.traceParamsForAction)(actionInContext);
+  const callMetadata = {
+    id: `call@${(0, _utils.createGuid)()}`,
+    apiName,
+    objectId: mainFrame.guid,
+    pageId: mainFrame._page.guid,
+    frameId: mainFrame.guid,
+    startTime: actionInContext.startTime,
+    endTime: 0,
+    type: 'Frame',
+    method,
+    params,
+    log: []
+  };
+  return {
+    callMetadata,
+    mainFrame
+  };
+}
+function collapseActions(actions) {
+  const result = [];
+  for (const action of actions) {
+    const lastAction = result[result.length - 1];
+    const isSameAction = lastAction && lastAction.action.name === action.action.name && lastAction.frame.pageAlias === action.frame.pageAlias && lastAction.frame.framePath.join('|') === action.frame.framePath.join('|');
+    const isSameSelector = lastAction && 'selector' in lastAction.action && 'selector' in action.action && action.action.selector === lastAction.action.selector;
+    const shouldMerge = isSameAction && (action.action.name === 'navigate' || action.action.name === 'fill' && isSameSelector);
+    if (!shouldMerge) {
+      result.push(action);
+      continue;
+    }
+    const startTime = result[result.length - 1].startTime;
+    result[result.length - 1] = action;
+    result[result.length - 1].startTime = startTime;
+  }
+  return result;
 }