@eyepop.ai/eyepop 0.11.0 → 0.12.0

package/dist/index.d.mts

@@ -24,14 +24,26 @@ interface LiveIngress {
     close(): Promise<void>;
 }
 interface IngressEvent {
-    readonly ingressId?: string;
-    readonly event?: "stream-ready" | "stream-ready";
+    readonly ingressId: string;
+    readonly event: "stream-ready" | "stream-ready";
 }
-interface UploadParams {
-    readonly filePath?: string | undefined;
-    readonly file?: File | undefined;
-    readonly mimeType?: string | undefined;
+interface FileSource {
+    readonly file: File;
 }
+interface StreamSource {
+    readonly stream: ReadableStream<Uint8Array>;
+    readonly mimeType: string;
+}
+interface PathSource {
+    readonly path: string;
+}
+interface LiveSource {
+    readonly ingressId: string;
+}
+interface UrlSource {
+    readonly url: string;
+}
+type Source = FileSource | StreamSource | PathSource | LiveSource | UrlSource;
 interface Prediction {
     timestamp: number;
     seconds: number;
@@ -145,9 +157,12 @@ declare class Endpoint {
     popId(): string | null;
     session(): Promise<SessionPlus>;
     liveIngress(stream: MediaStream): Promise<LiveIngress>;
-    upload(params: UploadParams): Promise<ResultStream>;
-    loadFrom(location: string): Promise<ResultStream>;
-    loadLiveIngress(ingressId: string): Promise<ResultStream>;
+    process(source: Source): Promise<ResultStream>;
+    private uploadFile;
+    private uploadStream;
+    private uploadPath;
+    private loadFrom;
+    private loadLiveIngress;
     connect(): Promise<Endpoint>;
     private jobDone;
     private updateState;
@@ -186,4 +201,4 @@ declare class EyePopSdk {
     static plot(context: CanvasRenderingContext2D): EyePopPlot;
 }
 
-export { EndpointState, EyePopSdk, type IngressEvent, type LiveIngress, type Point2d, type Point3d, type PredictedClass, type PredictedKeyPoint, type PredictedKeyPoints, type PredictedMesh, type PredictedObject, type Prediction, type ResultStream, type Session, type UploadParams, EyePopSdk as default };
+export { EndpointState, EyePopSdk, type FileSource, type IngressEvent, type LiveIngress, type LiveSource, type PathSource, type Point2d, type Point3d, type PredictedClass, type PredictedKeyPoint, type PredictedKeyPoints, type PredictedMesh, type PredictedObject, type Prediction, type ResultStream, type Session, type Source, type StreamSource, type UrlSource, EyePopSdk as default };

package/dist/index.d.ts

@@ -24,14 +24,26 @@ interface LiveIngress {
     close(): Promise<void>;
 }
 interface IngressEvent {
-    readonly ingressId?: string;
-    readonly event?: "stream-ready" | "stream-ready";
+    readonly ingressId: string;
+    readonly event: "stream-ready" | "stream-ready";
 }
-interface UploadParams {
-    readonly filePath?: string | undefined;
-    readonly file?: File | undefined;
-    readonly mimeType?: string | undefined;
+interface FileSource {
+    readonly file: File;
 }
+interface StreamSource {
+    readonly stream: ReadableStream<Uint8Array>;
+    readonly mimeType: string;
+}
+interface PathSource {
+    readonly path: string;
+}
+interface LiveSource {
+    readonly ingressId: string;
+}
+interface UrlSource {
+    readonly url: string;
+}
+type Source = FileSource | StreamSource | PathSource | LiveSource | UrlSource;
 interface Prediction {
     timestamp: number;
     seconds: number;
@@ -145,9 +157,12 @@ declare class Endpoint {
     popId(): string | null;
     session(): Promise<SessionPlus>;
     liveIngress(stream: MediaStream): Promise<LiveIngress>;
-    upload(params: UploadParams): Promise<ResultStream>;
-    loadFrom(location: string): Promise<ResultStream>;
-    loadLiveIngress(ingressId: string): Promise<ResultStream>;
+    process(source: Source): Promise<ResultStream>;
+    private uploadFile;
+    private uploadStream;
+    private uploadPath;
+    private loadFrom;
+    private loadLiveIngress;
     connect(): Promise<Endpoint>;
     private jobDone;
     private updateState;
@@ -186,4 +201,4 @@ declare class EyePopSdk {
     static plot(context: CanvasRenderingContext2D): EyePopPlot;
 }
 
-export { EndpointState, EyePopSdk, type IngressEvent, type LiveIngress, type Point2d, type Point3d, type PredictedClass, type PredictedKeyPoint, type PredictedKeyPoints, type PredictedMesh, type PredictedObject, type Prediction, type ResultStream, type Session, type UploadParams, EyePopSdk as default };
+export { EndpointState, EyePopSdk, type FileSource, type IngressEvent, type LiveIngress, type LiveSource, type PathSource, type Point2d, type Point3d, type PredictedClass, type PredictedKeyPoint, type PredictedKeyPoints, type PredictedMesh, type PredictedObject, type Prediction, type ResultStream, type Session, type Source, type StreamSource, type UrlSource, EyePopSdk as default };

package/dist/index.js

@@ -8944,7 +8944,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) {
@@ -8973,7 +8973,7 @@ var AbstractJob = class {
               reject(`response body is empty`);
               break;
             } else {
-              resolve2(response.body);
+              resolve(response.body);
               break;
             }
           } catch (error) {
@@ -9509,7 +9509,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":
@@ -9517,7 +9517,7 @@ var Whip = class _Whip extends WebRtcBase {
             reject(`peer connection: ${pc.iceConnectionState}`);
             break;
           case "connected":
-            resolve2(this);
+            resolve(this);
             break;
         }
       };
@@ -9634,44 +9634,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;
   };
 }
 
@@ -9785,59 +9763,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() {