@editframe/api 0.16.8-beta.0 → 0.17.6-beta.0

package/dist/resources/unprocessed-file.js

@@ -1,81 +1,45 @@
+import { uploadChunks } from "../uploadChunks.js";
+import { assertTypesMatch } from "../utils/assertTypesMatch.js";
 import debug from "debug";
 import { z } from "zod";
-import { uploadChunks } from "../uploadChunks.js";
 const log = debug("ef:api:unprocessed-file");
 const MAX_FILE_SIZE = 1024 * 1024 * 1024;
 const CreateUnprocessedFilePayload = z.object({
-  md5: z.string(),
-  filename: z.string(),
-  byte_size: z.number().int().max(MAX_FILE_SIZE)
+	md5: z.string(),
+	filename: z.string(),
+	byte_size: z.number().int().max(MAX_FILE_SIZE)
 });
-z.object({});
+const UpdateUnprocessedFilePayload = z.object({});
+assertTypesMatch(true);
 const createUnprocessedFile = async (client, payload) => {
-  log("Creating an unprocessed file", payload);
-  CreateUnprocessedFilePayload.parse(payload);
-  const response = await client.authenticatedFetch(
-    "/api/v1/unprocessed_files",
-    {
-      method: "POST",
-      body: JSON.stringify(payload)
-    }
-  );
-  log(
-    "Unprocessed file created",
-    response.status,
-    response.statusText,
-    response.headers
-  );
-  if (response.ok) {
-    return await response.json();
-  }
-  throw new Error(
-    `Failed to create unprocessed file ${response.status} ${response.statusText}`
-  );
+	log("Creating an unprocessed file", payload);
+	CreateUnprocessedFilePayload.parse(payload);
+	const response = await client.authenticatedFetch("/api/v1/unprocessed_files", {
+		method: "POST",
+		body: JSON.stringify(payload)
+	});
+	log("Unprocessed file created", response.status, response.statusText, response.headers);
+	if (response.ok) return await response.json();
+	throw new Error(`Failed to create unprocessed file ${response.status} ${response.statusText}`);
 };
 const uploadUnprocessedReadableStream = (client, uploadDetails, fileStream) => {
-  log("Uploading unprocessed file", uploadDetails.id);
-  return uploadChunks(client, {
-    url: `/api/v1/unprocessed_files/${uploadDetails.id}/upload`,
-    fileSize: uploadDetails.byte_size,
-    fileStream,
-    maxSize: MAX_FILE_SIZE
-  });
+	log("Uploading unprocessed file", uploadDetails.id);
+	return uploadChunks(client, {
+		url: `/api/v1/unprocessed_files/${uploadDetails.id}/upload`,
+		fileSize: uploadDetails.byte_size,
+		fileStream,
+		maxSize: MAX_FILE_SIZE
+	});
 };
 const lookupUnprocessedFileByMd5 = async (client, md5) => {
-  const response = await client.authenticatedFetch(
-    `/api/v1/unprocessed_files/md5/${md5}`,
-    {
-      method: "GET"
-    }
-  );
-  if (response.ok) {
-    return await response.json();
-  }
-  if (response.status === 404) {
-    return null;
-  }
-  throw new Error(
-    `Failed to lookup unprocessed file by md5 ${md5} ${response.status} ${response.statusText}`
-  );
+	const response = await client.authenticatedFetch(`/api/v1/unprocessed_files/md5/${md5}`, { method: "GET" });
+	if (response.ok) return await response.json();
+	if (response.status === 404) return null;
+	throw new Error(`Failed to lookup unprocessed file by md5 ${md5} ${response.status} ${response.statusText}`);
 };
 const processIsobmffFile = async (client, id) => {
-  const response = await client.authenticatedFetch(
-    `/api/v1/unprocessed_files/${id}/isobmff`,
-    {
-      method: "POST"
-    }
-  );
-  if (response.ok) {
-    return await response.json();
-  }
-  throw new Error(
-    `Failed to process isobmff file ${id} ${response.status} ${response.statusText}`
-  );
-};
-export {
-  CreateUnprocessedFilePayload,
-  createUnprocessedFile,
-  lookupUnprocessedFileByMd5,
-  processIsobmffFile,
-  uploadUnprocessedReadableStream
+	const response = await client.authenticatedFetch(`/api/v1/unprocessed_files/${id}/isobmff`, { method: "POST" });
+	if (response.ok) return await response.json();
+	throw new Error(`Failed to process isobmff file ${id} ${response.status} ${response.statusText}`);
 };
