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

package/dist/operations/syncAssetsDirectory/SyncTrack.js

@@ -1,146 +1,110 @@
-import { createReadStream } from "node:fs";
-import fs from "node:fs/promises";
-import { join, dirname, basename } from "node:path";
-import { lookupISOBMFFFileByMd5, createISOBMFFFile, createISOBMFFTrack, uploadISOBMFFTrack } from "@editframe/api";
-import { Probe } from "@editframe/assets";
-import { createReadableStreamFromReadable } from "../../utils/createReadableStreamFromReadable.js";
 import { getClient } from "../../utils/index.js";
+import { createReadableStreamFromReadable } from "../../utils/createReadableStreamFromReadable.js";
 import { SyncStatus } from "./SyncStatus.js";
-class SyncTrack {
-  constructor(path, md5) {
-    this.path = path;
-    this.md5 = md5;
-    this.icon = "📼";
-    this.label = "track";
-    this.syncStatus = new SyncStatus(this.path);
-    this.fileSyncStatus = new SyncStatus(join(dirname(this.path), "isobmff"));
-    this.created = null;
-    this._isoFile = null;
-    this._probeResult = null;
-  }
-  get isoFile() {
-    if (this._isoFile) {
-      return this._isoFile;
-    }
-    throw new Error("ISOBMFF file not found. Call prepare() first.");
-  }
-  async byteSize() {
-    return (await fs.stat(this.path)).size;
-  }
-  get probeResult() {
-    if (this._probeResult) {
-      return this._probeResult;
-    }
-    throw new Error("Probe result not found. Call prepare() first.");
-  }
-  get track() {
-    const [track] = this.probeResult.streams;
-    if (track) {
-      return track;
-    }
-    throw new Error(`No track found in track: ${this.path}`);
-  }
-  async prepare() {
-    const maybeIsoFile = await lookupISOBMFFFileByMd5(getClient(), this.md5);
-    if (maybeIsoFile) {
-      this._isoFile = maybeIsoFile;
-    } else {
-      this._isoFile = await createISOBMFFFile(getClient(), {
-        md5: this.md5,
-        filename: basename(this.path).replace(/\.track-[\d]+.mp4$/, "")
-      });
-    }
-    this._probeResult = await Probe.probePath(this.path);
-  }
-  get trackId() {
-    const trackId = this.path.match(/track-([\d]+).mp4/)?.[1];
-    if (!trackId) {
-      throw new Error(`No track ID  found for track: ${this.path}`);
-    }
-    return trackId;
-  }
-  get trackDuration() {
-    const track = this.track;
-    if (!track.duration) {
-      throw new Error(`No duration found in track: ${this.path}`);
-    }
-    if (typeof track.duration === "string") {
-      return Number.parseFloat(track.duration);
-    }
-    return track.duration;
-  }
-  async validate() {
-    this.trackId;
-    this.isoFile;
-    this.trackDuration;
-  }
-  async create() {
-    const track = this.track;
-    const isoFile = this.isoFile;
-    if (track.codec_type === "data") {
-      throw new Error(`Unsupported codec type: ${track.codec_type}`);
-    }
-    const createPayload = track.codec_type === "audio" ? {
-      type: track.codec_type,
-      file_id: isoFile.id,
-      track_id: Number(this.trackId),
-      probe_info: track,
-      duration_ms: Math.round(this.trackDuration * 1e3),
-      codec_name: track.codec_name,
-      byte_size: await this.byteSize()
-    } : {
-      type: track.codec_type,
-      file_id: isoFile.id,
-      track_id: Number(this.trackId),
-      probe_info: track,
-      duration_ms: Math.round(this.trackDuration * 1e3),
-      codec_name: track.codec_name,
-      byte_size: await this.byteSize()
-    };
-    this.created = await createISOBMFFTrack(getClient(), createPayload);
-  }
-  isComplete() {
-    return !!this.created?.complete;
-  }
-  async upload() {
-    if (!this.created) {
-      throw new Error(
-        "Track not created. Should have been prevented by .isComplete()"
-      );
-    }
-    await uploadISOBMFFTrack(
-      getClient(),
-      this.isoFile.id,
-      Number(this.trackId),
-      createReadableStreamFromReadable(createReadStream(this.path)),
-      this.created?.byte_size
-    ).whenUploaded();
-  }
-  async markSynced() {
-    if (!this.created) {
-      throw new Error(
-        "Track not created. Should have been prevented by .isComplete()"
-      );
-    }
-    const byteSize = await this.byteSize();
-    await Promise.all([
-      this.syncStatus.markSynced({
-        version: "1",
-        complete: true,
-        id: `${this.created.file_id}:${this.created.track_id}`,
-        md5: this.md5,
-        byte_size: byteSize
-      }),
-      this.fileSyncStatus.markSynced({
-        version: "1",
-        complete: true,
-        id: this.created.file_id,
-        md5: this.md5,
-        byte_size: byteSize
-      })
-    ]);
-  }
-}
-export {
-  SyncTrack
+import { createISOBMFFFile, createISOBMFFTrack, lookupISOBMFFFileByMd5, uploadISOBMFFTrack } from "@editframe/api";
+import { basename, dirname, join } from "node:path";
+import fs from "node:fs/promises";
+import { createReadStream } from "node:fs";
+import { Probe } from "@editframe/assets";
+var SyncTrack = class {
+	constructor(path$1, md5) {
+		this.path = path$1;
+		this.md5 = md5;
+		this.icon = "📼";
+		this.label = "track";
+		this.syncStatus = new SyncStatus(this.path);
+		this.fileSyncStatus = new SyncStatus(join(dirname(this.path), "isobmff"));
+		this.created = null;
+		this._isoFile = null;
+		this._probeResult = null;
+	}
+	get isoFile() {
+		if (this._isoFile) return this._isoFile;
+		throw new Error("ISOBMFF file not found. Call prepare() first.");
+	}
+	async byteSize() {
+		return (await fs.stat(this.path)).size;
+	}
+	get probeResult() {
+		if (this._probeResult) return this._probeResult;
+		throw new Error("Probe result not found. Call prepare() first.");
+	}
+	get track() {
+		const [track] = this.probeResult.streams;
+		if (track) return track;
+		throw new Error(`No track found in track: ${this.path}`);
+	}
+	async prepare() {
+		const maybeIsoFile = await lookupISOBMFFFileByMd5(getClient(), this.md5);
+		if (maybeIsoFile) this._isoFile = maybeIsoFile;
+		else this._isoFile = await createISOBMFFFile(getClient(), {
+			md5: this.md5,
+			filename: basename(this.path).replace(/\.track-[\d]+.mp4$/, "")
+		});
+		this._probeResult = await Probe.probePath(this.path);
+	}
+	get trackId() {
+		const trackId = this.path.match(/track-([\d]+).mp4/)?.[1];
+		if (!trackId) throw new Error(`No track ID  found for track: ${this.path}`);
+		return trackId;
+	}
+	get trackDuration() {
+		const track = this.track;
+		if (!track.duration) throw new Error(`No duration found in track: ${this.path}`);
+		if (typeof track.duration === "string") return Number.parseFloat(track.duration);
+		return track.duration;
+	}
+	async validate() {
+		this.trackId;
+		this.isoFile;
+		this.trackDuration;
+	}
+	async create() {
+		const track = this.track;
+		const isoFile = this.isoFile;
+		if (track.codec_type === "data") throw new Error(`Unsupported codec type: ${track.codec_type}`);
+		const createPayload = track.codec_type === "audio" ? {
+			type: track.codec_type,
+			file_id: isoFile.id,
+			track_id: Number(this.trackId),
+			probe_info: track,
+			duration_ms: Math.round(this.trackDuration * 1e3),
+			codec_name: track.codec_name,
+			byte_size: await this.byteSize()
+		} : {
+			type: track.codec_type,
+			file_id: isoFile.id,
+			track_id: Number(this.trackId),
+			probe_info: track,
+			duration_ms: Math.round(this.trackDuration * 1e3),
+			codec_name: track.codec_name,
+			byte_size: await this.byteSize()
+		};
+		this.created = await createISOBMFFTrack(getClient(), createPayload);
+	}
+	isComplete() {
+		return !!this.created?.complete;
+	}
+	async upload() {
+		if (!this.created) throw new Error("Track not created. Should have been prevented by .isComplete()");
+		await uploadISOBMFFTrack(getClient(), this.isoFile.id, Number(this.trackId), createReadableStreamFromReadable(createReadStream(this.path)), this.created?.byte_size).whenUploaded();
+	}
+	async markSynced() {
+		if (!this.created) throw new Error("Track not created. Should have been prevented by .isComplete()");
+		const byteSize = await this.byteSize();
+		await Promise.all([this.syncStatus.markSynced({
+			version: "1",
+			complete: true,
+			id: `${this.created.file_id}:${this.created.track_id}`,
+			md5: this.md5,
+			byte_size: byteSize
+		}), this.fileSyncStatus.markSynced({
+			version: "1",
+			complete: true,
+			id: this.created.file_id,
+			md5: this.md5,
+			byte_size: byteSize
+		})]);
+	}
 };
+export { SyncTrack };

package/dist/operations/syncAssetsDirectory/doAssetSync.js

@@ -1,48 +1,44 @@
 const doAssetSync = async function* (assetSync) {
-  if (await assetSync.syncStatus.isSynced()) {
-    yield {
-      status: "info",
-      message: `Sub-asset has already been synced: ${assetSync.path}`
-    };
-    return;
-  }
-  try {
-    await assetSync.prepare();
-    await assetSync.validate();
-  } catch (error) {
-    const message = error instanceof Error ? error.message : "Unknown error";
-    throw new Error(`Error validating ${assetSync.label}: ${message}`);
-  }
-  yield {
-    status: "info",
-    message: `${assetSync.icon}  Syncing ${assetSync.label}: ${assetSync.path}`
-  };
-  try {
-    await assetSync.create();
-  } catch (error) {
-    const message = error instanceof Error ? error.message : "Unknown error";
-    throw new Error(`Error creating ${assetSync.label}: ${message}`);
-  }
-  if (!assetSync.isComplete()) {
-    try {
-      await assetSync.upload();
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "Unknown error";
-      throw new Error(`Error uploading ${assetSync.label}: ${message}`);
-    }
-  }
-  try {
-    await assetSync.markSynced();
-  } catch (error) {
-    const message = error instanceof Error ? error.message : "Unknown error";
-    throw new Error(`Error marking ${assetSync.label} as synced: ${message}`);
-  }
-  yield {
-    status: "success",
-    message: `Synced ${assetSync.label}: ${assetSync.path}`
-  };
-  return;
-};
-export {
-  doAssetSync
+	if (await assetSync.syncStatus.isSynced()) {
+		yield {
+			status: "info",
+			message: `Sub-asset has already been synced: ${assetSync.path}`
+		};
+		return;
+	}
+	try {
+		await assetSync.prepare();
+		await assetSync.validate();
+	} catch (error) {
+		const message = error instanceof Error ? error.message : "Unknown error";
+		throw new Error(`Error validating ${assetSync.label}: ${message}`);
+	}
+	yield {
+		status: "info",
+		message: `${assetSync.icon}  Syncing ${assetSync.label}: ${assetSync.path}`
+	};
+	try {
+		await assetSync.create();
+	} catch (error) {
+		const message = error instanceof Error ? error.message : "Unknown error";
+		throw new Error(`Error creating ${assetSync.label}: ${message}`);
+	}
+	if (!assetSync.isComplete()) try {
+		await assetSync.upload();
+	} catch (error) {
+		const message = error instanceof Error ? error.message : "Unknown error";
+		throw new Error(`Error uploading ${assetSync.label}: ${message}`);
+	}
+	try {
+		await assetSync.markSynced();
+	} catch (error) {
+		const message = error instanceof Error ? error.message : "Unknown error";
+		throw new Error(`Error marking ${assetSync.label} as synced: ${message}`);
+	}
+	yield {
+		status: "success",
+		message: `Synced ${assetSync.label}: ${assetSync.path}`
+	};
+	return;
 };
+export { doAssetSync };

package/dist/operations/syncAssetsDirectory.js

@@ -1,82 +1,59 @@
-import fs from "node:fs/promises";
-import path from "node:path";
 import { getAssetSync } from "./syncAssetsDirectory/SubAssetSync.js";
 import { doAssetSync } from "./syncAssetsDirectory/doAssetSync.js";
+import path from "node:path";
+import fs from "node:fs/promises";
 const syncAssetDirectory = async (cacheDir) => {
-  const stat = await fs.stat(cacheDir).catch((error) => {
-    if (error.code === "ENOENT") {
-      return;
-    }
-    throw error;
-  });
-  if (!stat?.isDirectory()) {
-    console.error(`No assets cache directory found at ${cacheDir}`);
-    return;
-  }
-  const assets = await fs.readdir(cacheDir);
-  process.stderr.write(`Syncing asset dir: ${cacheDir}
-`);
-  const errors = {};
-  const reportError = (path2, message) => {
-    errors[path2] ||= [];
-    errors[path2].push(message);
-    process.stderr.write(` 🚫 ${message}
-`);
-  };
-  const reportSuccess = (_path, message) => {
-    process.stderr.write(` ✅ ${message}
-`);
-  };
-  const reportInfo = (_path, message) => {
-    process.stderr.write(` ${message}
-`);
-  };
-  for (const assetMd5 of assets) {
-    reportInfo(assetMd5, `Syncing asset: ${assetMd5}`);
-    const assetDir = path.join(cacheDir, assetMd5);
-    const stat2 = await fs.stat(assetDir);
-    if (!stat2.isDirectory()) {
-      reportError(assetMd5, "Invalid asset. Did not find asset directory.");
-      return;
-    }
-    const subAssets = await fs.readdir(assetDir);
-    for (const subAsset of subAssets) {
-      if (subAsset.endsWith(".info")) {
-        continue;
-      }
-      const subAssetPath = path.join(assetDir, subAsset);
-      try {
-        const assetSync = getAssetSync(subAssetPath, assetMd5);
-        for await (const { status, message } of doAssetSync(assetSync)) {
-          if (status === "success") {
-            reportSuccess(subAsset, message);
-          } else if (status === "info") {
-            reportInfo(subAsset, message);
-          }
-        }
-      } catch (error) {
-        if (error instanceof Error) {
-          reportError(subAsset, error.message);
-        } else {
-          reportError(subAsset, "Unknown error");
-        }
-      }
-    }
-  }
-  if (Object.keys(errors).length) {
-    process.stderr.write("\n\n❌ Encountered errors while syncing assets:\n");
-    for (const [asset, messages] of Object.entries(errors)) {
-      process.stderr.write(`
-🚫 ${asset}
-`);
-      for (const message of messages) {
-        process.stderr.write(`  - ${message}
-`);
-      }
-    }
-    throw new Error("Failed to sync assets");
-  }
-};
-export {
-  syncAssetDirectory
+	const stat = await fs.stat(cacheDir).catch((error) => {
+		if (error.code === "ENOENT") return;
+		throw error;
+	});
+	if (!stat?.isDirectory()) {
+		console.error(`No assets cache directory found at ${cacheDir}`);
+		return;
+	}
+	const assets = await fs.readdir(cacheDir);
+	process.stderr.write(`Syncing asset dir: ${cacheDir}\n`);
+	const errors = {};
+	const reportError = (path$1, message) => {
+		errors[path$1] ||= [];
+		errors[path$1].push(message);
+		process.stderr.write(` 🚫 ${message}\n`);
+	};
+	const reportSuccess = (_path, message) => {
+		process.stderr.write(` ✅ ${message}\n`);
+	};
+	const reportInfo = (_path, message) => {
+		process.stderr.write(` ${message}\n`);
+	};
+	for (const assetMd5 of assets) {
+		reportInfo(assetMd5, `Syncing asset: ${assetMd5}`);
+		const assetDir = path.join(cacheDir, assetMd5);
+		const stat$1 = await fs.stat(assetDir);
+		if (!stat$1.isDirectory()) {
+			reportError(assetMd5, "Invalid asset. Did not find asset directory.");
+			return;
+		}
+		const subAssets = await fs.readdir(assetDir);
+		for (const subAsset of subAssets) {
+			if (subAsset.endsWith(".info")) continue;
+			const subAssetPath = path.join(assetDir, subAsset);
+			try {
+				const assetSync = getAssetSync(subAssetPath, assetMd5);
+				for await (const { status, message } of doAssetSync(assetSync)) if (status === "success") reportSuccess(subAsset, message);
+				else if (status === "info") reportInfo(subAsset, message);
+			} catch (error) {
+				if (error instanceof Error) reportError(subAsset, error.message);
+				else reportError(subAsset, "Unknown error");
+			}
+		}
+	}
+	if (Object.keys(errors).length) {
+		process.stderr.write("\n\n❌ Encountered errors while syncing assets:\n");
+		for (const [asset, messages] of Object.entries(errors)) {
+			process.stderr.write(`\n🚫 ${asset}\n`);
+			for (const message of messages) process.stderr.write(`  - ${message}\n`);
+		}
+		throw new Error("Failed to sync assets");
+	}
 };
+export { syncAssetDirectory };

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 };