@storyteller-platform/align 0.1.21 → 0.1.22

package/dist/align/textFragments.js

@@ -0,0 +1,124 @@
+import "../chunk-BIEQXUOY.js";
+import { enumerate, min } from "itertools";
+import { runes } from "runes2";
+class TextFragmentTrie {
+  root = new Node(null, "");
+  spans;
+  constructor(casedSpans, locale = new Intl.Locale("en-Latn-US")) {
+    this.spans = casedSpans.map((span) => span.toLocaleLowerCase(locale));
+    for (const [i, span] of enumerate(this.spans)) {
+      const parents = [this.root];
+      for (const [j, char] of enumerate(runes(span))) {
+        for (const [k, parent] of enumerate(parents)) {
+          const newNode = new Node(parent, char, { span: i, pos: j });
+          let node = parent.children.find((child) => child.eq(newNode));
+          if (!node) {
+            node = newNode;
+            parent.children.push(node);
+          } else {
+            node.indices.push({ span: i, pos: j });
+          }
+          parents[k] = node;
+        }
+        parents.push(this.root);
+      }
+    }
+  }
+  findMinimalFragment(spanIndex) {
+    let node = this.root;
+    while (node.children.length) {
+      const candidates = node.children.filter(
+        (child2) => child2.indices.some(
+          ({ span: childSpanIndex }) => childSpanIndex === spanIndex
+        )
+      );
+      const child = min(
+        candidates,
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        (c) => c.indices.find((i) => i.span === spanIndex).pos
+      );
+      if (!child) {
+        return this.nodeToFragment(node, spanIndex, true);
+      }
+      if (child.indices.length === 1) {
+        return this.nodeToFragment(child, spanIndex);
+      }
+      node = child;
+    }
+    return this.nodeToFragment(node, spanIndex, true);
+  }
+  nodeToFragment(node, spanIndex, findPrefix) {
+    const span = this.spans[spanIndex];
+    let fragment = ":~:text=";
+    let prefix = "";
+    if (findPrefix) {
+      const prev = this.spans[spanIndex - 1];
+      if (prev) {
+        const prefixes = node.indices.filter(({ span: s }) => s !== spanIndex).map(({ span: spanIndex2, pos }) => {
+          let startNode2 = node;
+          let startPos = pos;
+          while (startNode2.parent && startNode2.parent !== this.root) {
+            startPos -= startNode2.value.length;
+            startNode2 = startNode2.parent;
+          }
+          const prev2 = this.spans[spanIndex2 - 1];
+          const span2 = this.spans[spanIndex2];
+          return (prev2 ?? "") + span2.slice(0, startPos);
+        });
+        const reversedPrefixes = prefixes.map((p) => runes(p).toReversed());
+        for (const [i2, char] of enumerate(runes(prev).toReversed())) {
+          prefix = char + prefix;
+          for (const [j, p] of enumerate([...reversedPrefixes.toReversed()])) {
+            if (p[i2] !== char) {
+              reversedPrefixes.splice(reversedPrefixes.length - 1 - j, 1);
+            }
+          }
+          if (reversedPrefixes.length === 0) {
+            break;
+          }
+        }
+      }
+    }
+    if (prefix) {
+      fragment += `${encodeTextFragmentPart(prefix)}-,`;
+    }
+    let startNode = node;
+    let start = "";
+    while (startNode) {
+      start = startNode.value + start;
+      startNode = startNode.parent;
+    }
+    fragment += encodeTextFragmentPart(start);
+    const remainingSentence = span.slice(start.length + node.value.length);
+    let end = "";
+    let i = remainingSentence.length - 1;
+    while (remainingSentence.indexOf(end) !== i + 1 && i >= node.value.length) {
+      end = remainingSentence.slice(i);
+      i--;
+    }
+    if (end) {
+      fragment += `,${encodeTextFragmentPart(end)}`;
+    }
+    return fragment;
+  }
+}
+function encodeTextFragmentPart(part) {
+  return encodeURIComponent(part).replaceAll(/-/g, "%2d").replaceAll(/,/g, "%2c");
+}
+class Node {
+  constructor(parent, value, firstIndex) {
+    this.parent = parent;
+    this.value = value;
+    if (firstIndex !== void 0) {
+      this.indices.push(firstIndex);
+    }
+  }
+  children = [];
+  indices = [];
+  eq(other) {
+    return this.value === other.value;
+  }
+}
+export {
+  TextFragmentTrie
+};

