@editframe/assets 0.6.0-beta.9 → 0.7.0-beta.4

package/dist/packages/assets/src/md5.d.ts

@@ -0,0 +1,6 @@
+import { ReadStream } from 'node:fs';
+import { Ora } from 'ora';
+
+export declare function md5Directory(directory: string, spinner?: Ora): Promise<string>;
+export declare function md5FilePath(filePath: string): Promise<string>;
+export declare function md5ReadStream(readStream: ReadStream): Promise<string>;

package/dist/packages/assets/src/md5.js

@@ -0,0 +1,60 @@
+import { createReadStream } from "node:fs";
+import { readdir } from "node:fs/promises";
+import { join } from "node:path";
+import crypto from "node:crypto";
+import ora from "ora";
+async function md5Directory(directory, spinner) {
+  const shouldEndSpinner = !spinner;
+  spinner ||= ora("⚡️ Calculating MD5").start();
+  spinner.suffixText = directory;
+  const files = await readdir(directory, { withFileTypes: true });
+  const hashes = await Promise.all(
+    files.map(async (file) => {
+      const filePath = join(directory, file.name);
+      if (file.isDirectory()) {
+        return md5Directory(filePath, spinner);
+      }
+      spinner.suffixText = filePath;
+      return md5FilePath(filePath);
+    })
+  );
+  const hash = crypto.createHash("md5");
+  for (const fileHash of hashes) {
+    hash.update(fileHash);
+  }
+  if (shouldEndSpinner) {
+    spinner.succeed("MD5 calculated");
+    spinner.suffixText = directory;
+  }
+  return addDashesToUUID(hash.digest("hex"));
+}
+async function md5FilePath(filePath) {
+  const readStream = createReadStream(filePath);
+  return md5ReadStream(readStream);
+}
+function md5ReadStream(readStream) {
+  return new Promise((resolve, reject) => {
+    const hash = crypto.createHash("md5");
+    readStream.on("data", (data) => {
+      hash.update(data);
+    });
+    readStream.on("error", reject);
+    readStream.on("end", () => {
+      resolve(addDashesToUUID(hash.digest("hex")));
+    });
+  });
+}
+function addDashesToUUID(uuidWithoutDashes) {
+  if (uuidWithoutDashes.length !== 32) {
+    throw new Error("Invalid UUID without dashes. Expected 32 characters.");
+  }
+  return (
+    // biome-ignore lint/style/useTemplate: using a template makes a long line
+    uuidWithoutDashes.slice(0, 8) + "-" + uuidWithoutDashes.slice(8, 12) + "-" + uuidWithoutDashes.slice(12, 16) + "-" + uuidWithoutDashes.slice(16, 20) + "-" + uuidWithoutDashes.slice(20, 32)
+  );
+}
+export {
+  md5Directory,
+  md5FilePath,
+  md5ReadStream
+};

package/dist/packages/assets/src/mp4FileWritable.cjs

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const node_stream = require("node:stream");
+const mp4FileWritable = (mp4File) => {
+  let arrayBufferStart = 0;
+  return new node_stream.Writable({
+    write: (chunk, _encoding, callback) => {
+      const mp4BoxBuffer = chunk.buffer;
+      mp4BoxBuffer.fileStart = arrayBufferStart;
+      arrayBufferStart += chunk.length;
+      mp4File.appendBuffer(mp4BoxBuffer, false);
+      callback();
+    },
+    final: (callback) => {
+      mp4File.flush();
+      mp4File.processSamples(true);
+      callback();
+    }
+  });
+};
+exports.mp4FileWritable = mp4FileWritable;

package/dist/packages/assets/src/mp4FileWritable.d.ts

@@ -0,0 +1,4 @@
+import { Writable } from 'node:stream';
+import { MP4File } from '../../../lib/av/MP4File';
+
+export declare const mp4FileWritable: (mp4File: MP4File) => Writable;

package/dist/packages/assets/src/mp4FileWritable.js

