@eyepop.ai/eyepop 0.11.0 → 0.12.0

package/dist/index.mjs

@@ -8915,7 +8915,7 @@ var AbstractJob = class {
     return Promise.reject("abstract class");
   }
   start(done, status) {
-    this._responseStream = new Promise(async (resolve2, reject) => {
+    this._responseStream = new Promise(async (resolve, reject) => {
       try {
         let retries = 1;
         while (true) {
@@ -8944,7 +8944,7 @@ var AbstractJob = class {
               reject(`response body is empty`);
               break;
             } else {
-              resolve2(response.body);
+              resolve(response.body);
               break;
             }
           } catch (error) {
@@ -9480,7 +9480,7 @@ var Whip = class _Whip extends WebRtcBase {
     });
     this._pc = pc;
     pc.onicecandidate = (evt) => this.onLocalCandidate(evt);
-    return new Promise(async (resolve2, reject) => {
+    return new Promise(async (resolve, reject) => {
       pc.oniceconnectionstatechange = () => {
         switch (pc.iceConnectionState) {
           case "failed":
@@ -9488,7 +9488,7 @@ var Whip = class _Whip extends WebRtcBase {
             reject(`peer connection: ${pc.iceConnectionState}`);
             break;
           case "connected":
-            resolve2(this);
+            resolve(this);
             break;
         }
       };
@@ -9605,44 +9605,22 @@ var Whip = class _Whip extends WebRtcBase {
 };
 
 // src/shims/local_file.ts
-var resolve;
+var resolvePath;
 if ("document" in globalThis && "implementation" in globalThis.document) {
-  const isFileLike = (value) => value != null && typeof value === "object" && typeof value.name === "string" && typeof value.lastModified === "number";
-  resolve = async (params) => {
-    if (params.file) {
-      if (isFileLike(params.file)) {
-        params = {
-          mimeType: params.file.type,
-          file: params.file
-        };
-        return params;
-      }
-    }
+  resolvePath = async (source) => {
     throw new DOMException("resolving a path to a file is not supported in browser");
   };
 } else {
-  resolve = async (params) => {
-    if (params.file) {
-      return params;
-    }
+  resolvePath = async (source) => {
     const mime = require_mime_types();
-    const fs = __require("fs");
-    let mimeType;
-    let stream;
-    if (params.filePath) {
-      if (params.mimeType) {
-        mimeType = params.mimeType;
-      } else {
-        mimeType = mime.lookup(params.filePath) || void 0;
-      }
-      stream = fs.createReadStream(params.filePath);
-    }
-    params = {
-      filePath: params.filePath,
-      mimeType,
-      file: stream
+    const filehandle = __require("fs/promises");
+    const fd = await filehandle.open(source.path, "r");
+    const stream = fd.createReadStream();
+    const mimeType = mime.lookup(source.path) || "application/octet-stream";
+    return {
+      stream,
+      mimeType
     };
-    return params;
   };
 }
 
@@ -9756,59 +9734,126 @@ var Endpoint = class {
     if (!this._baseUrl || !this._client) {
       return Promise.reject("endpoint not connected, use connect() before ingress()");
     }
-    const job = new Whip(stream, async () => {
+    const whip = new Whip(stream, async () => {
       return this.session();
     }, this._client, this._requestLogger);
-    return job.start();
+    return whip.start();
+  }
+  async process(source) {
+    if (source.file !== void 0) {
+      return this.uploadFile(source);
+    } else if (source.stream !== void 0) {
+      return this.uploadStream(source);
+    } else if (source.path !== void 0) {
+      return this.uploadPath(source);
+    } else if (source.url !== void 0) {
+      return this.loadFrom(source);
+    } else if (source.ingressId !== void 0) {
+      return this.loadLiveIngress(source);
+    } else {
+      return Promise.reject("unknown source type");
+    }
   }
-  async upload(params) {
+  async uploadFile(source) {
     if (!this._baseUrl || !this._pipelineId || !this._client || !this._limit) {
       return Promise.reject("endpoint not connected, use connect() before upload()");
     }
-    params = await resolve(params);
-    if (!params.mimeType) {
-      return Promise.reject("upload for streams requires a mimeType");
+    await this._limit.acquire();
+    try {
+      this.updateState();
+      const job = new UploadJob(source.file, source.file.type, async () => {
+        return this.session();
+      }, this._client, this._requestLogger);
+      return job.start(() => {
+        this.jobDone(job);
+      }, (statusCode) => {
+        this.jobStatus(job, statusCode);
+      });
+    } catch (e) {
+      this._limit.release();
+      throw e;
+    }
+  }
+  async uploadStream(source) {
+    if (!this._baseUrl || !this._pipelineId || !this._client || !this._limit) {
+      return Promise.reject("endpoint not connected, use connect() before upload()");
     }
     await this._limit.acquire();
-    this.updateState();
-    const job = new UploadJob(params.file, params.mimeType, async () => {
-      return this.session();
-    }, this._client, this._requestLogger);
-    return job.start(() => {
-      this.jobDone(job);
-    }, (statusCode) => {
-      this.jobStatus(job, statusCode);
-    });
+    try {
+      this.updateState();
+      const job = new UploadJob(source.stream, source.mimeType, async () => {
+        return this.session();
+      }, this._client, this._requestLogger);
+      return job.start(() => {
+        this.jobDone(job);
+      }, (statusCode) => {
+        this.jobStatus(job, statusCode);
+      });
+    } catch (e) {
+      this._limit.release();
+      throw e;
+    }
   }
-  async loadFrom(location) {
+  async uploadPath(source) {
+    if (!this._baseUrl || !this._pipelineId || !this._client || !this._limit) {
+      throw new Error("endpoint not connected, use connect() before process()");
+    }
+    await this._limit.acquire();
+    try {
+      this.updateState();
+      const streamSource = await resolvePath(source);
+      const job = new UploadJob(streamSource.stream, streamSource.mimeType, async () => {
+        return this.session();
+      }, this._client, this._requestLogger);
+      return job.start(() => {
+        this.jobDone(job);
+      }, (statusCode) => {
+        this.jobStatus(job, statusCode);
+      });
+    } catch (e) {
+      this._limit.release();
+      throw e;
+    }
+  }
+  async loadFrom(source) {
     if (!this._baseUrl || !this._pipelineId || !this._client || !this._limit) {
       throw new Error("endpoint not connected, use connect() before loadFrom()");
     }
     await this._limit.acquire();
-    this.updateState();
-    const job = new LoadFromJob(location, async () => {
-      return this.session();
-    }, this._client, this._requestLogger);
-    return job.start(() => {
-      this.jobDone(job);
-    }, (statusCode) => {
-      this.jobStatus(job, statusCode);
-    });
+    try {
+      this.updateState();
+      const job = new LoadFromJob(source.url, async () => {
+        return this.session();
+      }, this._client, this._requestLogger);
+      return job.start(() => {
+        this.jobDone(job);
+      }, (statusCode) => {
+        this.jobStatus(job, statusCode);
+      });
+    } catch (e) {
+      this._limit.release();
+      throw e;
+    }
   }
-  async loadLiveIngress(ingressId) {
+  async loadLiveIngress(source) {
     if (!this._baseUrl || !this._pipelineId || !this._client || !this._limit) {
       throw new Error("endpoint not connected, use connect() before loadLiveIngress()");
     }
     await this._limit.acquire();
-    this.updateState();
-    const job = new LoadLiveIngressJob(ingressId, async () => {
-      return this.session();
-    }, this._client, this._requestLogger);
-    return job.start(() => {
-      this.jobDone(job);
-    }, (statusCode) => {
-      this.jobStatus(job, statusCode);
-    });
+    try {
+      this.updateState();
+      const job = new LoadLiveIngressJob(source.ingressId, async () => {
+        return this.session();
+      }, this._client, this._requestLogger);
+      return job.start(() => {
+        this.jobDone(job);
+      }, (statusCode) => {
+        this.jobStatus(job, statusCode);
+      });
+    } catch (e) {
+      this._limit.release();
+      throw e;
+    }
   }
   // noinspection TypeScriptValidateTypes
   async connect() {