@storyteller-platform/align 0.1.27 → 0.1.28

package/dist/align/align.js

@@ -2,11 +2,24 @@ import {
   __callDispose,
   __using
 } from "../chunk-BIEQXUOY.js";
-import { copyFile, mkdir, readFile, readdir, writeFile } from "node:fs/promises";
-import { dirname as autoDirname, join as autoJoin } from "node:path";
+import { randomUUID } from "node:crypto";
+import { createWriteStream } from "node:fs";
+import {
+  copyFile,
+  cp,
+  mkdir,
+  readFile,
+  readdir,
+  rm,
+  writeFile
+} from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname as autoDirname, extname, join as autoJoin } from "node:path";
 import { basename, dirname, parse, relative } from "node:path/posix";
+import { LocalizedString } from "@readium/shared";
 import { enumerate, max } from "itertools";
 import memoize from "memoize";
+import { ZipFile } from "yazl";
 import { isAudioFile, lookupAudioMime } from "@storyteller-platform/audiobook";
 import {
   Epub
@@ -19,6 +32,10 @@ import { getTrackDuration } from "../common/ffmpeg.js";
 import { parseDom } from "../markup/parseDom.js";
 import { segmentChapter } from "../markup/segmentation.js";
 import { inlineFootnotes, liftText } from "../markup/transform.js";
+import {
+  generateGuidedNavigationDocuments,
+  generateGuidedNavigationManifest
+} from "../readium/guidedNavigation.js";
 import {
   collapseSentenceRangeGaps,
   expandEmptySentenceRanges,
@@ -29,16 +46,19 @@ import {
 import { interpolateSentenceRanges } from "./interpolateSentenceRanges.js";
 import { findBoundaries } from "./search.js";
 import { slugify } from "./slugify.js";
-import { TextFragmentTrie } from "./textFragments.js";
+import { TextFragmentFactory } from "./textFragments.js";
 async function align(input, output, transcriptionsDir, audiobookDir, options) {
-  var _stack = [];
+  var _stack2 = [];
   try {
-    await mkdir(dirname(output), { recursive: true });
-    await copyFile(input, output);
+    const outFormat = options.outFormat ?? "epub";
+    if (outFormat === "epub") {
+      await mkdir(dirname(output), { recursive: true });
+      await copyFile(input, output);
+    }
     const audiobookFiles = await readdir(audiobookDir).then(
       (filenames) => filenames.filter((f) => isAudioFile(f)).map((f) => autoJoin(audiobookDir, f))
     );
-    const epub = __using(_stack, await Epub.from(output));
+    const epub = __using(_stack2, await Epub.from(outFormat === "epub" ? output : input));
     const transcriptions = await readdir(transcriptionsDir).then(
       (filenames) => filenames.filter((f) => f.endsWith(".json")).map((f) => autoJoin(transcriptionsDir, f))
     ).then(
@@ -70,7 +90,57 @@ async function align(input, output, transcriptionsDir, audiobookDir, options) {
       options.logger
     );
     const timing = await aligner.alignBook(options.onProgress);
-    await epub.saveAndClose();
+    if (outFormat === "epub") {
+      await epub.saveAndClose();
+    } else {
+      var _stack = [];
+      try {
+        const guidedNavigationDocuments = await generateGuidedNavigationDocuments(epub);
+        const manifest = generateGuidedNavigationManifest(
+          new LocalizedString(
+            await epub.getTitle() ?? basename(input, extname(input))
+          ),
+          guidedNavigationDocuments
+        );
+        const tmpArchivePath = autoJoin(
+          tmpdir(),
+          `storyteller-platform-epub-${randomUUID()}`
+        );
+        const { promise, resolve } = Promise.withResolvers();
+        const zipfile = new ZipFile();
+        const writeStream = createWriteStream(tmpArchivePath);
+        writeStream.on("close", () => {
+          resolve();
+        });
+        const stack = __using(_stack, new AsyncDisposableStack(), true);
+        stack.defer(async () => {
+          writeStream.close();
+          await rm(tmpArchivePath, { force: true });
+        });
+        zipfile.outputStream.pipe(writeStream);
+        zipfile.addBuffer(
+          Buffer.from(JSON.stringify(manifest.serialize())),
+          "manifest.json"
+        );
+        for (const doc of guidedNavigationDocuments) {
+          const selfLink = doc.links?.findWithRel("self");
+          if (!selfLink) continue;
+          zipfile.addBuffer(
+            Buffer.from(JSON.stringify(doc.serialize())),
+            selfLink.href
+          );
+        }
+        zipfile.end();
+        await promise;
+        await cp(tmpArchivePath, output);
+        epub.discardAndClose();
+      } catch (_) {
+        var _error = _, _hasError = true;
+      } finally {
+        var _promise = __callDispose(_stack, _error, _hasError);
+        _promise && await _promise;
+      }
+    }
     if (options.reportsPath) {
       await mkdir(autoDirname(options.reportsPath), { recursive: true });
       await writeFile(
@@ -82,10 +152,10 @@ async function align(input, output, transcriptionsDir, audiobookDir, options) {
       );
     }
     return timing;
-  } catch (_) {
-    var _error = _, _hasError = true;
+  } catch (_2) {
+    var _error2 = _2, _hasError2 = true;
   } finally {
-    __callDispose(_stack, _error, _hasError);
+    __callDispose(_stack2, _error2, _hasError2);
   }
 }
 class Aligner {
@@ -122,6 +192,7 @@ class Aligner {
     const locale = this.languageOverride ?? await this.epub.getLanguage() ?? new Intl.Locale("en-US");
     const { chapter, sentenceRanges, wordRanges, xml } = alignedChapter;
     const sentences = await this.getChapterSentences(chapter.id);
+    let sentenceIdToBlockFragment = null;
     const sentenceIdToFragment = new Map(
       sentenceRanges.map((range) => [
         range.id,
@@ -142,34 +213,67 @@ class Aligner {
     );
     const wordRangeMap = new Map(wordRanges.map((w) => [w[0].sentenceId, w]));
     if (this.textRef === "text-fragment") {
-      const trie = new TextFragmentTrie(
-        sentences.map((s) => s.text.replace("\n", " ")),
+      sentenceIdToBlockFragment = /* @__PURE__ */ new Map();
+      const blocks = [[]];
+      for (const [i, sentence] of enumerate(sentences)) {
+        const text = sentence.text;
+        blocks.at(-1)?.push(text);
+        if (text.includes("\n") && i < sentences.length - 1) {
+          blocks.push([]);
+        }
+      }
+      const blockFactory = new TextFragmentFactory(
+        blocks.map((block) => block.join("")),
         locale
       );
-      for (const range of sentenceRanges) {
-        const sentence = sentences[range.id];
-        sentenceIdToFragment.set(
-          range.id,
-          trie.findMinimalFragment(
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            range.id
-          )
+      let sentenceRangeIndex = 0;
+      for (const [i, block] of enumerate(blocks)) {
+        sentenceIdToBlockFragment.set(
+          sentenceRangeIndex,
+          blockFactory.findMinimalFragment(i)
         );
+        const sentenceFactory = new TextFragmentFactory(
+          block.map((s) => s.replace("\n", "")),
+          locale
+        );
+        const blockRanges = sentenceRanges.slice(
+          sentenceRangeIndex,
+          sentenceRangeIndex + block.length
+        );
+        for (const [j, range] of enumerate(blockRanges)) {
+          sentenceIdToFragment.set(
+            range.id,
+            sentenceFactory.findMinimalFragment(j)
+          );
+        }
         if (this.granularity === "word") {
-          const wordRanges2 = wordRangeMap.get(range.id);
-          const toFragment = wordIdToFragment.get(range.id);
-          const words = sentence.words.entries.filter((w) => w.text.match(/\S/));
-          const wordTrie = new TextFragmentTrie(
-            words.map((w) => w.text.replace("\n", " ")),
-            locale
+          const wordFactory = new TextFragmentFactory(
+            blockRanges.flatMap((range) => {
+              const sentence = sentences[range.id];
+              const wordRanges2 = wordRangeMap.get(range.id);
+              const toFragment = wordIdToFragment.get(range.id);
+              if (!wordRanges2 || !toFragment) return [];
+              const words = sentence.words.entries.filter(
+                (w) => w.text.match(/\S/)
+              );
+              return words.map((w) => w.text.replace("\n", ""));
+            })
           );
-          for (const wordRange of wordRanges2) {
-            toFragment.set(
-              wordRange.id,
-              wordTrie.findMinimalFragment(wordRange.id)
-            );
+          let wordRangeIndex = 0;
+          for (const range of blockRanges) {
+            const wordRanges2 = wordRangeMap.get(range.id);
+            const toFragment = wordIdToFragment.get(range.id);
+            if (!wordRanges2 || !toFragment) continue;
+            for (const [k, wordRange] of enumerate(wordRanges2)) {
+              toFragment.set(
+                wordRange.id,
+                wordFactory.findMinimalFragment(k + wordRangeIndex)
+              );
+            }
+            wordRangeIndex += wordRanges2.length;
           }
         }
+        sentenceRangeIndex += block.length;
       }
     }
     const audiofiles = Array.from(
@@ -209,6 +313,7 @@ class Aligner {
         this.granularity,
         sentenceRanges,
         wordRangeMap,
+        sentenceIdToBlockFragment,
         sentenceIdToFragment,
         wordIdToFragment
       ),
@@ -507,7 +612,23 @@ class Aligner {
     return this.timing;
   }
 }
-function createMediaOverlay(chapter, granularity, sentenceRanges, wordRanges, sentenceIdToFragment, wordIdToFragment) {
+function createMediaOverlay(chapter, granularity, sentenceRanges, wordRanges, sentenceIdToBlockFragment, sentenceIdToFragment, wordIdToFragment) {
+  const subSequences = sentenceIdToBlockFragment ? createTextRangeLargeSequences(
+    chapter,
+    granularity,
+    sentenceRanges,
+    wordRanges,
+    sentenceIdToBlockFragment,
+    sentenceIdToFragment,
+    wordIdToFragment
+  ) : createTextRangeSmallSequences(
+    chapter,
+    granularity,
+    sentenceRanges,
+    wordRanges,
+    sentenceIdToFragment,
+    wordIdToFragment
+  );
   return [
     Epub.createXmlElement(
       "smil",
@@ -525,60 +646,89 @@ function createMediaOverlay(chapter, granularity, sentenceRanges, wordRanges, se
               "epub:textref": `../${chapter.href}`,
               "epub:type": "chapter"
             },
-            sentenceRanges.map((sentenceRange) => {
-              if (granularity === "sentence" || !wordRanges.has(sentenceRange.id)) {
-                return Epub.createXmlElement(
-                  "par",
-                  {
-                    id: `${chapter.id}-s${sentenceRange.id}`
-                  },
-                  [
-                    Epub.createXmlElement("text", {
-                      src: `../${chapter.href}#${sentenceIdToFragment.get(sentenceRange.id)}`
-                    }),
-                    Epub.createXmlElement("audio", {
-                      src: `../Audio/${basename(sentenceRange.audiofile)}`,
-                      clipBegin: `${sentenceRange.start.toFixed(3)}s`,
-                      clipEnd: `${sentenceRange.end.toFixed(3)}s`
-                    })
-                  ]
-                );
-              }
-              const words = wordRanges.get(sentenceRange.id);
-              const wordToFragment = wordIdToFragment.get(sentenceRange.id);
-              return Epub.createXmlElement(
-                "seq",
-                {
-                  id: `${chapter.id}-s${sentenceRange.id}`,
-                  "epub:type": "text-range-small",
-                  "epub:textref": `../${chapter.href}#${sentenceIdToFragment.get(sentenceRange.id)}`
-                },
-                words.map(
-                  (word) => Epub.createXmlElement(
-                    "par",
-                    {
-                      id: `${chapter.id}-s${sentenceRange.id}-w${word.id}`
-                    },
-                    [
-                      Epub.createXmlElement("text", {
-                        src: `../${chapter.href}#${wordToFragment.get(word.id)}`
-                      }),
-                      Epub.createXmlElement("audio", {
-                        src: `../Audio/${basename(word.audiofile)}`,
-                        clipBegin: `${word.start.toFixed(3)}s`,
-                        clipEnd: `${word.end.toFixed(3)}s`
-                      })
-                    ]
-                  )
-                )
-              );
-            })
+            subSequences
           )
         ])
       ]
     )
   ];
 }
+function createTextRangeLargeSequences(chapter, granularity, sentenceRanges, wordRanges, sentenceIdToBlockFragment, sentenceIdToFragment, wordIdToFragment) {
+  const blockStarts = sentenceIdToBlockFragment.entries().toArray().toSorted(([a], [b]) => a - b);
+  return blockStarts.map(([sentenceId, fragment], index) => {
+    const blockEnd = index === blockStarts.length - 1 ? sentenceRanges.length - 1 : (
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      blockStarts[index + 1][0]
+    );
+    const sentences = sentenceRanges.slice(sentenceId, blockEnd);
+    return Epub.createXmlElement(
+      "seq",
+      {
+        id: `${chapter.id}-b${index}`,
+        "epub:type": "text-range-large",
+        "epub:textref": `../${chapter.href}#${fragment}`
+      },
+      createTextRangeSmallSequences(
+        chapter,
+        granularity,
+        sentences,
+        wordRanges,
+        sentenceIdToFragment,
+        wordIdToFragment
+      )
+    );
+  });
+}
+function createTextRangeSmallSequences(chapter, granularity, sentenceRanges, wordRanges, sentenceIdToFragment, wordIdToFragment) {
+  return sentenceRanges.map((sentenceRange) => {
+    if (granularity === "sentence" || !wordRanges.has(sentenceRange.id)) {
+      return Epub.createXmlElement(
+        "par",
+        {
+          id: `${chapter.id}-s${sentenceRange.id}`
+        },
+        [
+          Epub.createXmlElement("text", {
+            src: `../${chapter.href}#${sentenceIdToFragment.get(sentenceRange.id)}`
+          }),
+          Epub.createXmlElement("audio", {
+            src: `../Audio/${basename(sentenceRange.audiofile)}`,
+            clipBegin: `${sentenceRange.start.toFixed(3)}s`,
+            clipEnd: `${sentenceRange.end.toFixed(3)}s`
+          })
+        ]
+      );
+    }
+    const words = wordRanges.get(sentenceRange.id);
+    const wordToFragment = wordIdToFragment.get(sentenceRange.id);
+    return Epub.createXmlElement(
+      "seq",
+      {
+        id: `${chapter.id}-s${sentenceRange.id}`,
+        "epub:type": "text-range-small",
+        "epub:textref": `../${chapter.href}#${sentenceIdToFragment.get(sentenceRange.id)}`
+      },
+      words.map(
+        (word) => Epub.createXmlElement(
+          "par",
+          {
+            id: `${chapter.id}-s${sentenceRange.id}-w${word.id}`
+          },
+          [
+            Epub.createXmlElement("text", {
+              src: `../${chapter.href}#${wordToFragment.get(word.id)}`
+            }),
+            Epub.createXmlElement("audio", {
+              src: `../Audio/${basename(word.audiofile)}`,
+              clipBegin: `${word.start.toFixed(3)}s`,
+              clipEnd: `${word.end.toFixed(3)}s`
+            })
+          ]
+        )
+      )
+    );
+  });
+}
 function concatTranscriptions(transcriptions, audiofiles) {
   return transcriptions.reduce(
     (acc, transcription, index) => ({

package/dist/align/getSentenceRanges.cjs

@@ -312,7 +312,10 @@ async function getSentenceRanges(transcriptionText, mappedTimeline, sentences, c
         wordRanges,
         transcriptionOffset: chapterTranscriptEndIndex,
         firstFoundSentence,
-        lastFoundSentence: chapterSentenceIndex - 1
+        lastFoundSentence: Math.max(
+          firstFoundSentence,
+          chapterSentenceIndex - 1
+        )
       };
     }
     chapterSentenceIndex += lastGoodSentenceIndex + 1;

package/dist/align/getSentenceRanges.js

@@ -285,7 +285,10 @@ async function getSentenceRanges(transcriptionText, mappedTimeline, sentences, c
         wordRanges,
         transcriptionOffset: chapterTranscriptEndIndex,
         firstFoundSentence,
-        lastFoundSentence: chapterSentenceIndex - 1
+        lastFoundSentence: Math.max(
+          firstFoundSentence,
+          chapterSentenceIndex - 1
+        )
       };
     }
     chapterSentenceIndex += lastGoodSentenceIndex + 1;

package/dist/align/parse.cjs

@@ -36,11 +36,17 @@ const alignParser = (0, import_core.object)("Alignment", {
   ),
   textRef: (0, import_core.withDefault)(
     (0, import_core.option)("--text-ref", (0, import_core.choice)(["id-fragment", "text-fragment"]), {
-      description: import_core.message`Whether to use text fragments rather than element id fragments to identify text ranges in generated media overlays.`
+      description: import_core.message`Whether to use text fragments or element id fragments to identify text ranges in generated media overlays.`
     }),
     "id-fragment"
   ),
-  reports: (0, import_core.optional)((0, import_core.option)("--reports", (0, import_valueparser.path)({ type: "directory" })))
+  reports: (0, import_core.optional)((0, import_core.option)("--reports", (0, import_valueparser.path)({ type: "directory" }))),
+  outFormat: (0, import_core.withDefault)(
+    (0, import_core.option)("--out-format", (0, import_core.choice)(["epub", "gnp"]), {
+      description: import_core.message`Whether to output a full EPUB 3 package with embedded media overlays and audio, or a Readium Guided Navigation Package with just a manifest and guided navigation documents.`
+    }),
+    "epub"
+  )
 });
 const alignCommand = (0, import_core.command)(
   "align",
@@ -51,7 +57,12 @@ const alignCommand = (0, import_core.command)(
         "--transcriptions",
         (0, import_valueparser.path)({ mustExist: true, type: "directory" })
       ),
-      output: (0, import_core.option)("--output", (0, import_valueparser.path)({ type: "file", extensions: [".epub"] }))
+      output: (0, import_core.option)(
+        "--output",
+        // TODO: I think it should be possible to pick the correct
+        // extension based on the output format
+        (0, import_valueparser.path)({ type: "file", extensions: [".epub", ".gnp"] })
+      )
     }),
     alignParser,
     import_parse.loggingParser,

package/dist/align/parse.d.cts

@@ -5,11 +5,13 @@ declare const alignParser: _optique_core.Parser<"sync", {
     readonly epub: string;
     readonly textRef: "id-fragment" | "text-fragment";
     readonly reports: string | undefined;
+    readonly outFormat: "epub" | "gnp";
 }, {
     readonly audiobook: _optique_core.ValueParserResult<string> | undefined;
     readonly epub: _optique_core.ValueParserResult<string> | undefined;
     readonly textRef: [_optique_core.ValueParserResult<"id-fragment" | "text-fragment"> | undefined] | undefined;
     readonly reports: [_optique_core.ValueParserResult<string> | undefined] | undefined;
+    readonly outFormat: [_optique_core.ValueParserResult<"epub" | "gnp"> | undefined] | undefined;
 }>;
 declare const alignCommand: _optique_core.Parser<"sync", {
     readonly action: "align";
@@ -20,6 +22,7 @@ declare const alignCommand: _optique_core.Parser<"sync", {
     readonly epub: string;
     readonly textRef: "id-fragment" | "text-fragment";
     readonly reports: string | undefined;
+    readonly outFormat: "epub" | "gnp";
 } & {
     readonly noProgress: boolean;
     readonly logLevel: "silent" | "debug" | "info" | "warn" | "error";

package/dist/align/parse.d.ts

@@ -5,11 +5,13 @@ declare const alignParser: _optique_core.Parser<"sync", {
     readonly epub: string;
     readonly textRef: "id-fragment" | "text-fragment";
     readonly reports: string | undefined;
+    readonly outFormat: "epub" | "gnp";
 }, {
     readonly audiobook: _optique_core.ValueParserResult<string> | undefined;
     readonly epub: _optique_core.ValueParserResult<string> | undefined;
     readonly textRef: [_optique_core.ValueParserResult<"id-fragment" | "text-fragment"> | undefined] | undefined;
     readonly reports: [_optique_core.ValueParserResult<string> | undefined] | undefined;
+    readonly outFormat: [_optique_core.ValueParserResult<"epub" | "gnp"> | undefined] | undefined;
 }>;
 declare const alignCommand: _optique_core.Parser<"sync", {
     readonly action: "align";
@@ -20,6 +22,7 @@ declare const alignCommand: _optique_core.Parser<"sync", {
     readonly epub: string;
     readonly textRef: "id-fragment" | "text-fragment";
     readonly reports: string | undefined;
+    readonly outFormat: "epub" | "gnp";
 } & {
     readonly noProgress: boolean;
     readonly logLevel: "silent" | "debug" | "info" | "warn" | "error";

package/dist/align/parse.js

@@ -27,11 +27,17 @@ const alignParser = object("Alignment", {
   ),
   textRef: withDefault(
     option("--text-ref", choice(["id-fragment", "text-fragment"]), {
-      description: message`Whether to use text fragments rather than element id fragments to identify text ranges in generated media overlays.`
+      description: message`Whether to use text fragments or element id fragments to identify text ranges in generated media overlays.`
     }),
     "id-fragment"
   ),
-  reports: optional(option("--reports", path({ type: "directory" })))
+  reports: optional(option("--reports", path({ type: "directory" }))),
+  outFormat: withDefault(
+    option("--out-format", choice(["epub", "gnp"]), {
+      description: message`Whether to output a full EPUB 3 package with embedded media overlays and audio, or a Readium Guided Navigation Package with just a manifest and guided navigation documents.`
+    }),
+    "epub"
+  )
 });
 const alignCommand = command(
   "align",
@@ -42,7 +48,12 @@ const alignCommand = command(
         "--transcriptions",
         path({ mustExist: true, type: "directory" })
       ),
-      output: option("--output", path({ type: "file", extensions: [".epub"] }))
+      output: option(
+        "--output",
+        // TODO: I think it should be possible to pick the correct
+        // extension based on the output format
+        path({ type: "file", extensions: [".epub", ".gnp"] })
+      )
     }),
     alignParser,
     loggingParser,