@@ -0,0 +1,21 @@
+import { Writable } from "node:stream";
+const mp4FileWritable = (mp4File) => {
+  let arrayBufferStart = 0;
+  return new Writable({
+    write: (chunk, _encoding, callback) => {
+      const mp4BoxBuffer = chunk.buffer;
+      mp4BoxBuffer.fileStart = arrayBufferStart;
+      arrayBufferStart += chunk.length;
+      mp4File.appendBuffer(mp4BoxBuffer, false);
+      callback();
+    },
+    final: (callback) => {
+      mp4File.flush();
+      mp4File.processSamples(true);
+      callback();
+    }
+  });
+};
+export {
+  mp4FileWritable
+};

package/dist/packages/assets/src/tasks/cacheImage.cjs

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const idempotentTask = require("../idempotentTask.cjs");
+const node_fs = require("node:fs");
+const path = require("node:path");
+const cacheImageTask = idempotentTask.idempotentTask({
+  label: "image",
+  filename: (absolutePath) => path.basename(absolutePath),
+  runner: async (absolutePath) => {
+    return node_fs.createReadStream(absolutePath);
+  }
+});
+const cacheImage = async (cacheRoot, absolutePath) => {
+  try {
+    return await cacheImageTask(cacheRoot, absolutePath);
+  } catch (error) {
+    console.error(error);
+    console.trace("Error generating track fragment index", error);
+    throw error;
+  }
+};
+exports.cacheImage = cacheImage;

package/dist/packages/assets/src/tasks/cacheImage.d.ts

@@ -0,0 +1 @@
+export declare const cacheImage: (cacheRoot: string, absolutePath: string) => Promise<import('../idempotentTask').TaskResult>;

package/dist/packages/assets/src/tasks/cacheImage.js

@@ -0,0 +1,22 @@
+import { idempotentTask } from "../idempotentTask.js";
+import { createReadStream } from "node:fs";
+import path from "node:path";
+const cacheImageTask = idempotentTask({
+  label: "image",
+  filename: (absolutePath) => path.basename(absolutePath),
+  runner: async (absolutePath) => {
+    return createReadStream(absolutePath);
+  }
+});
+const cacheImage = async (cacheRoot, absolutePath) => {
+  try {
+    return await cacheImageTask(cacheRoot, absolutePath);
+  } catch (error) {
+    console.error(error);
+    console.trace("Error generating track fragment index", error);
+    throw error;
+  }
+};
+export {
+  cacheImage
+};

package/dist/packages/assets/src/tasks/findOrCreateCaptions.cjs

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const execPromise = require("../../../../lib/util/execPromise.cjs");
+const idempotentTask = require("../idempotentTask.cjs");
+const debug = require("debug");
+const path = require("node:path");
+const log = debug("ef:generateCaptions");
+const generateCaptionData = idempotentTask.idempotentTask({
+  label: "captions",
+  filename: (absolutePath) => `${path.basename(absolutePath)}.captions.json`,
+  runner: async (absolutePath) => {
+    const command = `whisper_timestamped --language en --efficient --output_format vtt ${absolutePath}`;
+    log(`Running command: ${command}`);
+    const { stdout } = await execPromise.execPromise(command);
+    return stdout;
+  }
+});
+const findOrCreateCaptions = async (cacheRoot, absolutePath) => {
+  try {
+    return await generateCaptionData(cacheRoot, absolutePath);
+  } catch (error) {
+    console.trace("Error finding or creating captions", error);
+    throw error;
+  }
+};
+exports.findOrCreateCaptions = findOrCreateCaptions;

package/dist/packages/assets/src/tasks/findOrCreateCaptions.d.ts

@@ -0,0 +1 @@
+export declare const findOrCreateCaptions: (cacheRoot: string, absolutePath: string) => Promise<import('../idempotentTask').TaskResult>;

package/dist/packages/assets/src/tasks/findOrCreateCaptions.js

