@checkly/playwright-core 1.48.22 → 1.51.11-beta.1

package/lib/client/waiter.js

@@ -4,9 +4,8 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.Waiter = void 0;
-var _stackTrace = require("../utils/stackTrace");
 var _errors = require("./errors");
-var _utils = require("../utils");
+var _stackTrace = require("../utils/isomorphic/stackTrace");
 /**
  * Copyright (c) Microsoft Corporation.
  *
@@ -32,8 +31,10 @@ class Waiter {
     this._channelOwner = void 0;
     this._waitId = void 0;
     this._error = void 0;
-    this._waitId = (0, _utils.createGuid)();
+    this._savedZone = void 0;
+    this._waitId = channelOwner._platform.createGuid();
     this._channelOwner = channelOwner;
+    this._savedZone = channelOwner._platform.zones.current().pop();
     this._channelOwner._channel.waitForEventInfo({
       info: {
         waitId: this._waitId,
@@ -58,14 +59,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);
@@ -109,8 +110,8 @@ class Waiter {
           phase: 'log',
           message: s
         }
-      }).catch(() => {});
-    }, true);
+      });
+    }, true).catch(() => {});
   }
   _rejectOn(promise, dispose) {
     this._failures.push(promise);
@@ -118,18 +119,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);
   });

package/lib/client/webSocket.js

@@ -0,0 +1,106 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.connectOverWebSocket = connectOverWebSocket;
+var _connection = require("./connection");
+/**
+ * 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 connectOverWebSocket(parentConnection, params) {
+  const localUtils = parentConnection.localUtils();
+  const transport = localUtils ? new JsonPipeTransport(localUtils) : new WebSocketTransport();
+  const connectHeaders = await transport.connect(params);
+  const connection = new _connection.Connection(parentConnection._platform, localUtils, parentConnection._instrumentation, connectHeaders);
+  connection.markAsRemote();
+  connection.on('close', () => transport.close());
+  let closeError;
+  const onTransportClosed = reason => {
+    connection.close(reason || closeError);
+  };
+  transport.onClose(reason => onTransportClosed(reason));
+  connection.onmessage = message => transport.send(message).catch(() => onTransportClosed());
+  transport.onMessage(message => {
+    try {
+      connection.dispatch(message);
+    } catch (e) {
+      closeError = String(e);
+      transport.close().catch(() => {});
+    }
+  });
+  return connection;
+}
+class JsonPipeTransport {
+  constructor(owner) {
+    this._pipe = void 0;
+    this._owner = void 0;
+    this._owner = owner;
+  }
+  async connect(params) {
+    const {
+      pipe,
+      headers: connectHeaders
+    } = await this._owner._wrapApiCall(async () => {
+      return await this._owner._channel.connect(params);
+    }, /* isInternal */true);
+    this._pipe = pipe;
+    return connectHeaders;
+  }
+  async send(message) {
+    await this._owner._wrapApiCall(async () => {
+      await this._pipe.send({
+        message
+      });
+    }, /* isInternal */true);
+  }
+  onMessage(callback) {
+    this._pipe.on('message', ({
+      message
+    }) => callback(message));
+  }
+  onClose(callback) {
+    this._pipe.on('closed', ({
+      reason
+    }) => callback(reason));
+  }
+  async close() {
+    await this._owner._wrapApiCall(async () => {
+      await this._pipe.close().catch(() => {});
+    }, /* isInternal */true);
+  }
+}
+class WebSocketTransport {
+  constructor() {
+    this._ws = void 0;
+  }
+  async connect(params) {
+    this._ws = new window.WebSocket(params.wsEndpoint);
+    return [];
+  }
+  async send(message) {
+    this._ws.send(JSON.stringify(message));
+  }
+  onMessage(callback) {
+    this._ws.addEventListener('message', event => callback(JSON.parse(event.data)));
+  }
+  onClose(callback) {
+    this._ws.addEventListener('close', () => callback());
+  }
+  async close() {
+    this._ws.close();
+  }
+}

package/lib/client/worker.js

@@ -4,11 +4,11 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.Worker = void 0;
-var _events = require("./events");
 var _channelOwner = require("./channelOwner");
-var _jsHandle = require("./jsHandle");
-var _utils = require("../utils");
 var _errors = require("./errors");
+var _events = require("./events");
+var _jsHandle = require("./jsHandle");
+var _manualPromise = require("../utils/isomorphic/manualPromise");
 /**
  * Copyright (c) Microsoft Corporation.
  *
@@ -35,7 +35,7 @@ class Worker extends _channelOwner.ChannelOwner {
     // Set for web workers.
     this._context = void 0;
     // Set for service workers.
-    this._closedScope = new _utils.LongStandingScope();
+    this._closedScope = new _manualPromise.LongStandingScope();
     this._channel.on('close', () => {
       if (this._page) this._page._workers.delete(this);
       if (this._context) this._context._serviceWorkers.delete(this);

package/lib/client/writableStream.js

@@ -4,7 +4,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.WritableStream = void 0;
-var _stream = require("stream");
 var _channelOwner = require("./channelOwner");
 /**
  * Copyright (c) Microsoft Corporation.
@@ -30,25 +29,7 @@ class WritableStream extends _channelOwner.ChannelOwner {
     super(parent, type, guid, initializer);
   }
   stream() {
-    return new WritableStreamImpl(this._channel);
+    return this._platform.streamWritable(this._channel);
   }
 }
-exports.WritableStream = WritableStream;
-class WritableStreamImpl extends _stream.Writable {
-  constructor(channel) {
-    super();
-    this._channel = void 0;
-    this._channel = channel;
-  }
-  async _write(chunk, encoding, callback) {
-    const error = await this._channel.write({
-      binary: typeof chunk === 'string' ? Buffer.from(chunk) : chunk
-    }).catch(e => e);
-    callback(error || null);
-  }
-  async _final(callback) {
-    // Stream might be destroyed after the connection was closed.
-    const error = await this._channel.close().catch(e => e);
-    callback(error || null);
-  }
-}
+exports.WritableStream = WritableStream;