rebrowser-playwright-core 1.47.100 → 1.49.0

package/lib/client/network.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.WebSocket = exports.RouteHandler = exports.Route = exports.Response = exports.Request = exports.RawHeaders = void 0;
+exports.WebSocketRouteHandler = exports.WebSocketRoute = 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");
@@ -17,7 +17,7 @@ var _events = require("./events");
 var _waiter = require("./waiter");
 var _fetch = require("./fetch");
 var _errors = require("./errors");
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+let _Symbol$asyncDispose;
 /**
  * Copyright (c) Microsoft Corporation.
  *
@@ -33,7 +33,7 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 class Request extends _channelOwner.ChannelOwner {
   static from(request) {
     return request._object;
@@ -203,6 +203,7 @@ class Route extends _channelOwner.ChannelOwner {
     this._handlingPromise = null;
     this._context = void 0;
     this._didThrow = false;
+    this.markAsInternalType();
   }
   request() {
     return Request.from(this._initializer.request);
@@ -225,7 +226,6 @@ class Route extends _channelOwner.ChannelOwner {
   async abort(errorCode) {
     await this._handleRoute(async () => {
       await this._raceWithTargetClose(this._channel.abort({
-        requestUrl: this.request()._initializer.url,
         errorCode
       }));
     });
@@ -302,7 +302,6 @@ class Route extends _channelOwner.ChannelOwner {
     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,
@@ -313,7 +312,7 @@ class Route extends _channelOwner.ChannelOwner {
   async continue(options = {}) {
     await this._handleRoute(async () => {
       this.request()._applyFallbackOverrides(options);
-      await this._innerContinue();
+      await this._innerContinue(false /* isFallback */);
     });
   }
   _checkNotHandled() {
@@ -324,21 +323,180 @@ class Route extends _channelOwner.ChannelOwner {
     this._handlingPromise = null;
     chain.resolve(done);
   }
-  async _innerContinue(internal = false) {
+  async _innerContinue(isFallback) {
     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);
+    return await this._raceWithTargetClose(this._channel.continue({
+      url: options.url,
+      method: options.method,
+      headers: options.headers ? (0, _utils.headersObjectToArray)(options.headers) : undefined,
+      postData: options.postDataBuffer,
+      isFallback
+    }));
   }
 }
 exports.Route = Route;