@@ -0,0 +1,26 @@
+import { execPromise } from "../../../../lib/util/execPromise.js";
+import { idempotentTask } from "../idempotentTask.js";
+import debug from "debug";
+import { basename } from "node:path";
+const log = debug("ef:generateCaptions");
+const generateCaptionData = idempotentTask({
+  label: "captions",
+  filename: (absolutePath) => `${basename(absolutePath)}.captions.json`,
+  runner: async (absolutePath) => {
+    const command = `whisper_timestamped --language en --efficient --output_format vtt ${absolutePath}`;
+    log(`Running command: ${command}`);
+    const { stdout } = await execPromise(command);
+    return stdout;
+  }
+});
+const findOrCreateCaptions = async (cacheRoot, absolutePath) => {
+  try {
+    return await generateCaptionData(cacheRoot, absolutePath);
+  } catch (error) {
+    console.trace("Error finding or creating captions", error);
+    throw error;
+  }
+};
+export {
+  findOrCreateCaptions
+};

package/dist/packages/assets/src/tasks/generateTrack.cjs

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const idempotentTask = require("../idempotentTask.cjs");
+const MP4File = require("../../../../lib/av/MP4File.cjs");
+const debug = require("debug");
+const mp4FileWritable = require("../mp4FileWritable.cjs");
+const node_stream = require("node:stream");
+const path = require("node:path");
+const Probe = require("../Probe.cjs");
+const generateTrackTask = idempotentTask.idempotentTask({
+  label: "track",
+  filename: (absolutePath, trackId) => `${path.basename(absolutePath)}.track-${trackId}.mp4`,
+  runner: async (absolutePath, trackId) => {
+    const log = debug("ef:generateTrackFragment");
+    const probe = await Probe.Probe.probePath(absolutePath);
+    const readStream = probe.createConformingReadstream();
+    const mp4File = new MP4File.MP4File();
+    log(`Generating track fragment index for ${absolutePath}`);
+    readStream.pipe(mp4FileWritable.mp4FileWritable(mp4File));
+    await new Promise((resolve, reject) => {
+      readStream.on("end", resolve);
+      readStream.on("error", reject);
+    });
+    const trackStream = new node_stream.PassThrough();
+    for await (const fragment of mp4File.fragmentIterator()) {
+      if (fragment.track !== trackId) {
+        continue;
+      }
+      trackStream.write(Buffer.from(fragment.data), "binary");
+    }
+    trackStream.end();
+    return trackStream;
+  }
+});
+const generateTrack = async (cacheRoot, absolutePath, url) => {
+  try {
+    const trackId = new URL(
+      `http://localhost${url}` ?? "bad-url"
+    ).searchParams.get("trackId");
+    if (trackId === null) {
+      throw new Error(
+        "No trackId provided. IT must be specified in the query string: ?trackId=0"
+      );
+    }
+    return await generateTrackTask(cacheRoot, absolutePath, Number(trackId));
+  } catch (error) {
+    console.error(error);
+    console.trace("Error generating track fragment index", error);
+    throw error;
+  }
+};
+exports.generateTrack = generateTrack;

package/dist/packages/assets/src/tasks/generateTrack.d.ts

@@ -0,0 +1 @@
+export declare const generateTrack: (cacheRoot: string, absolutePath: string, url: string) => Promise<import('../idempotentTask').TaskResult>;

package/dist/packages/assets/src/tasks/generateTrack.js

@@ -0,0 +1,52 @@
+import { idempotentTask } from "../idempotentTask.js";
+import { MP4File } from "../../../../lib/av/MP4File.js";
+import debug from "debug";
+import { mp4FileWritable } from "../mp4FileWritable.js";
+import { PassThrough } from "node:stream";
+import { basename } from "node:path";
+import { Probe } from "../Probe.js";
+const generateTrackTask = idempotentTask({
+  label: "track",
+  filename: (absolutePath, trackId) => `${basename(absolutePath)}.track-${trackId}.mp4`,
+  runner: async (absolutePath, trackId) => {
+    const log = debug("ef:generateTrackFragment");
+    const probe = await Probe.probePath(absolutePath);
+    const readStream = probe.createConformingReadstream();
+    const mp4File = new MP4File();
+    log(`Generating track fragment index for ${absolutePath}`);
+    readStream.pipe(mp4FileWritable(mp4File));
+    await new Promise((resolve, reject) => {
+      readStream.on("end", resolve);
+      readStream.on("error", reject);
+    });
+    const trackStream = new PassThrough();
+    for await (const fragment of mp4File.fragmentIterator()) {
+      if (fragment.track !== trackId) {
+        continue;
+      }
+      trackStream.write(Buffer.from(fragment.data), "binary");
+    }
+    trackStream.end();
+    return trackStream;
+  }
+});
+const generateTrack = async (cacheRoot, absolutePath, url) => {
+  try {
+    const trackId = new URL(
+      `http://localhost${url}` ?? "bad-url"
+    ).searchParams.get("trackId");
+    if (trackId === null) {
+      throw new Error(
+        "No trackId provided. IT must be specified in the query string: ?trackId=0"
+      );
+    }
+    return await generateTrackTask(cacheRoot, absolutePath, Number(trackId));
+  } catch (error) {
+    console.error(error);
+    console.trace("Error generating track fragment index", error);
+    throw error;
+  }
+};
+export {
+  generateTrack
+};