+export { CreateUnprocessedFilePayload, createUnprocessedFile, lookupUnprocessedFileByMd5, processIsobmffFile, uploadUnprocessedReadableStream };

package/dist/resources/url-token.js

@@ -1,20 +1,12 @@
 import debug from "debug";
 const log = debug("ef:api:url-token");
 const createURLToken = async (client, url) => {
-  log("Creating signed url for", url);
-  const response = await client.authenticatedFetch("/api/v1/url-token", {
-    method: "POST",
-    body: JSON.stringify({
-      url
-    })
-  });
-  if (!response.ok) {
-    throw new Error(
-      `Failed to create signed url: ${response.status} ${response.statusText} ${await response.text()}`
-    );
-  }
-  return (await response.json()).token;
-};
-export {
-  createURLToken
+	log("Creating signed url for", url);
+	const response = await client.authenticatedFetch("/api/v1/url-token", {
+		method: "POST",
+		body: JSON.stringify({ url })
+	});
+	if (!response.ok) throw new Error(`Failed to create signed url: ${response.status} ${response.statusText} ${await response.text()}`);
+	return (await response.json()).token;
 };
+export { createURLToken };

package/dist/streamChunker.js

@@ -1,28 +1,24 @@
 import { CHUNK_SIZE_BYTES } from "./CHUNK_SIZE_BYTES.js";
 async function* streamChunker(readableStream, chunkSize = CHUNK_SIZE_BYTES) {
-  const reader = readableStream.getReader();
-  let buffer = new Uint8Array(0);
-  try {
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      const chunk = value;
-      const newBuffer = new Uint8Array(buffer.length + chunk.length);
-      newBuffer.set(buffer);
-      newBuffer.set(chunk, buffer.length);
-      buffer = newBuffer;
-      while (buffer.length >= chunkSize) {
-        yield buffer.slice(0, chunkSize);
-        buffer = buffer.slice(chunkSize);
-      }
-    }
-    if (buffer.length > 0) {
-      yield buffer;
-    }
-  } finally {
-    reader.releaseLock();
-  }
+	const reader = readableStream.getReader();
+	let buffer = new Uint8Array(0);
+	try {
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			const chunk = value;
+			const newBuffer = new Uint8Array(buffer.length + chunk.length);
+			newBuffer.set(buffer);
+			newBuffer.set(chunk, buffer.length);
+			buffer = newBuffer;
+			while (buffer.length >= chunkSize) {
+				yield buffer.slice(0, chunkSize);
+				buffer = buffer.slice(chunkSize);
+			}
+		}
+		if (buffer.length > 0) yield buffer;
+	} finally {
+		reader.releaseLock();
+	}
 }
-export {
-  streamChunker
-};
+export { streamChunker };

package/dist/uploadChunks.js

@@ -1,96 +1,80 @@
-import debug from "debug";
 import { CHUNK_SIZE_BYTES } from "./CHUNK_SIZE_BYTES.js";
 import { streamChunker } from "./streamChunker.js";
+import debug from "debug";
 const log = debug("ef:api:uploadChunk");