+_Symbol$asyncDispose = Symbol.asyncDispose;
+class WebSocketRoute extends _channelOwner.ChannelOwner {
+  static from(route) {
+    return route._object;
+  }
+  constructor(parent, type, guid, initializer) {
+    super(parent, type, guid, initializer);
+    this._onPageMessage = void 0;
+    this._onPageClose = void 0;
+    this._onServerMessage = void 0;
+    this._onServerClose = void 0;
+    this._server = void 0;
+    this._connected = false;
+    this.markAsInternalType();
+    this._server = {
+      onMessage: handler => {
+        this._onServerMessage = handler;
+      },
+      onClose: handler => {
+        this._onServerClose = handler;
+      },
+      connectToServer: () => {
+        throw new Error(`connectToServer must be called on the page-side WebSocketRoute`);
+      },
+      url: () => {
+        return this._initializer.url;
+      },
+      close: async (options = {}) => {
+        await this._channel.closeServer({
+          ...options,
+          wasClean: true
+        }).catch(() => {});
+      },
+      send: message => {
+        if ((0, _utils.isString)(message)) this._channel.sendToServer({
+          message,
+          isBase64: false
+        }).catch(() => {});else this._channel.sendToServer({
+          message: message.toString('base64'),
+          isBase64: true
+        }).catch(() => {});
+      },
+      async [Symbol.asyncDispose]() {
+        await this.close();
+      }
+    };
+    this._channel.on('messageFromPage', ({
+      message,
+      isBase64
+    }) => {
+      if (this._onPageMessage) this._onPageMessage(isBase64 ? Buffer.from(message, 'base64') : message);else if (this._connected) this._channel.sendToServer({
+        message,
+        isBase64
+      }).catch(() => {});
+    });
+    this._channel.on('messageFromServer', ({
+      message,
+      isBase64
+    }) => {
+      if (this._onServerMessage) this._onServerMessage(isBase64 ? Buffer.from(message, 'base64') : message);else this._channel.sendToPage({
+        message,
+        isBase64
+      }).catch(() => {});
+    });
+    this._channel.on('closePage', ({
+      code,
+      reason,
+      wasClean
+    }) => {
+      if (this._onPageClose) this._onPageClose(code, reason);else this._channel.closeServer({
+        code,
+        reason,
+        wasClean
+      }).catch(() => {});
+    });
+    this._channel.on('closeServer', ({
+      code,
+      reason,
+      wasClean
+    }) => {
+      if (this._onServerClose) this._onServerClose(code, reason);else this._channel.closePage({
+        code,
+        reason,
+        wasClean
+      }).catch(() => {});
+    });
+  }
+  url() {
+    return this._initializer.url;
+  }
+  async close(options = {}) {
+    await this._channel.closePage({
+      ...options,
+      wasClean: true
+    }).catch(() => {});
+  }
+  connectToServer() {
+    if (this._connected) throw new Error('Already connected to the server');
+    this._connected = true;
+    this._channel.connect().catch(() => {});
+    return this._server;
+  }
+  send(message) {
+    if ((0, _utils.isString)(message)) this._channel.sendToPage({
+      message,
+      isBase64: false
+    }).catch(() => {});else this._channel.sendToPage({
+      message: message.toString('base64'),
+      isBase64: true
+    }).catch(() => {});
+  }
+  onMessage(handler) {
+    this._onPageMessage = handler;
+  }
+  onClose(handler) {
+    this._onPageClose = handler;
+  }
+  async [_Symbol$asyncDispose]() {
+    await this.close();
+  }
+  async _afterHandle() {
+    if (this._connected) return;
+    // Ensure that websocket is "open" and can send messages without an actual server connection.
+    await this._channel.ensureOpened();
+  }
+}
+exports.WebSocketRoute = WebSocketRoute;
+class WebSocketRouteHandler {
+  constructor(baseURL, url, handler) {
+    this._baseURL = void 0;
+    this.url = void 0;
+    this.handler = void 0;
+    this._baseURL = baseURL;
+    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(wsURL) {
+    return (0, _utils.urlMatches)(this._baseURL, wsURL, this.url);
+  }
+  async handle(webSocketRoute) {
+    const handler = this.handler;
+    await handler(webSocketRoute);
+    await webSocketRoute._afterHandle();
+  }
+}
+exports.WebSocketRouteHandler = WebSocketRouteHandler;
 class Response extends _channelOwner.ChannelOwner {
   static from(response) {
     return response._object;
@@ -496,10 +654,12 @@ class RouteHandler {
     this.handler = void 0;
     this._ignoreException = false;
     this._activeInvocations = new Set();
+    this._svedZone = void 0;
     this._baseURL = baseURL;
     this._times = times;
     this.url = url;
     this.handler = handler;
+    this._svedZone = _utils.zones.currentZone();
   }
   static prepareInterceptionPatterns(handlers) {
     const patterns = [];
@@ -521,6 +681,9 @@ class RouteHandler {
     return (0, _utils.urlMatches)(this._baseURL, requestURL, this.url);
   }
   async handle(route) {
+    return await this._svedZone.run(async () => this._handleImpl(route));
+  }
+  async _handleImpl(route) {
     const handlerInvocation = {
       complete: new _manualPromise.ManualPromise(),
       route

package/lib/client/page.js

@@ -63,6 +63,7 @@ class Page extends _channelOwner.ChannelOwner {
     this._closedOrCrashedScope = new _utils.LongStandingScope();
     this._viewportSize = void 0;
     this._routes = [];
+    this._webSocketRoutes = [];
     this.accessibility = void 0;
     this.coverage = void 0;
     this.keyboard = void 0;
@@ -121,6 +122,9 @@ class Page extends _channelOwner.ChannelOwner {
     this._channel.on('route', ({
       route
     }) => this._onRoute(_network.Route.from(route)));
+    this._channel.on('webSocketRoute', ({
+      webSocketRoute
+    }) => this._onWebSocketRoute(_network.WebSocketRoute.from(webSocketRoute)));
     this._channel.on('video', ({
       artifact
     }) => {
@@ -166,6 +170,10 @@ class Page extends _channelOwner.ChannelOwner {
     }
     await this._browserContext._onRoute(route);
   }
+  async _onWebSocketRoute(webSocketRoute) {
+    const routeHandler = this._webSocketRoutes.find(route => route.matches(webSocketRoute.url()));
+    if (routeHandler) await routeHandler.handle(webSocketRoute);else await this._browserContext._onWebSocketRoute(webSocketRoute);
+  }
   async _onBinding(bindingCall) {
     const func = this._bindings.get(bindingCall._initializer.name);
     if (func) {
@@ -416,6 +424,9 @@ class Page extends _channelOwner.ChannelOwner {
       waitUntil
     })).response);
   }
+  async requestGC() {
+    await this._channel.requestGC();
+  }
   async emulateMedia(options = {}) {
     await this._channel.emulateMedia({
       media: options.media === null ? 'no-override' : options.media,
@@ -458,6 +469,10 @@ class Page extends _channelOwner.ChannelOwner {
     this._harRouters.push(harRouter);
     await harRouter.addPageRoute(this);
   }
+  async routeWebSocket(url, handler) {
+    this._webSocketRoutes.unshift(new _network.WebSocketRouteHandler(this._browserContext._options.baseURL, url, handler));
+    await this._updateWebSocketInterceptionPatterns();
+  }
   _disposeHarRouters() {
     this._harRouters.forEach(router => router.dispose());
     this._harRouters = [];
@@ -487,6 +502,12 @@ class Page extends _channelOwner.ChannelOwner {
       patterns
     });
   }
+  async _updateWebSocketInterceptionPatterns() {
+    const patterns = _network.WebSocketRouteHandler.prepareInterceptionPatterns(this._webSocketRoutes);
+    await this._channel.setWebSocketInterceptionPatterns({
+      patterns
+    });
+  }
   async screenshot(options = {}) {
     const copy = {
       ...options,
@@ -655,14 +676,16 @@ class Page extends _channelOwner.ChannelOwner {
   workers() {
     return [...this._workers];
   }
-  async pause() {
+  async pause(_options) {
     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 || _this$_instrumentatio.onWillPause();
+    (_this$_instrumentatio = this._instrumentation) === null || _this$_instrumentatio === void 0 || _this$_instrumentatio.onWillPause({
+      keepTestTimeout: !!(_options !== null && _options !== void 0 && _options.__testHookKeepTestTimeout)
+    });
     await this._closedOrCrashedScope.safeRace(this.context()._channel.pause());
     this._browserContext.setDefaultNavigationTimeout(defaultNavigationTimeout);
     this._browserContext.setDefaultTimeout(defaultTimeout);

package/lib/client/playwright.js

@@ -33,7 +33,8 @@ class Playwright extends _channelOwner.ChannelOwner {
     super(parent, type, guid, initializer);
     this._android = void 0;
     this._electron = void 0;
-    this._experimentalBidi = void 0;
+    this._bidiChromium = void 0;
+    this._bidiFirefox = void 0;
     this.chromium = void 0;
     this.firefox = void 0;
     this.webkit = void 0;
@@ -50,8 +51,10 @@ class Playwright extends _channelOwner.ChannelOwner {
     this.webkit._playwright = this;
     this._android = _android.Android.from(initializer.android);
     this._electron = _electron.Electron.from(initializer.electron);
-    this._experimentalBidi = _browserType.BrowserType.from(initializer.bidi);
-    this._experimentalBidi._playwright = this;
+    this._bidiChromium = _browserType.BrowserType.from(initializer.bidiChromium);
+    this._bidiChromium._playwright = this;
+    this._bidiFirefox = _browserType.BrowserType.from(initializer.bidiFirefox);
+    this._bidiFirefox._playwright = this;
     this.devices = (_this$_connection$loc = (_this$_connection$loc2 = this._connection.localUtils()) === null || _this$_connection$loc2 === void 0 ? void 0 : _this$_connection$loc2.devices) !== null && _this$_connection$loc !== void 0 ? _this$_connection$loc : {};
     this.selectors = new _selectors.Selectors();
     this.errors = {

package/lib/client/tracing.js

@@ -32,22 +32,22 @@ class Tracing extends _channelOwner.ChannelOwner {
     this._tracesDir = void 0;
     this._stacksId = void 0;
     this._isTracing = false;
+    this.markAsInternalType();
   }
   async start(options = {}) {
     this._includeSources = !!options.sources;
-    const traceName = await this._wrapApiCall(async () => {
-      await this._channel.tracingStart({
-        name: options.name,
-        snapshots: options.snapshots,
-        screenshots: options.screenshots,
-        live: options._live
-      });
-      const response = await this._channel.tracingStartChunk({
-        name: options.name,
-        title: options.title
-      });
-      return response.traceName;
-    }, true);
+    await this._channel.tracingStart({
+      name: options.name,
+      snapshots: options.snapshots,
+      screenshots: options.screenshots,
+      live: options._live
+    });
+    const {
+      traceName
+    } = await this._channel.tracingStartChunk({
+      name: options.name,
+      title: options.title
+    });
     await this._startCollectingStacks(traceName);
   }
   async startChunk(options = {}) {
@@ -56,6 +56,19 @@ class Tracing extends _channelOwner.ChannelOwner {
     } = await this._channel.tracingStartChunk(options);
     await this._startCollectingStacks(traceName);
   }
+  async group(name, options = {}) {
+    await this._wrapApiCall(async () => {
+      await this._channel.tracingGroup({
+        name,
+        location: options.location
+      });
+    }, false);
+  }
+  async groupEnd() {
+    await this._wrapApiCall(async () => {
+      await this._channel.tracingGroupEnd();
+    }, false);
+  }
   async _startCollectingStacks(traceName) {
     if (!this._isTracing) {
       this._isTracing = true;
@@ -68,15 +81,11 @@ class Tracing extends _channelOwner.ChannelOwner {
     this._stacksId = result.stacksId;
   }
   async stopChunk(options = {}) {
-    await this._wrapApiCall(async () => {
-      await this._doStopChunk(options.path);
-    }, true);
+    await this._doStopChunk(options.path);
   }
   async stop(options = {}) {
-    await this._wrapApiCall(async () => {
-      await this._doStopChunk(options.path);
-      await this._channel.tracingStop();
-    }, true);
+    await this._doStopChunk(options.path);
+    await this._channel.tracingStop();
   }
   async _doStopChunk(filePath) {
     this._resetStackCounter();

package/lib/client/waiter.js

@@ -32,8 +32,10 @@ class Waiter {
     this._channelOwner = void 0;
     this._waitId = void 0;
     this._error = void 0;
+    this._savedZone = void 0;
     this._waitId = (0, _utils.createGuid)();
     this._channelOwner = channelOwner;
+    this._savedZone = _utils.zones.currentZone();
     this._channelOwner._channel.waitForEventInfo({
       info: {
         waitId: this._waitId,
@@ -58,14 +60,14 @@ class Waiter {
     const {
       promise,
       dispose
-    } = waitForEvent(emitter, event, predicate);
+    } = waitForEvent(emitter, event, this._savedZone, predicate);
     return await this.waitForPromise(promise, dispose);
   }
   rejectOnEvent(emitter, event, error, predicate) {
     const {
       promise,
       dispose
-    } = waitForEvent(emitter, event, predicate);
+    } = waitForEvent(emitter, event, this._savedZone, predicate);
     this._rejectOn(promise.then(() => {
       throw typeof error === 'function' ? error() : error;
     }), dispose);
@@ -118,18 +120,20 @@ class Waiter {
   }
 }
 exports.Waiter = Waiter;
-function waitForEvent(emitter, event, predicate) {
+function waitForEvent(emitter, event, savedZone, 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);
-      }
+      await savedZone.run(async () => {
+        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);
   });