package/dist/cli/bin.cjs

@@ -85,7 +85,9 @@ 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_parse5 = require("../snapshot/parse.cjs");
+var import_snapshot = require("../snapshot/snapshot.cjs");
+var import_parse6 = require("../transcribe/parse.cjs");
 var import_transcribe = require("../transcribe/transcribe.cjs");
 const pipelineCommand = (0, import_core.merge)(
   (0, import_core.object)({
@@ -110,7 +112,7 @@ const pipelineCommand = (0, import_core.merge)(
     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),
+  (0, import_core.group)("Transcription", import_parse6.transcribeParser),
   import_parse2.granularityParser,
   import_parse2.languageParser,
   import_parse.alignParser,
@@ -118,10 +120,11 @@ const pipelineCommand = (0, import_core.merge)(
 );
 const parser = (0, import_core.or)(
   import_parse4.processCommand,
-  import_parse5.transcribeCommand,
+  import_parse6.transcribeCommand,
   import_parse3.markupCommand,
   import_parse.alignCommand,
-  pipelineCommand
+  pipelineCommand,
+  import_parse5.snapshotCommand
 );
 async function main() {
   var _stack2 = [];
@@ -223,6 +226,7 @@ async function main() {
           parsed.audiobook,
           {
             granularity: parsed.granularity,
+            textRef: parsed.textRef,
             primaryLocale: parsed.language,
             logger,
             ...!parsed.noProgress && parsed.logLevel === "silent" && {
@@ -304,28 +308,33 @@ async function main() {
           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));
+          const markedup = parsed.textRef === "id-fragment" ? parsed.markedup ?? (0, import_node_path.join)(os.tmpdir(), `stalign-markedup-${(0, import_node_crypto.randomUUID)()}.epub`) : parsed.epub;
+          if (parsed.textRef === "id-fragment") {
+            logger.info("Marking up EPUB...");
+            startProgressBar();
+            const markedup2 = 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)(markedup2, { recursive: true, force: true });
+              });
+            }
+            const markupTiming = await (0, import_markup.markup)(parsed.epub, markedup2, {
+              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 ${markedup2}.`);
+            if (parsed.time) {
+              markupTiming.print();
             }
-          });
-          resetProgressBar();
-          logger.info(`Markup complete, marked up EPUB saved to ${markedup}.`);
-          if (parsed.time) {
-            markupTiming.print();
+          } else {
+            logger.info("Skipping markup, text-range-type set to text-fragment");
           }
           logger.info("Aligning EPUB with audiobook...");
           startProgressBar();
@@ -336,6 +345,7 @@ async function main() {
             processedAudio,
             {
               granularity: parsed.granularity,
+              textRef: parsed.textRef,
               primaryLocale,
               logger,
               ...!parsed.noProgress && parsed.logLevel === "silent" && {
@@ -350,12 +360,16 @@ async function main() {
           if (parsed.time) {
             alignTiming.print();
           }
+          break;
         } catch (_) {
           var _error = _, _hasError = true;
         } finally {
           __callDispose(_stack, _error, _hasError);
         }
       }
+      case "snapshot": {
+        await (0, import_snapshot.snapshotAlignment)(parsed.epub, parsed.transcriptions, parsed.output);
+      }
     }
   } catch (_2) {
     var _error2 = _2, _hasError2 = true;

package/dist/cli/bin.js

@@ -36,6 +36,8 @@ 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 { snapshotCommand } from "../snapshot/parse.js";
+import { snapshotAlignment } from "../snapshot/snapshot.js";
 import { transcribeCommand, transcribeParser } from "../transcribe/parse.js";
 import { transcribe } from "../transcribe/transcribe.js";
 const pipelineCommand = merge(
@@ -72,7 +74,8 @@ const parser = or(
   transcribeCommand,
   markupCommand,
   alignCommand,
-  pipelineCommand
+  pipelineCommand,
+  snapshotCommand
 );
 async function main() {
   var _stack2 = [];
@@ -174,6 +177,7 @@ async function main() {
           parsed.audiobook,
           {
             granularity: parsed.granularity,
+            textRef: parsed.textRef,
             primaryLocale: parsed.language,
             logger,
             ...!parsed.noProgress && parsed.logLevel === "silent" && {
@@ -255,28 +259,33 @@ async function main() {
           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));
+          const markedup = parsed.textRef === "id-fragment" ? parsed.markedup ?? join(os.tmpdir(), `stalign-markedup-${randomUUID()}.epub`) : parsed.epub;
+          if (parsed.textRef === "id-fragment") {
+            logger.info("Marking up EPUB...");
+            startProgressBar();
+            const markedup2 = parsed.markedup ?? join(os.tmpdir(), `stalign-markedup-${randomUUID()}.epub`);
+            if (!parsed.markedup) {
+              stack.defer(() => {
+                rmSync(markedup2, { recursive: true, force: true });
+              });
+            }
+            const markupTiming = await markup(parsed.epub, markedup2, {
+              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 ${markedup2}.`);
+            if (parsed.time) {
+              markupTiming.print();
             }
-          });
-          resetProgressBar();
-          logger.info(`Markup complete, marked up EPUB saved to ${markedup}.`);
-          if (parsed.time) {
-            markupTiming.print();
+          } else {
+            logger.info("Skipping markup, text-range-type set to text-fragment");
           }
           logger.info("Aligning EPUB with audiobook...");
           startProgressBar();
@@ -287,6 +296,7 @@ async function main() {
             processedAudio,
             {
               granularity: parsed.granularity,
+              textRef: parsed.textRef,
               primaryLocale,
               logger,
               ...!parsed.noProgress && parsed.logLevel === "silent" && {
@@ -301,12 +311,16 @@ async function main() {
           if (parsed.time) {
             alignTiming.print();
           }
+          break;
         } catch (_) {
           var _error = _, _hasError = true;
         } finally {
           __callDispose(_stack, _error, _hasError);
         }
       }
+      case "snapshot": {
+        await snapshotAlignment(parsed.epub, parsed.transcriptions, parsed.output);
+      }
     }
   } catch (_2) {
     var _error2 = _2, _hasError2 = true;

package/dist/index.d.cts

@@ -6,6 +6,7 @@ import '@storyteller-platform/ghost-story';
 import '@esfx/async-semaphore';
 import 'pino';
 import './process/AudioEncoding.cjs';
+import '@storyteller-platform/ghost-story/constants';
 import '@echogarden/text-segmentation';
 import '@storyteller-platform/epub';
 import './markup/map.cjs';

package/dist/index.d.ts

@@ -6,6 +6,7 @@ import '@storyteller-platform/ghost-story';
 import '@esfx/async-semaphore';
 import 'pino';
 import './process/AudioEncoding.js';
+import '@storyteller-platform/ghost-story/constants';
 import '@echogarden/text-segmentation';
 import '@storyteller-platform/epub';
 import './markup/map.js';

package/dist/snapshot/parse.cjs

@@ -0,0 +1,61 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var parse_exports = {};
+__export(parse_exports, {
+  snapshotCommand: () => snapshotCommand,
+  snapshotParser: () => snapshotParser
+});
+module.exports = __toCommonJS(parse_exports);
+var import_core = require("@optique/core");
+var import_run = require("@optique/run");
+var import_parse = require("../common/parse.cjs");
+const snapshotParser = (0, import_core.object)("Snapshot", {
+  transcriptions: (0, import_core.option)(
+    "--transcriptions",
+    (0, import_run.path)({ mustExist: true, type: "directory" })
+  ),
+  epub: (0, import_core.option)(
+    "--epub",
+    (0, import_run.path)({ mustExist: true, type: "file", extensions: [".epub"] }),
+    {
+      description: import_core.message`Path to an EPUB file to snapshot. This EPUB must have Media Overlays and audio files corresponding to the transcription files passed to --transcriptions.`
+    }
+  ),
+  output: (0, import_core.argument)((0, import_run.path)({ type: "file", metavar: "OUTPUT_PATH" }), {
+    description: import_core.message`Path to save the snapshot.`
+  })
+});
+const snapshotCommand = (0, import_core.command)(
+  "snapshot",
+  (0, import_core.merge)(
+    (0, import_core.object)({
+      action: (0, import_core.constant)("snapshot")
+    }),
+    snapshotParser,
+    import_parse.loggingParser
+  ),
+  {
+    description: import_core.message`Print a human-readable snapshot of the EPUB’s alignment to a text file.`
+  }
+);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  snapshotCommand,
+  snapshotParser
+});

package/dist/snapshot/parse.d.cts

@@ -0,0 +1,24 @@
+import * as _optique_core from '@optique/core';
+
+declare const snapshotParser: _optique_core.Parser<"sync", {
+    readonly transcriptions: string;
+    readonly epub: string;
+    readonly output: string;
+}, {
+    readonly transcriptions: _optique_core.ValueParserResult<string> | undefined;
+    readonly epub: _optique_core.ValueParserResult<string> | undefined;
+    readonly output: _optique_core.ValueParserResult<string> | undefined;
+}>;
+declare const snapshotCommand: _optique_core.Parser<"sync", {
+    readonly action: "snapshot";
+} & {
+    readonly transcriptions: string;
+    readonly epub: string;
+    readonly output: string;
+} & {
+    readonly noProgress: boolean;
+    readonly logLevel: "silent" | "debug" | "info" | "warn" | "error";
+    readonly time: boolean;
+}, ["matched", string] | ["parsing", Record<string | symbol, unknown>] | undefined>;
+
+export { snapshotCommand, snapshotParser };

package/dist/snapshot/parse.d.ts

@@ -0,0 +1,24 @@
+import * as _optique_core from '@optique/core';
+
+declare const snapshotParser: _optique_core.Parser<"sync", {
+    readonly transcriptions: string;
+    readonly epub: string;
+    readonly output: string;
+}, {
+    readonly transcriptions: _optique_core.ValueParserResult<string> | undefined;
+    readonly epub: _optique_core.ValueParserResult<string> | undefined;
+    readonly output: _optique_core.ValueParserResult<string> | undefined;
+}>;
+declare const snapshotCommand: _optique_core.Parser<"sync", {
+    readonly action: "snapshot";
+} & {
+    readonly transcriptions: string;
+    readonly epub: string;
+    readonly output: string;
+} & {
+    readonly noProgress: boolean;
+    readonly logLevel: "silent" | "debug" | "info" | "warn" | "error";
+    readonly time: boolean;
+}, ["matched", string] | ["parsing", Record<string | symbol, unknown>] | undefined>;
+
+export { snapshotCommand, snapshotParser };

package/dist/snapshot/parse.js

@@ -0,0 +1,45 @@
+import "../chunk-BIEQXUOY.js";
+import {
+  argument,
+  command,
+  constant,
+  merge,
+  message,
+  object,
+  option
+} from "@optique/core";
+import { path } from "@optique/run";
+import { loggingParser } from "../common/parse.js";
+const snapshotParser = object("Snapshot", {
+  transcriptions: option(
+    "--transcriptions",
+    path({ mustExist: true, type: "directory" })
+  ),
+  epub: option(
+    "--epub",
+    path({ mustExist: true, type: "file", extensions: [".epub"] }),
+    {
+      description: message`Path to an EPUB file to snapshot. This EPUB must have Media Overlays and audio files corresponding to the transcription files passed to --transcriptions.`
+    }
+  ),
+  output: argument(path({ type: "file", metavar: "OUTPUT_PATH" }), {
+    description: message`Path to save the snapshot.`
+  })
+});
+const snapshotCommand = command(
+  "snapshot",
+  merge(
+    object({
+      action: constant("snapshot")
+    }),
+    snapshotParser,
+    loggingParser
+  ),
+  {
+    description: message`Print a human-readable snapshot of the EPUB’s alignment to a text file.`
+  }
+);
+export {
+  snapshotCommand,
+  snapshotParser
+};