@checkly/playwright-core 1.47.20-alpha → 1.48.20

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

@@ -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,49 @@ 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,
+    params
+  } = (0, _recorderUtils.traceParamsForAction)(actionInContext);
+  const callMetadata = {
+    id: `call@${(0, _utils.createGuid)()}`,
+    apiName: 'page.' + method,
+    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;
 }

package/lib/server/recorder.js

@@ -12,6 +12,7 @@ var _browserContext = require("./browserContext");
 var _debugger = require("./debugger");
 var _contextRecorder = require("./recorder/contextRecorder");
 var _recorderUtils = require("./recorder/recorderUtils");
+var _recorderUtils2 = require("../utils/isomorphic/recorderUtils");
 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; }
 /**
@@ -32,26 +33,29 @@ function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e;
 
 const recorderSymbol = Symbol('recorderSymbol');
 class Recorder {
-  static showInspector(context, recorderAppFactory) {
-    const params = {};
+  static async showInspector(context, params, recorderAppFactory) {
     if ((0, _utils.isUnderTest)()) params.language = process.env.TEST_INSPECTOR_LANGUAGE;
-    Recorder.show(context, recorderAppFactory, params).catch(() => {});
+    return await Recorder.show('actions', context, recorderAppFactory, params);
   }
-  static show(context, recorderAppFactory, params = {}) {
+  static showInspectorNoReply(context, recorderAppFactory) {
+    Recorder.showInspector(context, {}, recorderAppFactory).catch(() => {});
+  }
+  static show(codegenMode, context, recorderAppFactory, params) {
     let recorderPromise = context[recorderSymbol];
     if (!recorderPromise) {
-      recorderPromise = Recorder._create(context, recorderAppFactory, params);
+      recorderPromise = Recorder._create(codegenMode, context, recorderAppFactory, params);
       context[recorderSymbol] = recorderPromise;
     }
     return recorderPromise;
   }
-  static async _create(context, recorderAppFactory, params = {}) {
-    const recorder = new Recorder(context, params);
+  static async _create(codegenMode, context, recorderAppFactory, params = {}) {
+    const recorder = new Recorder(codegenMode, context, params);
     const recorderApp = await recorderAppFactory(recorder);
     await recorder._install(recorderApp);
     return recorder;
   }
-  constructor(context, params) {
+  constructor(codegenMode, context, params) {
+    this.handleSIGINT = void 0;
     this._context = void 0;
     this._mode = void 0;
     this._highlightedSelector = '';
@@ -67,7 +71,8 @@ class Recorder {
     this._omitCallTracking = false;
     this._currentLanguage = void 0;
     this._mode = params.mode || 'none';
-    this._contextRecorder = new _contextRecorder.ContextRecorder(context, params, {});
+    this.handleSIGINT = params.handleSIGINT;
+    this._contextRecorder = new _contextRecorder.ContextRecorder(codegenMode, context, params, {});
     this._context = context;
     this._omitCallTracking = !!params.omitCallTracking;
     this._debugger = context.debugger();
@@ -123,10 +128,10 @@ class Recorder {
       (_this$_recorderApp = this._recorderApp) === null || _this$_recorderApp === void 0 || _this$_recorderApp.close().catch(() => {});
     });
     this._contextRecorder.on(_contextRecorder.ContextRecorder.Events.Change, data => {
-      var _this$_recorderApp2;
       this._recorderSources = data.sources;
+      recorderApp.setActions(data.actions, data.sources);
+      recorderApp.setRunningFile(undefined);
       this._pushAllSources();
-      (_this$_recorderApp2 = this._recorderApp) === null || _this$_recorderApp2 === void 0 || _this$_recorderApp2.setFileIfNeeded(data.primaryFileName);
     });
     await this._context.exposeBinding('__pw_recorderState', false, source => {
       let actionSelector = '';
@@ -154,9 +159,9 @@ class Recorder {
     await this._context.exposeBinding('__pw_recorderSetSelector', false, async ({
       frame
     }, selector) => {
-      var _this$_recorderApp3;
+      var _this$_recorderApp2;
       const selectorChain = await (0, _contextRecorder.generateFrameSelector)(frame);
-      await ((_this$_recorderApp3 = this._recorderApp) === null || _this$_recorderApp3 === void 0 ? void 0 : _this$_recorderApp3.setSelector((0, _recorderUtils.buildFullSelector)(selectorChain, selector), true));
+      await ((_this$_recorderApp2 = this._recorderApp) === null || _this$_recorderApp2 === void 0 ? void 0 : _this$_recorderApp2.setSelector((0, _recorderUtils2.buildFullSelector)(selectorChain, selector), true));
     });
     await this._context.exposeBinding('__pw_recorderSetMode', false, async ({
       frame
@@ -180,7 +185,7 @@ class Recorder {
     this._context.recorderAppForTest = this._recorderApp;
   }
   _pausedStateChanged() {
-    var _this$_recorderApp4;
+    var _this$_recorderApp3;
     // If we are called upon page.pause, we don't have metadatas, populate them.
     for (const {
       metadata,
@@ -188,16 +193,16 @@ class Recorder {
     } of this._debugger.pausedDetails()) {
       if (!this._currentCallsMetadata.has(metadata)) this.onBeforeCall(sdkObject, metadata);
     }
-    (_this$_recorderApp4 = this._recorderApp) === null || _this$_recorderApp4 === void 0 || _this$_recorderApp4.setPaused(this._debugger.isPaused());
+    (_this$_recorderApp3 = this._recorderApp) === null || _this$_recorderApp3 === void 0 || _this$_recorderApp3.setPaused(this._debugger.isPaused());
     this._updateUserSources();
     this.updateCallLog([...this._currentCallsMetadata.keys()]);
   }
   setMode(mode) {
-    var _this$_recorderApp5;
+    var _this$_recorderApp4;
     if (this._mode === mode) return;
     this._highlightedSelector = '';
     this._mode = mode;
-    (_this$_recorderApp5 = this._recorderApp) === null || _this$_recorderApp5 === void 0 || _this$_recorderApp5.setMode(this._mode);
+    (_this$_recorderApp4 = this._recorderApp) === null || _this$_recorderApp4 === void 0 || _this$_recorderApp4.setMode(this._mode);
     this._contextRecorder.setEnabled(this._mode === 'recording' || this._mode === 'assertingText' || this._mode === 'assertingVisibility' || this._mode === 'assertingValue');
     this._debugger.setMuted(this._mode === 'recording' || this._mode === 'assertingText' || this._mode === 'assertingVisibility' || this._mode === 'assertingValue');
     if (this._mode !== 'none' && this._mode !== 'standby' && this._context.pages().length === 1) this._context.pages()[0].bringToFront().catch(() => {});
@@ -231,9 +236,9 @@ class Recorder {
     if (isScreenshotCommand(metadata)) {
       this.hideHighlightedSelector();
     } else if (metadata.params && metadata.params.selector) {
-      var _this$_recorderApp6;
+      var _this$_recorderApp5;
       this._highlightedSelector = metadata.params.selector;
-      (_this$_recorderApp6 = this._recorderApp) === null || _this$_recorderApp6 === void 0 || _this$_recorderApp6.setSelector(this._highlightedSelector).catch(() => {});
+      (_this$_recorderApp5 = this._recorderApp) === null || _this$_recorderApp5 === void 0 || _this$_recorderApp5.setSelector(this._highlightedSelector).catch(() => {});
     }
   }
   async onAfterCall(sdkObject, metadata) {
@@ -243,7 +248,7 @@ class Recorder {
     this.updateCallLog([metadata]);
   }
   _updateUserSources() {
-    var _this$_recorderApp7;
+    var _this$_recorderApp6;
     // Remove old decorations.
     for (const source of this._userSources.values()) {
       source.highlight = [];
@@ -281,18 +286,18 @@ class Recorder {
       }
     }
     this._pushAllSources();
-    if (fileToSelect) (_this$_recorderApp7 = this._recorderApp) === null || _this$_recorderApp7 === void 0 || _this$_recorderApp7.setFileIfNeeded(fileToSelect);
+    if (fileToSelect) (_this$_recorderApp6 = this._recorderApp) === null || _this$_recorderApp6 === void 0 || _this$_recorderApp6.setRunningFile(fileToSelect);
   }
   _pushAllSources() {
-    var _this$_recorderApp8;
-    (_this$_recorderApp8 = this._recorderApp) === null || _this$_recorderApp8 === void 0 || _this$_recorderApp8.setSources([...this._recorderSources, ...this._userSources.values()]);
+    var _this$_recorderApp7;
+    (_this$_recorderApp7 = this._recorderApp) === null || _this$_recorderApp7 === void 0 || _this$_recorderApp7.setSources([...this._recorderSources, ...this._userSources.values()]);
   }
   async onBeforeInputAction(sdkObject, metadata) {}
   async onCallLog(sdkObject, metadata, logName, message) {
     this.updateCallLog([metadata]);
   }
   updateCallLog(metadatas) {
-    var _this$_recorderApp9;
+    var _this$_recorderApp8;
     if (this._mode === 'recording' || this._mode === 'assertingText' || this._mode === 'assertingVisibility' || this._mode === 'assertingValue') return;
     const logs = [];
     for (const metadata of metadatas) {
@@ -302,7 +307,7 @@ class Recorder {
       if (this._debugger.isPaused(metadata)) status = 'paused';
       logs.push((0, _recorderUtils.metadataToCallLog)(metadata, status));
     }
-    (_this$_recorderApp9 = this._recorderApp) === null || _this$_recorderApp9 === void 0 || _this$_recorderApp9.updateCallLogs(logs);
+    (_this$_recorderApp8 = this._recorderApp) === null || _this$_recorderApp8 === void 0 || _this$_recorderApp8.updateCallLogs(logs);
   }
   _readSource(fileName) {
     try {