@storyteller-platform/align 0.0.1

package/dist/cli/bin.cjs

@@ -0,0 +1,368 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __using = (stack, value, async) => {
+  if (value != null) {
+    if (typeof value !== "object" && typeof value !== "function") __typeError("Object expected");
+    var dispose, inner;
+    if (async) dispose = value[__knownSymbol("asyncDispose")];
+    if (dispose === void 0) {
+      dispose = value[__knownSymbol("dispose")];
+      if (async) inner = dispose;
+    }
+    if (typeof dispose !== "function") __typeError("Object not disposable");
+    if (inner) dispose = function() {
+      try {
+        inner.call(this);
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    };
+    stack.push([async, dispose, value]);
+  } else if (async) {
+    stack.push([async]);
+  }
+  return value;
+};
+var __callDispose = (stack, error, hasError) => {
+  var E = typeof SuppressedError === "function" ? SuppressedError : function(e, s, m, _) {
+    return _ = Error(m), _.name = "SuppressedError", _.error = e, _.suppressed = s, _;
+  };
+  var fail = (e) => error = hasError ? new E(e, error, "An error was suppressed during disposal") : (hasError = true, e);
+  var next = (it) => {
+    while (it = stack.pop()) {
+      try {
+        var result = it[1] && it[1].call(it[2]);
+        if (it[0]) return Promise.resolve(result).then(next, (e) => (fail(e), next()));
+      } catch (e) {
+        fail(e);
+      }
+    }
+    if (hasError) throw error;
+  };
+  return next();
+};
+var import_node_crypto = require("node:crypto");
+var import_node_fs = require("node:fs");
+var os = __toESM(require("node:os"), 1);
+var import_node_path = require("node:path");
+var import_core = require("@optique/core");
+var import_run = require("@optique/run");
+var import_valueparser = require("@optique/run/valueparser");
+var import_cli_progress = require("cli-progress");
+var import_epub = require("@storyteller-platform/epub");
+var import_package = __toESM(require("../../package.json"), 1);
+var import_align = require("../align/align.cjs");
+var import_parse = require("../align/parse.cjs");
+var import_logging = require("../common/logging.cjs");
+var import_parse2 = require("../common/parse.cjs");
+var import_markup = require("../markup/markup.cjs");
+var import_parse3 = require("../markup/parse.cjs");
+var import_parse4 = require("../process/parse.cjs");
+var import_processAudiobook = require("../process/processAudiobook.cjs");
+var import_parse5 = require("../transcribe/parse.cjs");
+var import_transcribe = require("../transcribe/transcribe.cjs");
+const pipelineCommand = (0, import_core.merge)(
+  (0, import_core.object)({
+    action: (0, import_core.constant)("pipeline"),
+    processedAudio: (0, import_core.optional)(
+      (0, import_core.option)("--processed-audio", (0, import_valueparser.path)({ type: "directory" }))
+    ),
+    transcriptions: (0, import_core.optional)(
+      (0, import_core.option)("--transcriptions", (0, import_valueparser.path)({ type: "directory" }))
+    ),
+    markedup: (0, import_core.optional)(
+      (0, import_core.option)("--markedup", (0, import_valueparser.path)({ type: "file", extensions: [".epub"] }))
+    ),
+    parallelTranscodes: (0, import_core.withDefault)(
+      (0, import_core.option)("--parallel-transcodes", (0, import_core.integer)()),
+      1
+    ),
+    parallelTranscribes: (0, import_core.withDefault)(
+      (0, import_core.option)("--parallel-transcribes", (0, import_core.integer)()),
+      1
+    ),
+    output: (0, import_core.option)("--output", (0, import_valueparser.path)({ type: "file", extensions: [".epub"] }))
+  }),
+  import_parse4.processParser,
+  (0, import_core.group)("Transcription", import_parse5.transcribeParser),
+  import_parse2.granularityParser,
+  import_parse2.languageParser,
+  import_parse.alignParser,
+  import_parse2.loggingParser
+);
+const parser = (0, import_core.or)(
+  import_parse4.processCommand,
+  import_parse5.transcribeCommand,
+  import_parse3.markupCommand,
+  import_parse.alignCommand,
+  pipelineCommand
+);
+async function main() {
+  var _stack2 = [];
+  try {
+    const parsed = (0, import_run.run)(parser, {
+      showChoices: true,
+      showDefault: true,
+      version: import_package.default.version,
+      completion: "command",
+      help: "both",
+      description: import_core.message`A CLI to automatically align audiobooks and EPUB files, producing EPUBs with Media Overlays.`
+    });
+    const controller = new AbortController();
+    let progressBar;
+    function resetProgressBar() {
+      progressBar == null ? void 0 : progressBar.stop();
+      progressBar = new import_cli_progress.SingleBar(
+        { etaBuffer: 4, hideCursor: null, noTTYOutput: !process.stderr.isTTY },
+        import_cli_progress.Presets.shades_classic
+      );
+    }
+    function startProgressBar() {
+      if (!parsed.noProgress && parsed.logLevel === "silent") {
+        progressBar.start(100, 0);
+      }
+    }
+    resetProgressBar();
+    process.on("SIGINT", () => {
+      controller.abort();
+      process.exit();
+    });
+    const stack = __using(_stack2, new DisposableStack());
+    stack.defer(() => {
+      progressBar.stop();
+    });
+    startProgressBar();
+    const logger = (0, import_logging.createLogger)(parsed.logLevel);
+    switch (parsed.action) {
+      case "process": {
+        const timing = await (0, import_processAudiobook.processAudiobook)(parsed.input, parsed.output, {
+          encoding: { codec: parsed.codec, bitrate: parsed.bitrate },
+          maxLength: parsed.maxLength / 60,
+          parallelism: parsed.parallelism,
+          signal: controller.signal,
+          logger,
+          ...!parsed.noProgress && parsed.logLevel === "silent" && {
+            onProgress: (progress) => {
+              progressBar.update(Math.floor(progress * 100));
+            }
+          }
+        });
+        if (parsed.time) {
+          timing.print("Process audiobook");
+        }
+        break;
+      }
+      case "transcribe": {
+        const timing = await (0, import_transcribe.transcribe)(
+          parsed.input,
+          parsed.output,
+          parsed.language ?? new Intl.Locale("en-US"),
+          {
+            ...parsed,
+            signal: controller.signal,
+            logger,
+            ...!parsed.noProgress && parsed.logLevel === "silent" && {
+              onProgress: (progress) => {
+                progressBar.update(Math.floor(progress * 100));
+              }
+            }
+          }
+        );
+        if (parsed.time) {
+          timing.print("Process audiobook");
+        }
+        break;
+      }
+      case "markup": {
+        const timing = await (0, import_markup.markup)(parsed.input, parsed.output, {
+          primaryLocale: parsed.language ?? new Intl.Locale("en-US"),
+          granularity: parsed.granularity,
+          logger,
+          ...!parsed.noProgress && parsed.logLevel === "silent" && {
+            onProgress: (progress) => {
+              progressBar.update(Math.floor(progress * 100));
+            }
+          }
+        });
+        if (parsed.time) {
+          timing.print("Mark up EPUB");
+        }
+        break;
+      }
+      case "align": {
+        const timing = await (0, import_align.align)(
+          parsed.epub,
+          parsed.output,
+          parsed.transcriptions,
+          parsed.audiobook,
+          {
+            granularity: parsed.granularity,
+            primaryLocale: parsed.language,
+            logger,
+            ...!parsed.noProgress && parsed.logLevel === "silent" && {
+              onProgress: (progress) => {
+                progressBar.update(Math.floor(progress * 100));
+              }
+            }
+          }
+        );
+        if (parsed.time) {
+          timing.print("Align EPUB and audiobook");
+        }
+        break;
+      }
+      case "pipeline": {
+        var _stack = [];
+        try {
+          const epub = __using(_stack, await import_epub.Epub.from(parsed.epub));
+          const primaryLocale = parsed.language ?? await epub.getLanguage() ?? new Intl.Locale("en-US");
+          const processedAudio = parsed.processedAudio ?? (0, import_node_path.join)(os.tmpdir(), `stalign-processed-${(0, import_node_crypto.randomUUID)()}`);
+          if (!parsed.processedAudio) {
+            stack.defer(() => {
+              (0, import_node_fs.rmSync)(processedAudio, { recursive: true, force: true });
+            });
+          }
+          const processTiming = await (0, import_processAudiobook.processAudiobook)(
+            parsed.audiobook,
+            processedAudio,
+            {
+              encoding: {
+                codec: parsed.codec,
+                bitrate: parsed.bitrate
+              },
+              maxLength: parsed.maxLength / 60,
+              parallelism: parsed.parallelTranscodes,
+              signal: controller.signal,
+              ...!parsed.noProgress && parsed.logLevel === "silent" && {
+                onProgress: (progress) => {
+                  progressBar.update(Math.floor(progress * 100));
+                }
+              }
+            }
+          );
+          resetProgressBar();
+          logger.info(
+            `Processing audiobook complete, processed files saved to ${processedAudio}.`
+          );
+          if (parsed.time) {
+            processTiming.print();
+          }
+          logger.info("Transcribing...");
+          startProgressBar();
+          const transcriptions = parsed.transcriptions ?? (0, import_node_path.join)(os.tmpdir(), `stalign-transcriptions-${(0, import_node_crypto.randomUUID)()}`);
+          if (!parsed.transcriptions) {
+            stack.defer(() => {
+              (0, import_node_fs.rmSync)(transcriptions, { recursive: true, force: true });
+            });
+          }
+          const transcribeTiming = await (0, import_transcribe.transcribe)(
+            processedAudio,
+            transcriptions,
+            primaryLocale,
+            {
+              ...parsed,
+              parallelism: parsed.parallelTranscribes,
+              signal: controller.signal,
+              logger,
+              ...!parsed.noProgress && parsed.logLevel === "silent" && {
+                onProgress: (progress) => {
+                  progressBar.update(Math.floor(progress * 100));
+                }
+              }
+            }
+          );
+          resetProgressBar();
+          logger.info(
+            `Transcribing audiobook complete, transcriptions saved to ${transcriptions}.`
+          );
+          if (parsed.time) {
+            transcribeTiming.print();
+          }
+          logger.info("Marking up EPUB...");
+          startProgressBar();
+          const markedup = parsed.markedup ?? (0, import_node_path.join)(os.tmpdir(), `stalign-markedup-${(0, import_node_crypto.randomUUID)()}.epub`);
+          if (!parsed.markedup) {
+            stack.defer(() => {
+              (0, import_node_fs.rmSync)(markedup, { recursive: true, force: true });
+            });
+          }
+          const markupTiming = await (0, import_markup.markup)(parsed.epub, markedup, {
+            granularity: parsed.granularity,
+            primaryLocale,
+            logger,
+            ...!parsed.noProgress && parsed.logLevel === "silent" && {
+              onProgress: (progress) => {
+                progressBar.update(Math.floor(progress * 100));
+              }
+            }
+          });
+          resetProgressBar();
+          logger.info(`Markup complete, marked up EPUB saved to ${markedup}.`);
+          if (parsed.time) {
+            markupTiming.print();
+          }
+          logger.info("Aligning EPUB with audiobook...");
+          startProgressBar();
+          const alignTiming = await (0, import_align.align)(
+            markedup,
+            parsed.output,
+            transcriptions,
+            processedAudio,
+            {
+              granularity: parsed.granularity,
+              primaryLocale,
+              logger,
+              ...!parsed.noProgress && parsed.logLevel === "silent" && {
+                onProgress: (progress) => {
+                  progressBar.update(Math.floor(progress * 100));
+                }
+              }
+            }
+          );
+          resetProgressBar();
+          logger.info(`Alignment complete, aligned EPUB saved to ${parsed.output}`);
+          if (parsed.time) {
+            alignTiming.print();
+          }
+        } catch (_) {
+          var _error = _, _hasError = true;
+        } finally {
+          __callDispose(_stack, _error, _hasError);
+        }
+      }
+    }
+  } catch (_2) {
+    var _error2 = _2, _hasError2 = true;
+  } finally {
+    __callDispose(_stack2, _error2, _hasError2);
+  }
+}
+main().catch((e) => {
+  console.error(e);
+});

package/dist/cli/bin.d.cts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli/bin.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli/bin.js

@@ -0,0 +1,319 @@
+#!/usr/bin/env node
+import {
+  __callDispose,
+  __using
+} from "../chunk-BIEQXUOY.js";
+import { randomUUID } from "node:crypto";
+import { rmSync } from "node:fs";
+import * as os from "node:os";
+import { join } from "node:path";
+import {
+  constant,
+  group,
+  integer,
+  merge,
+  message,
+  object,
+  option,
+  optional,
+  or,
+  withDefault
+} from "@optique/core";
+import { run } from "@optique/run";
+import { path } from "@optique/run/valueparser";
+import { Presets, SingleBar } from "cli-progress";
+import { Epub } from "@storyteller-platform/epub";
+import packageJson from "../../package.json";
+import { align } from "../align/align.js";
+import { alignCommand, alignParser } from "../align/parse.js";
+import { createLogger } from "../common/logging.js";
+import {
+  granularityParser,
+  languageParser,
+  loggingParser
+} from "../common/parse.js";
+import { markup } from "../markup/markup.js";
+import { markupCommand } from "../markup/parse.js";
+import { processCommand, processParser } from "../process/parse.js";
+import { processAudiobook } from "../process/processAudiobook.js";
+import { transcribeCommand, transcribeParser } from "../transcribe/parse.js";
+import { transcribe } from "../transcribe/transcribe.js";
+const pipelineCommand = merge(
+  object({
+    action: constant("pipeline"),
+    processedAudio: optional(
+      option("--processed-audio", path({ type: "directory" }))
+    ),
+    transcriptions: optional(
+      option("--transcriptions", path({ type: "directory" }))
+    ),
+    markedup: optional(
+      option("--markedup", path({ type: "file", extensions: [".epub"] }))
+    ),
+    parallelTranscodes: withDefault(
+      option("--parallel-transcodes", integer()),
+      1
+    ),
+    parallelTranscribes: withDefault(
+      option("--parallel-transcribes", integer()),
+      1
+    ),
+    output: option("--output", path({ type: "file", extensions: [".epub"] }))
+  }),
+  processParser,
+  group("Transcription", transcribeParser),
+  granularityParser,
+  languageParser,
+  alignParser,
+  loggingParser
+);
+const parser = or(
+  processCommand,
+  transcribeCommand,
+  markupCommand,
+  alignCommand,
+  pipelineCommand
+);
+async function main() {
+  var _stack2 = [];
+  try {
+    const parsed = run(parser, {
+      showChoices: true,
+      showDefault: true,
+      version: packageJson.version,
+      completion: "command",
+      help: "both",
+      description: message`A CLI to automatically align audiobooks and EPUB files, producing EPUBs with Media Overlays.`
+    });
+    const controller = new AbortController();
+    let progressBar;
+    function resetProgressBar() {
+      progressBar == null ? void 0 : progressBar.stop();
+      progressBar = new SingleBar(
+        { etaBuffer: 4, hideCursor: null, noTTYOutput: !process.stderr.isTTY },
+        Presets.shades_classic
+      );
+    }
+    function startProgressBar() {
+      if (!parsed.noProgress && parsed.logLevel === "silent") {
+        progressBar.start(100, 0);
+      }
+    }
+    resetProgressBar();
+    process.on("SIGINT", () => {
+      controller.abort();
+      process.exit();
+    });
+    const stack = __using(_stack2, new DisposableStack());
+    stack.defer(() => {
+      progressBar.stop();
+    });
+    startProgressBar();
+    const logger = createLogger(parsed.logLevel);
+    switch (parsed.action) {
+      case "process": {
+        const timing = await processAudiobook(parsed.input, parsed.output, {
+          encoding: { codec: parsed.codec, bitrate: parsed.bitrate },
+          maxLength: parsed.maxLength / 60,
+          parallelism: parsed.parallelism,
+          signal: controller.signal,
+          logger,
+          ...!parsed.noProgress && parsed.logLevel === "silent" && {
+            onProgress: (progress) => {
+              progressBar.update(Math.floor(progress * 100));
+            }
+          }
+        });
+        if (parsed.time) {
+          timing.print("Process audiobook");
+        }
+        break;
+      }
+      case "transcribe": {
+        const timing = await transcribe(
+          parsed.input,
+          parsed.output,
+          parsed.language ?? new Intl.Locale("en-US"),
+          {
+            ...parsed,
+            signal: controller.signal,
+            logger,
+            ...!parsed.noProgress && parsed.logLevel === "silent" && {
+              onProgress: (progress) => {
+                progressBar.update(Math.floor(progress * 100));
+              }
+            }
+          }
+        );
+        if (parsed.time) {
+          timing.print("Process audiobook");
+        }
+        break;
+      }
+      case "markup": {
+        const timing = await markup(parsed.input, parsed.output, {
+          primaryLocale: parsed.language ?? new Intl.Locale("en-US"),
+          granularity: parsed.granularity,
+          logger,
+          ...!parsed.noProgress && parsed.logLevel === "silent" && {
+            onProgress: (progress) => {
+              progressBar.update(Math.floor(progress * 100));
+            }
+          }
+        });
+        if (parsed.time) {
+          timing.print("Mark up EPUB");
+        }
+        break;
+      }
+      case "align": {
+        const timing = await align(
+          parsed.epub,
+          parsed.output,
+          parsed.transcriptions,
+          parsed.audiobook,
+          {
+            granularity: parsed.granularity,
+            primaryLocale: parsed.language,
+            logger,
+            ...!parsed.noProgress && parsed.logLevel === "silent" && {
+              onProgress: (progress) => {
+                progressBar.update(Math.floor(progress * 100));
+              }
+            }
+          }
+        );
+        if (parsed.time) {
+          timing.print("Align EPUB and audiobook");
+        }
+        break;
+      }
+      case "pipeline": {
+        var _stack = [];
+        try {
+          const epub = __using(_stack, await Epub.from(parsed.epub));
+          const primaryLocale = parsed.language ?? await epub.getLanguage() ?? new Intl.Locale("en-US");
+          const processedAudio = parsed.processedAudio ?? join(os.tmpdir(), `stalign-processed-${randomUUID()}`);
+          if (!parsed.processedAudio) {
+            stack.defer(() => {
+              rmSync(processedAudio, { recursive: true, force: true });
+            });
+          }
+          const processTiming = await processAudiobook(
+            parsed.audiobook,
+            processedAudio,
+            {
+              encoding: {
+                codec: parsed.codec,
+                bitrate: parsed.bitrate
+              },
+              maxLength: parsed.maxLength / 60,
+              parallelism: parsed.parallelTranscodes,
+              signal: controller.signal,
+              ...!parsed.noProgress && parsed.logLevel === "silent" && {
+                onProgress: (progress) => {
+                  progressBar.update(Math.floor(progress * 100));
+                }
+              }
+            }
+          );
+          resetProgressBar();
+          logger.info(
+            `Processing audiobook complete, processed files saved to ${processedAudio}.`
+          );
+          if (parsed.time) {
+            processTiming.print();
+          }
+          logger.info("Transcribing...");
+          startProgressBar();
+          const transcriptions = parsed.transcriptions ?? join(os.tmpdir(), `stalign-transcriptions-${randomUUID()}`);
+          if (!parsed.transcriptions) {
+            stack.defer(() => {
+              rmSync(transcriptions, { recursive: true, force: true });
+            });
+          }
+          const transcribeTiming = await transcribe(
+            processedAudio,
+            transcriptions,
+            primaryLocale,
+            {
+              ...parsed,
+              parallelism: parsed.parallelTranscribes,
+              signal: controller.signal,
+              logger,
+              ...!parsed.noProgress && parsed.logLevel === "silent" && {
+                onProgress: (progress) => {
+                  progressBar.update(Math.floor(progress * 100));
+                }
+              }
+            }
+          );
+          resetProgressBar();
+          logger.info(
+            `Transcribing audiobook complete, transcriptions saved to ${transcriptions}.`
+          );
+          if (parsed.time) {
+            transcribeTiming.print();
+          }
+          logger.info("Marking up EPUB...");
+          startProgressBar();
+          const markedup = parsed.markedup ?? join(os.tmpdir(), `stalign-markedup-${randomUUID()}.epub`);
+          if (!parsed.markedup) {
+            stack.defer(() => {
+              rmSync(markedup, { recursive: true, force: true });
+            });
+          }
+          const markupTiming = await markup(parsed.epub, markedup, {
+            granularity: parsed.granularity,
+            primaryLocale,
+            logger,
+            ...!parsed.noProgress && parsed.logLevel === "silent" && {
+              onProgress: (progress) => {
+                progressBar.update(Math.floor(progress * 100));
+              }
+            }
+          });
+          resetProgressBar();
+          logger.info(`Markup complete, marked up EPUB saved to ${markedup}.`);
+          if (parsed.time) {
+            markupTiming.print();
+          }
+          logger.info("Aligning EPUB with audiobook...");
+          startProgressBar();
+          const alignTiming = await align(
+            markedup,
+            parsed.output,
+            transcriptions,
+            processedAudio,
+            {
+              granularity: parsed.granularity,
+              primaryLocale,
+              logger,
+              ...!parsed.noProgress && parsed.logLevel === "silent" && {
+                onProgress: (progress) => {
+                  progressBar.update(Math.floor(progress * 100));
+                }
+              }
+            }
+          );
+          resetProgressBar();
+          logger.info(`Alignment complete, aligned EPUB saved to ${parsed.output}`);
+          if (parsed.time) {
+            alignTiming.print();
+          }
+        } catch (_) {
+          var _error = _, _hasError = true;
+        } finally {
+          __callDispose(_stack, _error, _hasError);
+        }
+      }
+    }
+  } catch (_2) {
+    var _error2 = _2, _hasError2 = true;
+  } finally {
+    __callDispose(_stack2, _error2, _hasError2);
+  }
+}
+main().catch((e) => {
+  console.error(e);
+});