waha-shared 1.0.308 → 1.0.310

package/dist/functions/scripturePassages.js

@@ -1,61 +1,34 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseVerseRange = parseVerseRange;
+exports.parseVerseRange = void 0;
 exports.getChapterUrl = getChapterUrl;
 exports.getPassagesString = getPassagesString;
+exports.withChapterPlaceholders = withChapterPlaceholders;
 exports.getScripturePassage = getScripturePassage;
 exports.getLessonScripture = getLessonScripture;
-exports.parseBibleSnapshot = parseBibleSnapshot;
 exports.verseToSuperscript = verseToSuperscript;
-exports.getLessonPauses = getLessonPauses;
+exports.getFtbDuration = getFtbDuration;
+exports.enrichSections = enrichSections;
 exports.normalizeVerseTimings = normalizeVerseTimings;
 const bibleStatuses_1 = require("../data/bibleStatuses");
-const lessonPauses_1 = require("../data/lessonPauses");
+const firebase_1 = require("../data/firebase");
 const mediaDurations_1 = require("../data/mediaDurations");
-const specialIds_1 = require("../data/specialIds");
 const languages_1 = require("../functions/languages");
-const bibleChapters_1 = require("../types/bibleChapters");
-const sets_1 = require("./sets");
-/**
- * Parses a verse range string like "GEN.1.1-GEN.1.25" or "JHN.3.16" or "REV.22"
- * Returns the start and end verse IDs
- */
-function parseVerseRange(passageId) {
-    // Handle single verse: "GEN.1.1" -> "GEN.1.1-GEN.1.1"
-    const parts = passageId.includes('-')
-        ? passageId.split('-')
-        : [passageId, passageId];
-    const startParts = parts[0].split('.');
-    const endParts = parts[1].split('.');
-    const startBook = startParts[0];
-    const startChapter = startParts[1];
-    const startVerse = startParts.length > 2 ? startParts[2] : '1';
-    const endBook = endParts[0];
-    const endChapter = endParts[1];
-    const endVerse = endParts.length > 2 ? endParts[2] : '1';
-    return {
-        startBook,
-        startChapter,
-        startVerse,
-        endBook,
-        endChapter,
-        endVerse,
-        startChapterId: `${startBook}.${startChapter}`,
-        endChapterId: `${endBook}.${endChapter}`,
-    };
-}
+const sets_1 = require("../types/sets");
+const bibleBooks_1 = require("./bibleBooks");
+const bibles_1 = require("./bibles");
+var bibleBooks_2 = require("./bibleBooks");
+Object.defineProperty(exports, "parseVerseRange", { enumerable: true, get: function () { return bibleBooks_2.parseVerseRange; } });
 function getChapterUrl(params) {
-    const startBook = 'startBook' in params
-        ? params.startBook
-        : parseVerseRange(params.passageId).startBook;
-    const startChapter = 'startChapter' in params
-        ? params.startChapter
-        : parseVerseRange(params.passageId).startChapter;
-    return (sets_1.firebaseUrl +
+    const book = 'book' in params ? params.book : (0, bibleBooks_1.parseVerseRange)(params.passageId).book;
+    const chapter = 'chapter' in params
+        ? params.chapter
+        : (0, bibleBooks_1.parseVerseRange)(params.passageId).chapter;
+    return (firebase_1.firebaseUrl +
         encodeURIComponent('audio_bibles' +
             `/${params.bibleAudioId}` +
-            `/${startBook}` +
-            `/${startBook}_${startChapter.padStart(3, '0')}.mp3`) +
+            `/${book}` +
+            `/${book}_${chapter.padStart(3, '0')}.mp3`) +
         `?alt=media`);
 }
 /** Extracts verses from a chapter based on verse numbers */