-const uploadChunk = async (client, {
-  url,
-  chunkBuffer,
-  chunkNumber,
-  fileSize,
-  chunkSizeBytes = CHUNK_SIZE_BYTES
-}) => {
-  const startByte = chunkNumber * chunkSizeBytes;
-  const endByte = startByte + chunkBuffer.length - 1;
-  log(`Uploading chunk ${chunkNumber} for ${url}`);
-  const response = await client.authenticatedFetch(url, {
-    method: "POST",
-    headers: {
-      "Content-Range": `bytes=${startByte}-${endByte}/${fileSize}`,
-      "Content-Type": "application/octet-stream"
-    },
-    body: chunkBuffer
-  });
-  if (response.ok) {
-    if (response.status === 201) {
-      log(`File ${url} fully uploaded`);
-      return { complete: true, body: await response.json() };
-    }
-    if (response.status === 202) {
-      log(`File ${url} chunk ${chunkNumber} uploaded`);
-      return { complete: false, body: await response.json() };
-    }
-  }
-  throw new Error(
-    `Failed to upload chunk ${chunkNumber} for ${url} ${response.status} ${response.statusText}`
-  );
+const uploadChunk = async (client, { url, chunkBuffer, chunkNumber, fileSize, chunkSizeBytes = CHUNK_SIZE_BYTES }) => {
+	const startByte = chunkNumber * chunkSizeBytes;
+	const endByte = startByte + chunkBuffer.length - 1;
+	log(`Uploading chunk ${chunkNumber} for ${url}`);
+	const response = await client.authenticatedFetch(url, {
+		method: "POST",
+		headers: {
+			"Content-Range": `bytes=${startByte}-${endByte}/${fileSize}`,
+			"Content-Type": "application/octet-stream"
+		},
+		body: chunkBuffer
+	});
+	if (response.ok) {
+		if (response.status === 201) {
+			log(`File ${url} fully uploaded`);
+			return {
+				complete: true,
+				body: await response.json()
+			};
+		}
+		if (response.status === 202) {
+			log(`File ${url} chunk ${chunkNumber} uploaded`);
+			return {
+				complete: false,
+				body: await response.json()
+			};
+		}
+	}
+	throw new Error(`Failed to upload chunk ${chunkNumber} for ${url} ${response.status} ${response.statusText}`);
 };
-function uploadChunks(client, {
-  url,
-  fileSize,
-  fileStream,
-  maxSize,
-  chunkSizeBytes = CHUNK_SIZE_BYTES
-}) {
-  const makeGenerator = async function* () {
-    if (fileSize > maxSize) {
-      throw new Error(
-        `File size ${fileSize} bytes exceeds limit ${maxSize} bytes`
-      );
-    }
-    log("Checking upload status", url);
-    const uploadStatus = await client.authenticatedFetch(url);
-    yield { type: "progress", progress: 0 };
-    if (uploadStatus.status === 200) {
-      log("Chunk already uploaded");
-      yield { type: "progress", progress: 1 };
-      return;
-    }
-    let chunkNumber = 0;
-    let complete = false;
-    for await (const chunkBuffer of streamChunker(fileStream, chunkSizeBytes)) {
-      log(`Uploading chunk ${chunkNumber}`);
-      ({ complete } = await uploadChunk(client, {
-        url,
-        chunkBuffer,
-        chunkNumber,
-        fileSize,
-        chunkSizeBytes
-      }));
-      chunkNumber++;
-      yield {
-        type: "progress",
-        progress: Math.min(1, chunkNumber / (fileSize / chunkSizeBytes))
-      };
-    }
-    if (!complete) {
-      throw new Error("Did not complete upload");
-    }
-  };
-  const generator = makeGenerator();
-  generator.whenUploaded = async () => {
-    if (fileSize > maxSize) {
-      throw new Error(
-        `File size ${fileSize} bytes exceeds limit ${maxSize} bytes`
-      );
-    }
-    const events = [];
-    for await (const event of generator) {
-      events.push(event);
-    }
-    return events;
-  };
-  return generator;
+function uploadChunks(client, { url, fileSize, fileStream, maxSize, chunkSizeBytes = CHUNK_SIZE_BYTES }) {
+	const makeGenerator = async function* () {
+		if (fileSize > maxSize) throw new Error(`File size ${fileSize} bytes exceeds limit ${maxSize} bytes`);
+		log("Checking upload status", url);
+		const uploadStatus = await client.authenticatedFetch(url);
+		yield {
+			type: "progress",
+			progress: 0
+		};
+		if (uploadStatus.status === 200) {
+			log("Chunk already uploaded");
+			yield {
+				type: "progress",
+				progress: 1
+			};
+			return;
+		}
+		let chunkNumber = 0;
+		let complete = false;
+		for await (const chunkBuffer of streamChunker(fileStream, chunkSizeBytes)) {
+			log(`Uploading chunk ${chunkNumber}`);
+			({complete} = await uploadChunk(client, {
+				url,
+				chunkBuffer,
+				chunkNumber,
+				fileSize,
+				chunkSizeBytes
+			}));
+			chunkNumber++;
+			yield {
+				type: "progress",
+				progress: Math.min(1, chunkNumber / (fileSize / chunkSizeBytes))
+			};
+		}
+		if (!complete) throw new Error("Did not complete upload");
+	};
+	const generator = makeGenerator();
+	generator.whenUploaded = async () => {
+		if (fileSize > maxSize) throw new Error(`File size ${fileSize} bytes exceeds limit ${maxSize} bytes`);
+		const events = [];
+		for await (const event of generator) events.push(event);
+		return events;
+	};
+	return generator;
 }
-export {
-  uploadChunks
-};
+export { uploadChunks };

package/dist/utils/assertTypesMatch.js

@@ -0,0 +1,2 @@
+const assertTypesMatch = (value) => value;
+export { assertTypesMatch };

package/dist/utils/createReadableStreamFromReadable.js

@@ -1,82 +1,65 @@
 import { Stream } from "node:stream";
 const createReadableStreamFromReadable = (source) => {
-  const pump = new StreamPump(source);
-  const stream = new ReadableStream(pump, pump);
-  return stream;
+	const pump = new StreamPump(source);
+	const stream = new ReadableStream(pump, pump);
+	return stream;
 };
-class StreamPump {
-  constructor(stream) {
-    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) {
-    return chunk?.byteLength || 0;
-  }
-  start(controller) {
-    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) {
-    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) {
-    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) {
-        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();
-      delete this.controller;
-    }
-  }
-  error(error) {
-    if (this.controller) {
-      this.controller.error(error);
-      delete this.controller;
-    }
-  }
-}
-export {
-  createReadableStreamFromReadable
+var StreamPump = class {
+	constructor(stream) {
+		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) {
+		return chunk?.byteLength || 0;
+	}
+	start(controller) {
+		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) {
+		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) {
+		if (this.controller) try {
+			const available = (this.controller.desiredSize || 0) - chunk.length;
+			this.controller.enqueue(chunk);
+			if (available <= 0) this.pause();
+		} catch (_error) {
+			this.controller.error(/* @__PURE__ */ 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();
+			delete this.controller;
+		}
+	}
+	error(error) {
+		if (this.controller) {
+			this.controller.error(error);
+			delete this.controller;
+		}
+	}
 };
+export { createReadableStreamFromReadable };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@editframe/api",
-  "version": "0.16.8-beta.0",
+  "version": "0.17.6-beta.0",
   "description": "API functions for EditFrame",
   "exports": {
     ".": {
@@ -42,10 +42,10 @@
     "@types/node": "^20.14.13",
     "typedoc": "^0.26.5",
     "typescript": "^5.5.4",
-    "vite-plugin-dts": "^4.0.3"
+    "vite-plugin-dts": "^4.5.4"
   },
   "dependencies": {
-    "@editframe/assets": "0.16.8-beta.0",
+    "@editframe/assets": "0.17.6-beta.0",
     "@vitejs/plugin-react": "^4.3.4",
     "debug": "^4.3.5",
     "eventsource-parser": "^3.0.0",
@@ -53,8 +53,8 @@
     "mime": "^4.0.4",
     "mime-types": "^2.1.35",
     "node-fetch": "^3.3.2",
+    "rolldown-vite": "^6.3.21",
     "tar": "^7.4.3",
-    "vite": "^6.3.5",
     "vite-plugin-singlefile": "^2.1.0",
     "vite-tsconfig-paths": "^4.3.2",
     "zod": "^3.23.8"

package/src/resources/renders.bundle.ts

@@ -2,8 +2,8 @@ import path from "node:path";
 import { PassThrough } from "node:stream";
 
 import react from "@vitejs/plugin-react";
+import { build } from "rolldown-vite";
 import * as tar from "tar";
-import { build } from "vite";
 import { viteSingleFile } from "vite-plugin-singlefile";
 import tsconfigPathsPlugin from "vite-tsconfig-paths";
 

package/src/utils/createReadableStreamFromReadable.ts

@@ -69,14 +69,14 @@ class StreamPump {
   enqueue(chunk: Uint8Array | string) {
     if (this.controller) {
       try {
-        const bytes = chunk instanceof Uint8Array ? chunk : Buffer.from(chunk);
+        // const bytes = chunk instanceof Uint8Array ? chunk : Buffer.from(chunk);
 
-        const available = (this.controller.desiredSize || 0) - bytes.byteLength;
-        this.controller.enqueue(bytes);
+        const available = (this.controller.desiredSize || 0) - chunk.length;
+        this.controller.enqueue(chunk as Uint8Array);
         if (available <= 0) {
           this.pause();
         }
-      } catch (error: any) {
+      } 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",
@@ -102,7 +102,6 @@ class StreamPump {
   close() {
     if (this.controller) {
       this.controller.close();
-      // biome-ignore lint/performance/noDelete: infrequent use
       delete this.controller;
     }
   }
@@ -110,7 +109,6 @@ class StreamPump {
   error(error: Error) {
     if (this.controller) {
       this.controller.error(error);
-      // biome-ignore lint/performance/noDelete: infrequent use
       delete this.controller;
     }
   }