@storyteller-platform/align 0.1.56 → 0.1.58

package/dist/align/ctc/mediaOverlay.d.ts

@@ -0,0 +1,16 @@
+import * as _storyteller_platform_epub from '@storyteller-platform/epub';
+import { ManifestItem } from '@storyteller-platform/epub';
+import { SegmentationResult } from '@echogarden/text-segmentation';
+import { SentenceRange, WordRange } from '../getSentenceRanges.js';
+import '@storyteller-platform/ghost-story';
+import '@storyteller-platform/mapping';
+
+declare function createMediaOverlay(chapter: ManifestItem, granularity: "sentence" | "word", sentenceRanges: SentenceRange[], wordRanges: Map<number, WordRange[]>, sentenceIdToBlockFragment: Map<number, string> | null, sentenceIdToFragment: Map<number, string>, wordIdToFragment: Map<number, Map<number, string>>): _storyteller_platform_epub.XmlElement<"smil">[];
+declare function buildFragmentMaps(sentenceRanges: SentenceRange[], wordRanges: WordRange[][], sentences: SegmentationResult["sentences"], locale: Intl.Locale, textRef: "id-fragment" | "text-fragment", granularity: "sentence" | "word"): {
+    sentenceIdToBlockFragment: Map<number, string> | null;
+    sentenceIdToFragment: Map<number, string>;
+    wordIdToFragment: Map<number, Map<number, string>>;
+    wordRangeMap: Map<number, WordRange[]>;
+};
+
+export { buildFragmentMaps, createMediaOverlay };

package/dist/align/ctc/mediaOverlay.js

