@editframe/api 0.12.0-beta.10 → 0.12.0-beta.12

package/dist/{api/src/resources → resources}/unprocessed-file.js

@@ -56,7 +56,7 @@ const createUnprocessedFile = async (client, payload) => {
 const uploadUnprocessedFile = async (client, uploadDetails, path) => {
   const { createReadStream } = await import("node:fs");
   const readStream = createReadStream(path);
-  const { createReadableStreamFromReadable } = await import("../../../cli/src/utils/createReadableStreamFromReadable.js");
+  const { createReadableStreamFromReadable } = await import("../utils/createReadableStreamFromReadable.js");
   return uploadUnprocessedReadableStream(
     client,
     uploadDetails,

package/dist/utils/createReadableStreamFromReadable.d.ts

@@ -0,0 +1,4 @@
+import { Readable } from 'node:stream';
+export declare const createReadableStreamFromReadable: (source: Readable & {
+    readableHighWaterMark?: number;
+}) => ReadableStream<Uint8Array>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@editframe/api",
-  "version": "0.12.0-beta.10",
+  "version": "0.12.0-beta.12",
   "description": "API functions for EditFrame",
   "exports": {
     ".": {
@@ -29,7 +29,7 @@
     "vite-tsconfig-paths": "^4.3.2"
   },
   "dependencies": {
-    "@editframe/assets": "0.12.0-beta.10",
+    "@editframe/assets": "0.12.0-beta.12",
     "debug": "^4.3.5",
     "jsonwebtoken": "^9.0.2",
     "node-fetch": "^3.3.2",

package/src/resources/unprocessed-file.ts

@@ -104,7 +104,7 @@ export const uploadUnprocessedFile = async (
   const readStream = createReadStream(path);
 
   const { createReadableStreamFromReadable } = await import(
-    "packages/cli/src/utils/createReadableStreamFromReadable.ts"
+    "../utils/createReadableStreamFromReadable.ts"
   );
 
   return uploadUnprocessedReadableStream(

package/src/utils/createReadableStreamFromReadable.ts

@@ -0,0 +1,117 @@
+import { type Readable, Stream } from "node:stream";
+
+export const createReadableStreamFromReadable = (
+  source: Readable & { readableHighWaterMark?: number },
+) => {
+  const pump = new StreamPump(source);
+  const stream = new ReadableStream(pump, pump);
+  return stream;
+};
+
+class StreamPump {
+  public highWaterMark: number;
+  public accumalatedSize: number;
+  private stream: Stream & {
+    readableHighWaterMark?: number;
+    readable?: boolean;
+    resume?: () => void;
+    pause?: () => void;
+    destroy?: (error?: Error) => void;
+  };
+  private controller?: ReadableStreamController<Uint8Array>;
+
+  constructor(
+    stream: Stream & {
+      readableHighWaterMark?: number;
+      readable?: boolean;
+      resume?: () => void;
+      pause?: () => void;
+      destroy?: (error?: Error) => void;
+    },
+  ) {
+    this.highWaterMark =
+      stream.readableHighWaterMark ||
+      new Stream.Readable().readableHighWaterMark;
+    this.accumalatedSize = 0;
+    this.stream = stream;
+    this.enqueue = this.enqueue.bind(this);
+    this.error = this.error.bind(this);
+    this.close = this.close.bind(this);
+  }
+
+  size(chunk: Uint8Array) {
+    return chunk?.byteLength || 0;
+  }
+
+  start(controller: ReadableStreamController<Uint8Array>) {
+    this.controller = controller;
+    this.stream.on("data", this.enqueue);
+    this.stream.once("error", this.error);
+    this.stream.once("end", this.close);
+    this.stream.once("close", this.close);
+  }
+
+  pull() {
+    this.resume();
+  }
+
+  cancel(reason?: Error) {
+    if (this.stream.destroy) {
+      this.stream.destroy(reason);
+    }
+
+    this.stream.off("data", this.enqueue);
+    this.stream.off("error", this.error);
+    this.stream.off("end", this.close);
+    this.stream.off("close", this.close);
+  }
+
+  enqueue(chunk: Uint8Array | string) {
+    if (this.controller) {
+      try {
+        const bytes = chunk instanceof Uint8Array ? chunk : Buffer.from(chunk);
+
+        const available = (this.controller.desiredSize || 0) - bytes.byteLength;
+        this.controller.enqueue(bytes);
+        if (available <= 0) {
+          this.pause();
+        }
+      } catch (error: any) {
+        this.controller.error(
+          new Error(
+            "Could not create Buffer, chunk must be of type string or an instance of Buffer, ArrayBuffer, or Array or an Array-like Object",
+          ),
+        );
+        this.cancel();
+      }
+    }
+  }
+
+  pause() {
+    if (this.stream.pause) {
+      this.stream.pause();
+    }
+  }
+
+  resume() {
+    if (this.stream.readable && this.stream.resume) {
+      this.stream.resume();
+    }
+  }
+
+  close() {
+    if (this.controller) {
+      this.controller.close();
+      // biome-ignore lint/performance/noDelete: infrequent use
+      delete this.controller;
+    }
+  }
+
+  error(error: Error) {
+    if (this.controller) {
+      this.controller.error(error);
+      // biome-ignore lint/performance/noDelete: infrequent use
+      delete this.controller;
+    }
+  }
+}