package/dist/packages/assets/src/tasks/generateTrackFragmentIndex.cjs

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const idempotentTask = require("../idempotentTask.cjs");
+const MP4File = require("../../../../lib/av/MP4File.cjs");
+const debug = require("debug");
+const mp4FileWritable = require("../mp4FileWritable.cjs");
+const path = require("node:path");
+const Probe = require("../Probe.cjs");
+const generateTrackFragmentIndexFromPath = async (absolutePath) => {
+  const log = debug("ef:generateTrackFragment");
+  const probe = await Probe.Probe.probePath(absolutePath);
+  const readStream = probe.createConformingReadstream();
+  const mp4File = new MP4File.MP4File();
+  log(`Generating track fragment index for ${absolutePath}`);
+  readStream.pipe(mp4FileWritable.mp4FileWritable(mp4File));
+  await new Promise((resolve, reject) => {
+    readStream.on("end", resolve);
+    readStream.on("error", reject);
+  });
+  const trackFragmentIndexes = {};
+  const trackByteOffsets = {};
+  for await (const fragment of mp4File.fragmentIterator()) {
+    const track = mp4File.getInfo().tracks.find((track2) => track2.id === fragment.track);
+    if (!track) {
+      throw new Error("Track not found");
+    }
+    if (fragment.segment === "init") {
+      trackByteOffsets[fragment.track] = fragment.data.byteLength;
+      if (track?.type === "video") {
+        const videoTrack = mp4File.getInfo().videoTracks.find((track2) => track2.id === fragment.track);
+        if (!videoTrack) {
+          throw new Error("Video track not found");
+        }
+        trackFragmentIndexes[fragment.track] = {
+          track: fragment.track,
+          type: "video",
+          width: videoTrack.video.width,
+          height: videoTrack.video.height,
+          timescale: track.timescale,
+          sample_count: videoTrack.nb_samples,
+          duration: 0,
+          initSegment: {
+            offset: 0,
+            size: fragment.data.byteLength
+          },
+          segments: []
+        };
+      }
+      if (track?.type === "audio") {
+        const audioTrack = mp4File.getInfo().audioTracks.find((track2) => track2.id === fragment.track);
+        if (!audioTrack) {
+          throw new Error("Audio track not found");
+        }
+        trackFragmentIndexes[fragment.track] = {
+          track: fragment.track,
+          type: "audio",
+          channel_count: audioTrack.audio.channel_count,
+          sample_rate: audioTrack.audio.sample_rate,
+          sample_size: audioTrack.audio.sample_size,
+          sample_count: audioTrack.nb_samples,
+          timescale: track.timescale,
+          duration: 0,
+          initSegment: {
+            offset: 0,
+            size: fragment.data.byteLength
+          },
+          segments: []
+        };
+      }
+    } else {
+      const fragmentIndex = trackFragmentIndexes[fragment.track];
+      if (trackByteOffsets[fragment.track] === void 0) {
+        throw new Error("Fragment index not found");
+      }
+      if (!fragmentIndex) {
+        throw new Error("Fragment index not found");
+      }
+      fragmentIndex.duration += fragment.duration;
+      fragmentIndex.segments.push({
+        cts: fragment.cts,
+        dts: fragment.dts,
+        duration: fragment.duration,
+        // biome-ignore lint/style/noNonNullAssertion: This was checked above
+        offset: trackByteOffsets[fragment.track],
+        size: fragment.data.byteLength
+      });
+      trackByteOffsets[fragment.track] += fragment.data.byteLength;
+    }
+  }
+  return JSON.stringify(trackFragmentIndexes, null, 2);
+};
+const generateTrackFragmentIndexTask = idempotentTask.idempotentTask({
+  label: "trackFragmentIndex",
+  filename: (absolutePath) => `${path.basename(absolutePath)}.tracks.json`,
+  runner: generateTrackFragmentIndexFromPath
+});
+const generateTrackFragmentIndex = async (cacheRoot, absolutePath) => {
+  try {
+    return await generateTrackFragmentIndexTask(cacheRoot, absolutePath);
+  } catch (error) {
+    console.trace("Error generating track fragment index", error);
+    throw error;
+  }
+};
+exports.generateTrackFragmentIndex = generateTrackFragmentIndex;