@@ -0,0 +1,224 @@
+import "../../chunk-BIEQXUOY.js";
+import { basename } from "node:path/posix";
+import { enumerate } from "itertools";
+import { Epub } from "@storyteller-platform/epub";
+import { TextFragmentFactory } from "../textFragments.js";
+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",
+      {
+        xmlns: "http://www.w3.org/ns/SMIL",
+        "xmlns:epub": "http://www.idpf.org/2007/ops",
+        version: "3.0"
+      },
+      [
+        Epub.createXmlElement("body", {}, [
+          Epub.createXmlElement(
+            "seq",
+            {
+              id: `${chapter.id}_overlay`,
+              "epub:textref": `../${chapter.href}`,
+              "epub:type": "chapter"
+            },
+            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 buildFragmentMaps(sentenceRanges, wordRanges, sentences, locale, textRef, granularity) {
+  let sentenceIdToBlockFragment = null;
+  const sentenceIdToFragment = new Map(
+    sentenceRanges.map((range) => [
+      range.id,
+      `${range.chapterId}-s${range.id}`
+    ])
+  );
+  const wordIdToFragment = new Map(
+    wordRanges.map((ranges) => [
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      ranges[0].sentenceId,
+      new Map(
+        ranges.map((range) => [
+          range.id,
+          `${range.chapterId}-s${range.sentenceId}-w${range.id}`
+        ])
+      )
+    ])
+  );
+  const wordRangeMap = new Map(wordRanges.map((w) => [w[0].sentenceId, w]));
+  if (textRef === "text-fragment") {
+    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
+    );
+    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 (granularity === "word") {
+        const allWords = [];
+        for (const range of blockRanges) {
+          const sentence = sentences[range.id];
+          const words = [];
+          for (const w of sentence.words.entries) {
+            if (w.isPunctuation) {
+              const lastWord = words.at(-1);
+              if (lastWord === void 0) {
+                continue;
+              }
+              words[words.length - 1] = lastWord + w.text.replace("\n", "");
+            } else {
+              words.push(w.text);
+            }
+          }
+          allWords.push(...words);
+        }
+        const wordFactory = new TextFragmentFactory(allWords);
+        let wordRangeIndex = 0;
+        for (const range of blockRanges) {
+          const ranges = wordRangeMap.get(range.id);
+          const toFragment = wordIdToFragment.get(range.id);
+          if (!ranges || !toFragment) continue;
+          for (const [k, wordRange] of enumerate(ranges)) {
+            toFragment.set(
+              wordRange.id,
+              wordFactory.findMinimalFragment(k + wordRangeIndex)
+            );
+          }
+          wordRangeIndex += ranges.length;
+        }
+      }
+      sentenceRangeIndex += block.length;
+    }
+  }
+  return {
+    sentenceIdToBlockFragment,
+    sentenceIdToFragment,
+    wordIdToFragment,
+    wordRangeMap
+  };
+}
+export {
+  buildFragmentMaps,
+  createMediaOverlay
+};

package/dist/align/ctc/report.cjs

@@ -0,0 +1,66 @@
+"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 report_exports = {};
+__export(report_exports, {
+  buildAudioFileContexts: () => buildAudioFileContexts,
+  updateAudioFileReports: () => updateAudioFileReports
+});
+module.exports = __toCommonJS(report_exports);
+function buildAudioFileContexts(sentenceRanges) {
+  return sentenceRanges.reduce((acc, range) => {
+    const existing = acc.find((context) => context.filepath === range.audiofile);
+    if (existing) {
+      existing.end = range.end;
+      return acc;
+    }
+    acc.push({
+      filepath: range.audiofile,
+      start: range.start,
+      end: range.end
+    });
+    return acc;
+  }, []);
+}
+function updateAudioFileReports(report, audioFiles, audioFileDurations) {
+  for (const audioFile of audioFiles) {
+    const existing = report.audioFiles.find(
+      ({ filepath }) => audioFile.filepath === filepath
+    );
+    if (existing) {
+      existing.matchedRanges.push({
+        start: audioFile.start,
+        end: audioFile.end
+      });
+      existing.matchedRanges.sort((a, b) => a.start - b.start);
+      existing.alignedDuration += audioFile.end - audioFile.start;
+    } else {
+      report.audioFiles.push({
+        alignedDuration: audioFile.end - audioFile.start,
+        duration: audioFileDurations[audioFile.filepath] ?? 0,
+        filepath: audioFile.filepath,
+        matchedRanges: [{ start: audioFile.start, end: audioFile.end }]
+      });
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildAudioFileContexts,
+  updateAudioFileReports
+});

package/dist/align/ctc/report.d.cts

@@ -0,0 +1,79 @@
+import { ManifestItem, ParsedXml } from '@storyteller-platform/epub';
+import { SentenceRange, WordRange } from '../getSentenceRanges.cjs';
+import '@storyteller-platform/ghost-story';
+import '@echogarden/text-segmentation';
+import '@storyteller-platform/mapping';
+
+type AlignedChapter = {
+    chapter: ManifestItem;
+    chunk?: number;
+    xml: ParsedXml;
+    sentenceRanges: SentenceRange[];
+    wordRanges: WordRange[][];
+    startOffset: number;
+    endOffset: number;
+};
+interface AudioFileContext {
+    start: number;
+    end: number;
+    filepath: string;
+}
+interface ChapterReport {
+    href: string;
+    spineIndex: number;
+    chunk: number;
+    score: number;
+    transcriptionOffset: number;
+    endTranscriptionOffset: number;
+    firstMatchedSentenceId: number;
+    firstMatchedSentenceContext: {
+        prevSentence: string | null;
+        matchedSentence: string;
+        nextSentence: string | null;
+    };
+    lastMatchedSentenceId: number;
+    lastMatchedSentenceContext: {
+        prevSentence: string | null;
+        matchedSentence: string;
+        nextSentence: string | null;
+    };
+    chapterSentenceCount: number;
+    alignedSentenceCount: number;
+    audioFiles: AudioFileContext[];
+}
+type UnalignedChapterReason = "too-short" | "not-found" | "is-nav" | "no-text";
+interface UnalignedChapterReport {
+    href: string;
+    reason: Exclude<UnalignedChapterReason, "not-found">;
+}
+interface UnalignedNotFoundChapterReport {
+    href: string;
+    spineIndex: number;
+    score: number;
+    chapterSentenceCount: number;
+    reason: "not-found";
+    start: string;
+    end: string;
+}
+interface AudioFileReport {
+    filepath: string;
+    matchedRanges: {
+        start: number;
+        end: number;
+    }[];
+    duration: number;
+    alignedDuration: number;
+}
+interface UnalignedAudioFileReport {
+    filepath: string;
+}
+interface Report {
+    chapters: ChapterReport[];
+    unalignedChapters: (UnalignedChapterReport | UnalignedNotFoundChapterReport)[];
+    audioFiles: AudioFileReport[];
+    unalignedAudioFiles: UnalignedAudioFileReport[];
+}
+declare function buildAudioFileContexts(sentenceRanges: SentenceRange[]): AudioFileContext[];
+declare function updateAudioFileReports(report: Report, audioFiles: AudioFileContext[], audioFileDurations: Record<string, number>): void;
+
+export { type AlignedChapter, type AudioFileContext, type AudioFileReport, type ChapterReport, type Report, type UnalignedAudioFileReport, type UnalignedChapterReason, type UnalignedChapterReport, type UnalignedNotFoundChapterReport, buildAudioFileContexts, updateAudioFileReports };

package/dist/align/ctc/report.d.ts

@@ -0,0 +1,79 @@
+import { ManifestItem, ParsedXml } from '@storyteller-platform/epub';
+import { SentenceRange, WordRange } from '../getSentenceRanges.js';
+import '@storyteller-platform/ghost-story';
+import '@echogarden/text-segmentation';
+import '@storyteller-platform/mapping';
+
+type AlignedChapter = {
+    chapter: ManifestItem;
+    chunk?: number;
+    xml: ParsedXml;
+    sentenceRanges: SentenceRange[];
+    wordRanges: WordRange[][];
+    startOffset: number;
+    endOffset: number;
+};
+interface AudioFileContext {
+    start: number;
+    end: number;
+    filepath: string;
+}
+interface ChapterReport {
+    href: string;
+    spineIndex: number;
+    chunk: number;
+    score: number;
+    transcriptionOffset: number;
+    endTranscriptionOffset: number;
+    firstMatchedSentenceId: number;
+    firstMatchedSentenceContext: {
+        prevSentence: string | null;
+        matchedSentence: string;
+        nextSentence: string | null;
+    };
+    lastMatchedSentenceId: number;
+    lastMatchedSentenceContext: {
+        prevSentence: string | null;
+        matchedSentence: string;
+        nextSentence: string | null;
+    };
+    chapterSentenceCount: number;
+    alignedSentenceCount: number;
+    audioFiles: AudioFileContext[];
+}
+type UnalignedChapterReason = "too-short" | "not-found" | "is-nav" | "no-text";
+interface UnalignedChapterReport {
+    href: string;
+    reason: Exclude<UnalignedChapterReason, "not-found">;
+}
+interface UnalignedNotFoundChapterReport {
+    href: string;
+    spineIndex: number;
+    score: number;
+    chapterSentenceCount: number;
+    reason: "not-found";
+    start: string;
+    end: string;
+}
+interface AudioFileReport {
+    filepath: string;
+    matchedRanges: {
+        start: number;
+        end: number;
+    }[];
+    duration: number;
+    alignedDuration: number;
+}
+interface UnalignedAudioFileReport {
+    filepath: string;
+}
+interface Report {
+    chapters: ChapterReport[];
+    unalignedChapters: (UnalignedChapterReport | UnalignedNotFoundChapterReport)[];
+    audioFiles: AudioFileReport[];
+    unalignedAudioFiles: UnalignedAudioFileReport[];
+}
+declare function buildAudioFileContexts(sentenceRanges: SentenceRange[]): AudioFileContext[];
+declare function updateAudioFileReports(report: Report, audioFiles: AudioFileContext[], audioFileDurations: Record<string, number>): void;
+
+export { type AlignedChapter, type AudioFileContext, type AudioFileReport, type ChapterReport, type Report, type UnalignedAudioFileReport, type UnalignedChapterReason, type UnalignedChapterReport, type UnalignedNotFoundChapterReport, buildAudioFileContexts, updateAudioFileReports };

package/dist/align/ctc/report.js

@@ -0,0 +1,42 @@
+import "../../chunk-BIEQXUOY.js";
+function buildAudioFileContexts(sentenceRanges) {
+  return sentenceRanges.reduce((acc, range) => {
+    const existing = acc.find((context) => context.filepath === range.audiofile);
+    if (existing) {
+      existing.end = range.end;
+      return acc;
+    }
+    acc.push({
+      filepath: range.audiofile,
+      start: range.start,
+      end: range.end
+    });
+    return acc;
+  }, []);
+}
+function updateAudioFileReports(report, audioFiles, audioFileDurations) {
+  for (const audioFile of audioFiles) {
+    const existing = report.audioFiles.find(
+      ({ filepath }) => audioFile.filepath === filepath
+    );
+    if (existing) {
+      existing.matchedRanges.push({
+        start: audioFile.start,
+        end: audioFile.end
+      });
+      existing.matchedRanges.sort((a, b) => a.start - b.start);
+      existing.alignedDuration += audioFile.end - audioFile.start;
+    } else {
+      report.audioFiles.push({
+        alignedDuration: audioFile.end - audioFile.start,
+        duration: audioFileDurations[audioFile.filepath] ?? 0,
+        filepath: audioFile.filepath,
+        matchedRanges: [{ start: audioFile.start, end: audioFile.end }]
+      });
+    }
+  }
+}
+export {
+  buildAudioFileContexts,
+  updateAudioFileReports
+};