@@ -85,170 +58,119 @@ function extractVersesFromChapter(chapter, startVerse, endVerse) {
  *   ["GEN.1.1-GEN.1.25", "GEN.2.4-GEN.2.7", "EXO.3.3-EXO.3.25"] -> "Genesis 1: 1-25, 2: 4-7, Exodus 3: 3-25"
  *   ["JHN.1.1"] -> "John 1: 1"
  */
-function getPassagesString(passageIds, language) {
-    if (!passageIds || passageIds.length === 0)
-        return '';
+function getPassagesString(passages) {
     const parts = [];
     let currentBook = null;
-    for (const passageId of passageIds) {
-        const { startBook, startChapter, startVerse, endChapter, endVerse } = parseVerseRange(passageId);
-        let bookName = 
-        // American sign language should use English book names.
-        language.languageId === 'ase'
-            ? bibleStatuses_1.bibleStatuses.NLT.bookNames[startBook]
-            : language.bible.bookNames[startBook];
-        if (!bookName) {
-            bookName = language.bibleFallback?.bookNames[startBook];
-            if (!bookName)
-                continue;
-        }
-        // New book - include book name
-        if (currentBook !== startBook) {
-            currentBook = startBook;
-            // Same chapter
-            if (startChapter === endChapter) {
-                if (startVerse === endVerse) {
-                    parts.push(`${bookName} ${startChapter}: ${startVerse}`);
-                }
-                else {
-                    parts.push(`${bookName} ${startChapter}: ${startVerse}-${endVerse}`);
-                }
-            }
-            else {
-                // Different chapters
-                parts.push(`${bookName} ${startChapter}: ${startVerse}-${endChapter}: ${endVerse}`);
-            }
+    for (const passage of passages) {
+        const bibleInfo = (0, bibles_1.getBibleInfo)(passage.bibleId);
+        if (!bibleInfo)
+            continue;
+        const { book, chapter, startVerse, endVerse } = (0, bibleBooks_1.parseVerseRange)(passage.passageId);
+        const bookName = bibleInfo.bookNames[book];
+        if (!bookName)
+            continue;
+        const verseRange = startVerse === endVerse ? startVerse : `${startVerse}-${endVerse}`;
+        if (currentBook !== book) {
+            currentBook = book;
+            parts.push((0, languages_1.numerals)(`${bookName} ${chapter}: ${verseRange}`, bibleInfo.language.script));
         }
         else {
-            // Same book - omit book name
-            if (startChapter === endChapter) {
-                if (startVerse === endVerse) {
-                    parts.push(`${startChapter}: ${startVerse}`);
-                }
-                else {
-                    parts.push(`${startChapter}: ${startVerse}-${endVerse}`);
-                }
-            }
-            else {
-                // Different chapters
-                parts.push(`${startChapter}: ${startVerse}-${endChapter}: ${endVerse}`);
-            }
+            parts.push((0, languages_1.numerals)(`${chapter}: ${verseRange}`, bibleInfo.language.script));
         }
     }
-    return (0, languages_1.numerals)(parts.join(', '), language.script.name);
+    return parts.join(', ');
+}
+/**
+ * Wraps a raw chapter fetcher with placeholder logic shared across all
+ * backends:
+ *
+ * - If the chapter is not in `availableTextChapters` nor
+ *   `availableTimingsChapters`, synthesize a one-verse placeholder without
+ *   calling the underlying fetcher.
+ * - If a fetched chapter is timings-only (verses exist but none have text), patch
+ *   verse 1's text with `noTextAvailableString` so downstream consumers can
+ *   render something.
+ */
+function withChapterPlaceholders(fetchRaw) {
+    return async ({ bibleId, chapterId, noTextAvailableString }) => {
+        const bibleInfo = (0, bibles_1.getBibleInfo)(bibleId);
+        if (!bibleInfo)
+            return undefined;
+        if (!bibleInfo.availableTextChapters.includes(chapterId) &&
+            !bibleInfo.availableTimingsChapters.includes(chapterId)) {
+            return {
+                bookName: bibleInfo.bookNames[chapterId.split('.')[0]],
+                chapterId,
+                reference: chapterId,
+                titles: null,
+                translationId: bibleId,
+                verses: [{ text: noTextAvailableString, verseId: `${chapterId}.1` }],
+            };
+        }
+        const chapter = await fetchRaw({ bibleId, chapterId });
+        if (!chapter)
+            return undefined;
+        if (chapter.verses.length > 0 && !chapter.verses.some((v) => v.text)) {
+            chapter.verses[0].text = noTextAvailableString;
+        }
+        return chapter;
+    };
 }
 /** Gets a scripture passage by extracting verses from chapters documents. */
-async function getScripturePassage({ bibleId, bibleFallbackId, passageId, getChapter, languageInfo, }) {
+async function getScripturePassage({ bibleId, passageId, getChapter, noTextAvailableString, }) {
+    const bibleInfo = (0, bibles_1.getBibleInfo)(bibleId);
+    const { startVerse, endVerse, chapterId } = (0, bibleBooks_1.parseVerseRange)(passageId);
+    if (!bibleInfo)
+        return;
     try {
-        const { startBook, startChapter, startVerse, endBook, endChapter, endVerse, } = parseVerseRange(passageId);
         const startVerseNum = parseInt(startVerse);
         const endVerseNum = parseInt(endVerse);
-        // Same chapter - simple case
-        if (startBook === endBook && startChapter === endChapter) {
-            const chapterId = `${startBook}.${startChapter}`;
-            let chapter = await getChapter({ chapterId, bibleId });
-            if (!chapter && bibleFallbackId)
-                chapter = await getChapter({ chapterId, bibleId: bibleFallbackId });
-            if (!chapter) {
-                console.warn(`Chapter not found: ${bibleId}.${chapterId} for passage ${passageId}`);
-                return;
-            }
-            const verses = extractVersesFromChapter(chapter, startVerseNum, endVerseNum);
-            if (verses.length === 0) {
-                console.warn(`No verses found for passage ${passageId}`);
-                return;
-            }
+        const chapter = await getChapter({
+            chapterId,
+            bibleId,
+            noTextAvailableString,
+        });
+        if (!chapter || chapter.verses.length === 0)
+            return;
+        /**
+         * If we only have one verse for a chapter, it is the placeholder verse and
+         * we should return them as is instead of trying to extract a passage.
+         */
+        if (chapter.verses.length === 1) {
             return {
                 passageId,
-                bibleId,
-                header: getPassagesString([passageId], languageInfo),
-                verses,
+                bibleId: chapter.translationId,
+                verses: chapter.verses,
             };
         }
-        // Multi-chapter passage (rare but possible)
-        // Example: GEN.1.26-GEN.2.3
-        const chapters = [];
-        // Get all chapters in the range
-        const startChapterNum = parseInt(startChapter);
-        const endChapterNum = parseInt(endChapter);
-        for (let i = startChapterNum; i <= endChapterNum; i++) {
-            const chapterId = `${startBook}.${i}`;
-            let chapter = await getChapter({ chapterId, bibleId });
-            if (!chapter && bibleFallbackId)
-                chapter = await getChapter({ chapterId, bibleId: bibleFallbackId });
-            if (chapter) {
-                chapters.push(chapter);
-            }
-            else {
-                console.warn(`Missing chapter in range: ${bibleId}.${chapterId}`);
-            }
-        }
-        if (chapters.length === 0) {
-            return;
-        }
-        // Extract verses from each chapter
-        const allVerses = [];
-        chapters.forEach((chapter, index) => {
-            if (index === 0) {
-                // First chapter - from startVerse to end
-                const lastVerse = Math.max(...chapter.verses.map((v) => parseInt(v.verseId.split('.')[2])));
-                allVerses.push(...extractVersesFromChapter(chapter, startVerseNum, lastVerse));
-            }
-            else if (index === chapters.length - 1) {
-                // Last chapter - from beginning to endVerse
-                allVerses.push(...extractVersesFromChapter(chapter, 1, endVerseNum));
-            }
-            else {
-                // Middle chapters - all verses
-                allVerses.push(...chapter.verses);
-            }
-        });
-        return {
-            passageId,
-            bibleId,
-            header: getPassagesString([passageId], languageInfo),
-            verses: allVerses,
-        };
+        const verses = extractVersesFromChapter(chapter, startVerseNum, endVerseNum);
+        /**
+         * For textless chapters, verse 1 is always the placeholder verse. After
+         * extraction, we may have lost verse 1, so we patch back in the placeholder
+         * text.
+         */
+        if (!verses.some((v) => v.text) && verses.length > 0)
+            verses[0].text = noTextAvailableString;
+        return { passageId, bibleId: chapter.translationId, verses };
     }
     catch (error) {
         console.error(`Error getting scripture passage ${passageId} in ${bibleId}`, error);
-        return;
+        throw error;
     }
 }
-/**
- * Gets multiple scripture passages efficiently (Future optimization: could
- * batch the chapter fetches)
- */
-async function getLessonScripture(params) {
-    const passages = await Promise.all(params.passageIds.map((passageId) => getScripturePassage({ ...params, passageId })));
-    return passages;
-}
-function parseBibleSnapshot(snapshot, bible) {
-    const validChapters = [];
-    if (!snapshot) {
-        console.warn('No snapshot for', bible);
-        return [];
-    }
-    else if (snapshot.empty) {
-        console.warn('Empty snapshot for', bible);
-        return [];
-    }
-    for (const doc of snapshot.docs) {
-        const chapterParse = bibleChapters_1.BibleChapter.safeParse(doc.data());
-        if (!chapterParse.success) {
-            console.warn('Skipping invalid bible chapter document', doc.id, chapterParse.error.issues.map((i) => `${i.path.join('.')}: ${i.message}`));
-        }
-        else {
-            validChapters.push(chapterParse.data);
-        }
-    }
-    if (validChapters.length === 0) {
-        console.warn('No valid chapters for', bible);
-        return [];
-    }
-    else {
-        return validChapters;
-    }
+/** Gets all scripture passages for a lesson. */
+async function getLessonScripture({ getChapter, lessonInfo, noTextAvailableString, }) {
+    return Promise.all(lessonInfo.sections
+        .filter((s) => s.chapter === sets_1.Chapter.STORY)
+        .map((s) => {
+        const [bibleId, passageId] = s.id.split(';');
+        return getScripturePassage({
+            bibleId,
+            passageId,
+            getChapter,
+            noTextAvailableString,
+        });
+    }));
 }
 /**
  * Converts a verse number to a superscript string. This is useful for
@@ -285,131 +207,123 @@ function verseToSuperscript(num) {
         .join('');
 }
 /**
- * Splits a passage's verses into per-chapter chunks. Single-chapter passages
- * produce one chunk. Multi-chapter passages (rare, e.g. GEN.1.26-GEN.2.3)
- * produce one chunk per chapter, with isPartOfPrevious=true on the 2nd+ chunks.
- * This mirrors leviathan's passage_ids_by_chapter splitting logic.
+ * Returns the FTB audio duration + afterFtb pause for a section, or 0 if the
+ * section has no FTB.
  */
-function splitPassageIntoChunks(verses) {
-    if (verses.length === 0)
-        return [];
-    const chunks = [];
-    let currentChapterId = null;
-    for (const verse of verses) {
-        const parts = verse.verseId.split('.');
-        const chapterId = `${parts[0]}.${parts[1]}`;
-        if (chapterId !== currentChapterId) {
-            chunks.push({
-                verses: [verse],
-                bookId: parts[0],
-                isPartOfPrevious: currentChapterId !== null,
-            });
-            currentChapterId = chapterId;
-        }
-        else {
-            chunks[chunks.length - 1].verses.push(verse);
-        }
+function getFtbDuration(section, lessonInfo) {
+    if (!section.ftbFileName)
+        return 0;
+    const ftbDuration = mediaDurations_1.mediaDurations[lessonInfo.contentLanguages.ftbs]?.[section.ftbFileName];
+    if (ftbDuration == null) {
+        console.warn(`FTB duration not found for ${section.ftbFileName}`);
     }
-    return chunks;
+    return (ftbDuration ?? 0) + lessonInfo.lessonPauses.afterFtb;
 }
 /**
- * Some lessons were built using a system that used slightly different pause
- * values.
- */
-const alternativeLessonPauses = {
-    beforeStory: 1,
-    afterStory: 1,
-    betweenPassages: 0.5,
-    beforeFtb: 1,
-    afterFtb: 0.5,
-};
-/**
- * List of languages whose lessons were built using slightly different pause
- * values.
+ * Fills in `length` (for verse-timed story sections) and `startTime` (for all
+ * sections) by accumulating forward through the lesson. After this, every
+ * section has both fields set.
  */
-const usesAlternativeLessonPauses = ['tel', 'som', 'kmr', 'swz', 'vie'];
-/** Returns the correct lesson pauses for a given language. */
-function getLessonPauses(languageId) {
-    return usesAlternativeLessonPauses.includes(languageId)
-        ? alternativeLessonPauses
-        : lessonPauses_1.lessonPauses;
+function enrichSections(lessonInfo, scripture) {
+    const storySections = lessonInfo.sections.filter((s) => s.chapter === sets_1.Chapter.STORY);
+    /**
+     * Forward pass: compute lengths and start times for all non-application
+     * sections. We track whether any prior story had an unknown length — once
+     * that happens, every later story's startTime is unreliable (it accumulates
+     * from a bogus length), so we flag it with `ignoreTimings`.
+     */
+    let currentTime = 0;
+    let priorStoryLengthUnknown = false;
+    const enriched = lessonInfo.sections.map((section) => {
+        if (!section.chapter)
+            return { ...section, startTime: 0, length: 0 };
+        currentTime += section.pauseBefore ?? 0;
+        let length;
+        const isStory = section.chapter === sets_1.Chapter.STORY;
+        const ignoreTimings = isStory && priorStoryLengthUnknown ? true : undefined;
+        const startTime = currentTime;
+        if (!isStory) {
+            length = mediaDurations_1.mediaDurations[section.languageId]?.[section.fileName];
+        }
+        else {
+            currentTime += getFtbDuration(section, lessonInfo);
+            const [bibleId, passageId] = section.id.split(';');
+            length = bibleStatuses_1.bibleStatuses[bibleId]?.customPassages?.[passageId];
+            if (!length) {
+                const passage = scripture[storySections.indexOf(section)];
+                if (passage) {
+                    const firstTimed = passage.verses.find((v) => v.timings);
+                    const lastTimed = [...passage.verses].reverse().find((v) => v.timings);
+                    if (firstTimed?.timings && lastTimed?.timings) {
+                        length = lastTimed.timings[1] - firstTimed.timings[0];
+                    }
+                }
+            }
+            if (length == null)
+                priorStoryLengthUnknown = true;
+        }
+        if (length == null) {
+            console.warn(`Missing duration for section ${section.id} (${section.chapter}, ${section.fileName})`);
+        }
+        currentTime += length ?? 0;
+        return { ...section, length: length ?? 0, startTime, ignoreTimings };
+    });
+    // Backward pass: compute application section start times from the end of the
+    // lesson file, so they are always correct even if story durations are
+    // slightly off.
+    const fullFileName = lessonInfo.type === 'dbs'
+        ? lessonInfo.full.localFileName
+        : lessonInfo.video.localFileName;
+    const totalDuration = mediaDurations_1.mediaDurations[lessonInfo.languageId]?.[fullFileName] ?? 0;
+    if (totalDuration > 0) {
+        let timeFromEnd = totalDuration;
+        const applicationSections = enriched.filter((s) => s.chapter === sets_1.Chapter.APPLICATION);
+        for (const section of [...applicationSections].reverse()) {
+            timeFromEnd -= section.length;
+            section.startTime = timeFromEnd;
+            timeFromEnd -= section.pauseBefore ?? 0;
+        }
+    }
+    return enriched;
 }
 /**
- * Converts verse timings within each scripture passage from chapter-relative to
- * full-lesson relative. This includes accounting for question durations,
- * pauses, and from-the-book durations.
- *
- * Multi-chapter passages are split into per-chapter chunks internally, since
- * the audio is clipped from individual chapter files.
+ * Converts verse timings from chapter-relative to lesson-relative using each
+ * section's `startTime` (set by {@link enrichSections}).
  */
-function normalizeVerseTimings({ lessonInfo, scripture, }) {
-    const languageInfo = (0, languages_1.getLanguageInfo)(lessonInfo.meetLanguageId);
-    const pauses = getLessonPauses(lessonInfo.meetLanguageId);
-    let cumulativeTime = lessonInfo.fellowshipDuration + pauses.beforeStory;
-    if (specialIds_1.specialIds.introductionLessonIds.includes(lessonInfo.lessonId) &&
-        lessonInfo.type === 'dbs' &&
-        lessonInfo.introLength)
-        cumulativeTime += lessonInfo.introLength;
-    let lastBook = null;
-    /** Tracks the overall passage index (not chunk index) for FTB/pause logic. */
-    let globalChunkIndex = 0;
-    return scripture?.map((passage) => {
+function normalizeVerseTimings({ enrichedSections, scripture, lessonInfo, }) {
+    const storySections = enrichedSections.filter((s) => s.chapter === sets_1.Chapter.STORY);
+    return scripture.map((passage, passageIndex) => {
         if (!passage)
             return undefined;
-        const chunks = splitPassageIntoChunks(passage.verses);
-        if (chunks.length === 0)
-            return passage;
-        const adjustedVerses = [];
-        for (const chunk of chunks) {
-            const firstTimedVerse = chunk.verses.find((v) => v.timings);
-            if (!firstTimedVerse?.timings) {
-                // No timing data — pass through unadjusted
-                adjustedVerses.push(...chunk.verses);
-                if (!chunk.isPartOfPrevious)
-                    globalChunkIndex++;
-                continue;
-            }
-            const chunkAudioStart = firstTimedVerse.timings[0];
-            // Add FTB + pauses. Chunks that are continuations of a multi-chapter
-            // passage (isPartOfPrevious) get no pause — they are concatenated directly.
-            if (!chunk.isPartOfPrevious) {
-                if (lastBook !== chunk.bookId) {
-                    if (globalChunkIndex !== 0) {
-                        cumulativeTime += pauses.beforeFtb;
-                    }
-                    const ftbLanguage = languageInfo.titles ?? languageInfo.languageId;
-                    const ftbKey = `${ftbLanguage}.${chunk.bookId}.mp3`;
-                    const ftbDuration = mediaDurations_1.mediaDurations[ftbLanguage]?.[ftbKey];
-                    if (ftbDuration != null)
-                        cumulativeTime += ftbDuration;
-                    else {
-                        console.error(`FTB duration not found for ${ftbKey}`);
-                        return passage;
-                    }
-                    cumulativeTime += pauses.afterFtb;
-                    lastBook = chunk.bookId;
-                }
-                else if (globalChunkIndex !== 0) {
-                    cumulativeTime += pauses.betweenPassages;
-                }
-                globalChunkIndex++;
-            }
-            const offset = cumulativeTime - chunkAudioStart;
-            for (const verse of chunk.verses) {
+        const section = storySections[passageIndex];
+        const ignoreTimingsReturn = {
+            ...passage,
+            verses: passage.verses.map((verse) => ({ ...verse, timings: null })),
+        };
+        /**
+         * Section's startTime is wrong (e.g. an earlier story's scripture hasn't
+         * loaded), so applying it as an offset would produce bogus lesson-relative
+         * timings. Strip verse timings instead, which disables karaoke until the
+         * section becomes trusted.
+         */
+        if (section.ignoreTimings)
+            return ignoreTimingsReturn;
+        const firstTimedVerse = passage?.verses.find((v) => v.timings);
+        if (!firstTimedVerse?.timings)
+            return ignoreTimingsReturn;
+        const offset = section.startTime +
+            getFtbDuration(section, lessonInfo) -
+            firstTimedVerse.timings[0];
+        return {
+            ...passage,
+            verses: passage.verses.map((verse) => {
                 if (!verse.timings)
-                    adjustedVerses.push(verse);
-                else
-                    adjustedVerses.push({
-                        ...verse,
-                        timings: [verse.timings[0] + offset, verse.timings[1] + offset],
-                    });
-            }
-            // Advance cumulative time by this chunk's audio duration
-            const lastTimedVerse = [...chunk.verses].reverse().find((v) => v.timings);
-            if (lastTimedVerse?.timings) {
-                cumulativeTime += lastTimedVerse.timings[1] - chunkAudioStart;
-            }
-        }
-        return { ...passage, verses: adjustedVerses };
+                    return verse;
+                return {
+                    ...verse,
+                    timings: [verse.timings[0] + offset, verse.timings[1] + offset],
+                };
+            }),
+        };
     });
 }