package/dist/packages/assets/src/tasks/generateTrackFragmentIndex.d.ts

@@ -0,0 +1 @@
+export declare const generateTrackFragmentIndex: (cacheRoot: string, absolutePath: string) => Promise<import('../idempotentTask').TaskResult>;

package/dist/packages/assets/src/tasks/generateTrackFragmentIndex.js

@@ -0,0 +1,105 @@
+import { idempotentTask } from "../idempotentTask.js";
+import { MP4File } from "../../../../lib/av/MP4File.js";
+import debug from "debug";
+import { mp4FileWritable } from "../mp4FileWritable.js";
+import { basename } from "node:path";
+import { Probe } from "../Probe.js";
+const generateTrackFragmentIndexFromPath = async (absolutePath) => {
+  const log = debug("ef:generateTrackFragment");
+  const probe = await Probe.probePath(absolutePath);
+  const readStream = probe.createConformingReadstream();
+  const mp4File = new MP4File();
+  log(`Generating track fragment index for ${absolutePath}`);
+  readStream.pipe(mp4FileWritable(mp4File));
+  await new Promise((resolve, reject) => {
+    readStream.on("end", resolve);
+    readStream.on("error", reject);
+  });
+  const trackFragmentIndexes = {};
+  const trackByteOffsets = {};
+  for await (const fragment of mp4File.fragmentIterator()) {
+    const track = mp4File.getInfo().tracks.find((track2) => track2.id === fragment.track);
+    if (!track) {
+      throw new Error("Track not found");
+    }
+    if (fragment.segment === "init") {
+      trackByteOffsets[fragment.track] = fragment.data.byteLength;
+      if (track?.type === "video") {
+        const videoTrack = mp4File.getInfo().videoTracks.find((track2) => track2.id === fragment.track);
+        if (!videoTrack) {
+          throw new Error("Video track not found");
+        }
+        trackFragmentIndexes[fragment.track] = {
+          track: fragment.track,
+          type: "video",
+          width: videoTrack.video.width,
+          height: videoTrack.video.height,
+          timescale: track.timescale,
+          sample_count: videoTrack.nb_samples,
+          duration: 0,
+          initSegment: {
+            offset: 0,
+            size: fragment.data.byteLength
+          },
+          segments: []
+        };
+      }
+      if (track?.type === "audio") {
+        const audioTrack = mp4File.getInfo().audioTracks.find((track2) => track2.id === fragment.track);
+        if (!audioTrack) {
+          throw new Error("Audio track not found");
+        }
+        trackFragmentIndexes[fragment.track] = {
+          track: fragment.track,
+          type: "audio",
+          channel_count: audioTrack.audio.channel_count,
+          sample_rate: audioTrack.audio.sample_rate,
+          sample_size: audioTrack.audio.sample_size,
+          sample_count: audioTrack.nb_samples,
+          timescale: track.timescale,
+          duration: 0,
+          initSegment: {
+            offset: 0,
+            size: fragment.data.byteLength
+          },
+          segments: []
+        };
+      }
+    } else {
+      const fragmentIndex = trackFragmentIndexes[fragment.track];
+      if (trackByteOffsets[fragment.track] === void 0) {
+        throw new Error("Fragment index not found");
+      }
+      if (!fragmentIndex) {
+        throw new Error("Fragment index not found");
+      }
+      fragmentIndex.duration += fragment.duration;
+      fragmentIndex.segments.push({
+        cts: fragment.cts,
+        dts: fragment.dts,
+        duration: fragment.duration,
+        // biome-ignore lint/style/noNonNullAssertion: This was checked above
+        offset: trackByteOffsets[fragment.track],
+        size: fragment.data.byteLength
+      });
+      trackByteOffsets[fragment.track] += fragment.data.byteLength;
+    }
+  }
+  return JSON.stringify(trackFragmentIndexes, null, 2);
+};
+const generateTrackFragmentIndexTask = idempotentTask({
+  label: "trackFragmentIndex",
+  filename: (absolutePath) => `${basename(absolutePath)}.tracks.json`,
+  runner: generateTrackFragmentIndexFromPath
+});
+const generateTrackFragmentIndex = async (cacheRoot, absolutePath) => {
+  try {
+    return await generateTrackFragmentIndexTask(cacheRoot, absolutePath);
+  } catch (error) {
+    console.trace("Error generating track fragment index", error);
+    throw error;
+  }
+};
+export {
+  generateTrackFragmentIndex
+};

