@checkly/playwright-core 1.51.17-beta.2 → 1.54.2-beta.0

package/lib/server/dispatchers/artifactDispatcher.js

@@ -1,118 +1,118 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var artifactDispatcher_exports = {};
+__export(artifactDispatcher_exports, {
+  ArtifactDispatcher: () => ArtifactDispatcher
 });
-exports.ArtifactDispatcher = void 0;
-var _fs = _interopRequireDefault(require("fs"));
-var _dispatcher = require("./dispatcher");
-var _streamDispatcher = require("./streamDispatcher");
-var _fileUtils = require("../utils/fileUtils");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-/**
- * 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 ArtifactDispatcher extends _dispatcher.Dispatcher {
+module.exports = __toCommonJS(artifactDispatcher_exports);
+var import_fs = __toESM(require("fs"));
+var import_dispatcher = require("./dispatcher");
+var import_streamDispatcher = require("./streamDispatcher");
+var import_fileUtils = require("../utils/fileUtils");
+class ArtifactDispatcher extends import_dispatcher.Dispatcher {
+  constructor(scope, artifact) {
+    super(scope, artifact, "Artifact", {
+      absolutePath: artifact.localPath()
+    });
+    this._type_Artifact = true;
+  }
   static from(parentScope, artifact) {
     return ArtifactDispatcher.fromNullable(parentScope, artifact);
   }
   static fromNullable(parentScope, artifact) {
-    if (!artifact) return undefined;
-    const result = (0, _dispatcher.existingDispatcher)(artifact);
+    if (!artifact)
+      return void 0;
+    const result = parentScope.connection.existingDispatcher(artifact);
     return result || new ArtifactDispatcher(parentScope, artifact);
   }
-  constructor(scope, artifact) {
-    super(scope, artifact, 'Artifact', {
-      absolutePath: artifact.localPath()
-    });
-    this._type_Artifact = true;
-  }
-  async pathAfterFinished() {
-    const path = await this._object.localPathAfterFinished();
-    return {
-      value: path
-    };
+  async pathAfterFinished(params, progress) {
+    const path = await progress.race(this._object.localPathAfterFinished());
+    return { value: path };
   }
-  async saveAs(params) {
-    return await new Promise((resolve, reject) => {
+  async saveAs(params, progress) {
+    return await progress.race(new Promise((resolve, reject) => {
       this._object.saveAs(async (localPath, error) => {
         if (error) {
           reject(error);
           return;
         }
         try {
-          await (0, _fileUtils.mkdirIfNeeded)(params.path);
-          await _fs.default.promises.copyFile(localPath, params.path);
+          await (0, import_fileUtils.mkdirIfNeeded)(params.path);
+          await import_fs.default.promises.copyFile(localPath, params.path);
           resolve();
         } catch (e) {
           reject(e);
         }
       });
-    });
+    }));
   }
-  async saveAsStream() {
-    return await new Promise((resolve, reject) => {
+  async saveAsStream(params, progress) {
+    return await progress.race(new Promise((resolve, reject) => {
       this._object.saveAs(async (localPath, error) => {
         if (error) {
           reject(error);
           return;
         }
         try {
-          const readable = _fs.default.createReadStream(localPath, {
-            highWaterMark: 1024 * 1024
-          });
-          const stream = new _streamDispatcher.StreamDispatcher(this, readable);
-          // Resolve with a stream, so that client starts saving the data.
-          resolve({
-            stream
-          });
-          // Block the Artifact until the stream is consumed.
-          await new Promise(resolve => {
-            readable.on('close', resolve);
-            readable.on('end', resolve);
-            readable.on('error', resolve);
+          const readable = import_fs.default.createReadStream(localPath, { highWaterMark: 1024 * 1024 });
+          const stream = new import_streamDispatcher.StreamDispatcher(this, readable);
+          resolve({ stream });
+          await new Promise((resolve2) => {
+            readable.on("close", resolve2);
+            readable.on("end", resolve2);
+            readable.on("error", resolve2);
           });
         } catch (e) {
           reject(e);
         }
       });
-    });
+    }));
   }
-  async stream() {
-    const fileName = await this._object.localPathAfterFinished();
-    const readable = _fs.default.createReadStream(fileName, {
-      highWaterMark: 1024 * 1024
-    });
-    return {
-      stream: new _streamDispatcher.StreamDispatcher(this, readable)
-    };
+  async stream(params, progress) {
+    const fileName = await progress.race(this._object.localPathAfterFinished());
+    const readable = import_fs.default.createReadStream(fileName, { highWaterMark: 1024 * 1024 });
+    return { stream: new import_streamDispatcher.StreamDispatcher(this, readable) };
   }
-  async failure() {
-    const error = await this._object.failureError();
-    return {
-      error: error || undefined
-    };
+  async failure(params, progress) {
+    const error = await progress.race(this._object.failureError());
+    return { error: error || void 0 };
   }
-  async cancel() {
-    await this._object.cancel();
+  async cancel(params, progress) {
+    await progress.race(this._object.cancel());
   }
-  async delete(_, metadata) {
-    metadata.potentiallyClosesScope = true;
-    await this._object.delete();
+  async delete(params, progress) {
+    progress.metadata.potentiallyClosesScope = true;
+    await progress.race(this._object.delete());
     this._dispose();
   }
 }
-exports.ArtifactDispatcher = ArtifactDispatcher;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ArtifactDispatcher
+});