package/package.json

@@ -1,15 +1,20 @@
 {
   "name": "@editframe/assets",
-  "version": "0.6.0-beta.9",
+  "version": "0.7.0-beta.4",
   "description": "",
   "exports": {
     ".": {
-      "import": "./dist/packages/assets/src/index.js",
-      "require": "./dist/packages/assets/src/index.cjs"
+      "import": {
+        "default": "./dist/packages/assets/src/index.js",
+        "types": "./dist/packages/assets/src/index.d.ts"
+      },
+      "require": {
+        "default": "./dist/packages/assets/src/index.cjs",
+        "types": "./dist/packages/assets/src/index.d.ts"
+      }
     }
   },
   "type": "module",
-  "types": "./dist/packages/assets/src/index.d.ts",
   "scripts": {
     "typecheck": "tsc --noEmit --emitDeclarationOnly false",
     "build": "vite build",
@@ -18,6 +23,7 @@
   "author": "",
   "license": "UNLICENSED",
   "dependencies": {
+    "debug": "^4.3.5",
     "mp4box": "^0.5.2",
     "zod": "^3.23.8"
   },

package/src/tasks/cacheImage.ts

@@ -0,0 +1,22 @@
+import { idempotentTask } from "../idempotentTask";
+import { createReadStream } from "node:fs";
+
+import path from "node:path";
+
+const cacheImageTask = idempotentTask({
+  label: "image",
+  filename: (absolutePath: string) => path.basename(absolutePath),
+  runner: async (absolutePath) => {
+    return createReadStream(absolutePath);
+  },
+});
+
+export const cacheImage = async (cacheRoot: string, absolutePath: string) => {
+  try {
+    return await cacheImageTask(cacheRoot, absolutePath);
+  } catch (error) {
+    console.error(error);
+    console.trace("Error generating track fragment index", error);
+    throw error;
+  }
+};

package/src/tasks/findOrCreateCaptions.ts

@@ -0,0 +1,29 @@
+import { execPromise } from "@/util/execPromise";
+import { idempotentTask } from "../idempotentTask";
+import debug from "debug";
+import { basename } from "node:path";
+
+const log = debug("ef:generateCaptions");
+
+const generateCaptionData = idempotentTask({
+  label: "captions",
+  filename: (absolutePath) => `${basename(absolutePath)}.captions.json`,
+  runner: async (absolutePath) => {
+    const command = `whisper_timestamped --language en --efficient --output_format vtt ${absolutePath}`;
+    log(`Running command: ${command}`);
+    const { stdout } = await execPromise(command);
+    return stdout;
+  },
+});
+
+export const findOrCreateCaptions = async (
+  cacheRoot: string,
+  absolutePath: string,
+) => {
+  try {
+    return await generateCaptionData(cacheRoot, absolutePath);
+  } catch (error) {
+    console.trace("Error finding or creating captions", error);
+    throw error;
+  }
+};