waha-shared 1.0.1 → 1.0.2

package/dist/functions/languages.d.ts

@@ -0,0 +1,24 @@
+import type { AppTranslations } from '../data/typescript/appTranslations';
+import type { Languages } from '../data/typescript/languages';
+import type { BibleInfo, LanguageInfo, MeetTranslations } from '../types/languages';
+export declare function getBibleInfo(bibleId: string | undefined): BibleInfo | undefined;
+export declare function getIsRtl(script: Languages[number]['script']): boolean;
+export declare function getLanguageInfo(languageId: string): LanguageInfo;
+export declare function getInitialAppInterfaceLanguage(userPhoneLanguages: Array<string | null>): Languages[number]['languageId'];
+export declare function isLanguageAvailable(status: Languages[number]['status'], isDev?: boolean): boolean;
+export declare function numerals(text: string, script: Languages[number]['script']): string;
+/**
+ * These values are not the name of the font necessarily, but the identifier of
+ * the font which can be found by inspecting the font in an app like Font Book.
+ */
+export declare const fonts: Record<Languages[number]['script'], 'EudoxusSans' | 'NotoSans' | 'IBMPlexSansArabic' | null | 'KhmerOSContent' | 'Padauk' | 'AnekTelugu' | 'UKIJ Tuz'>;
+/**
+ * Get the font family for a given script and weight.
+ *
+ * @param script The script to get the font family for.
+ * @param bold Whether to use the bold variant of the font.
+ * @returns The font family for the given script and weight.
+ */
+export declare function getFontFamily(script: Languages[number]['script'], bold?: boolean): string;
+export declare function getAppTranslations(appLanguageId?: string): AppTranslations[string];
+export declare function getMeetTranslations(meetLanguageInfo: LanguageInfo): MeetTranslations;

package/dist/functions/languages.js

@@ -0,0 +1,212 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fonts = void 0;
+exports.getBibleInfo = getBibleInfo;
+exports.getIsRtl = getIsRtl;
+exports.getLanguageInfo = getLanguageInfo;
+exports.getInitialAppInterfaceLanguage = getInitialAppInterfaceLanguage;
+exports.isLanguageAvailable = isLanguageAvailable;
+exports.numerals = numerals;
+exports.getFontFamily = getFontFamily;
+exports.getAppTranslations = getAppTranslations;
+exports.getMeetTranslations = getMeetTranslations;
+const bibleAudios_1 = __importDefault(require("../data/bibleAudios"));
+const bibleStatuses_1 = __importDefault(require("../data/bibleStatuses"));
+const bibleTexts_1 = __importDefault(require("../data/bibleTexts"));
+const foundationsCurriculums_1 = __importDefault(require("../data/foundationsCurriculums"));
+const phoneLanguages_1 = __importDefault(require("../data/languageResources/phoneLanguages"));
+const languages_1 = __importDefault(require("../data/languages"));
+const numeralMaps_1 = __importDefault(require("../data/numeralMaps"));
+const questionsCurriculums_1 = __importDefault(require("../data/questionsCurriculums"));
+const topicsCurriculums_1 = __importDefault(require("../data/topicsCurriculums"));
+const appTranslations_1 = __importDefault(require("../translations/appTranslations"));
+const introductionTranslations_1 = __importDefault(require("../translations/introductionTranslations"));
+const questionTranslations_1 = __importDefault(require("../translations/questionTranslations"));
+const setTranslations_1 = __importDefault(require("../translations/setTranslations"));
+const bibleChapterUtils_1 = require("./bibleChapterUtils");
+function getBibleInfo(bibleId) {
+    const bibleText = bibleTexts_1.default.find((t) => t.bibleTextId === bibleId);
+    const bibleAudio = bibleAudios_1.default.find((t) => t.bibleAudioId === bibleText?.audioId ||
+        t.bibleAudioId === bibleText?.bibleTextId);
+    const language = languages_1.default.find((l) => l.languageId === bibleText?.language);
+    return bibleText && bibleAudio
+        ? {
+            ...bibleText,
+            ...bibleAudio,
+            language,
+            availableTextChapters: (0, bibleChapterUtils_1.getAvailableChapters)(bibleText.bibleTextId, 'text'),
+            availableAudioChapters: (0, bibleChapterUtils_1.getAvailableChapters)(bibleAudio.bibleAudioId, 'audio'),
+            bookNames: bibleStatuses_1.default[bibleText.bibleTextId]?.bookNames || {},
+            fullCopyright: (bibleText.copyright ?? '') + '\n\n' + (bibleAudio.copyright ?? ''),
+        }
+        : undefined;
+}
+function getIsRtl(script) {
+    return script === 'arabic' || script === 'hebrew' || script === 'uyghur';
+}
+function getLanguageInfo(languageId) {
+    const defaultReturn = {
+        ...languages_1.default[0],
+        sets: [...foundationsCurriculums_1.default[0].sets],
+        questionSets: questionsCurriculums_1.default[0].questionSets,
+        bible: {
+            ...bibleTexts_1.default[0],
+            ...bibleAudios_1.default[0],
+            availableTextChapters: [],
+            availableAudioChapters: [],
+            language: languages_1.default[0],
+            fullCopyright: '',
+            bookNames: {},
+        },
+        bibleFallback: undefined,
+        trainingVideoLanguage: '',
+        isRtl: false,
+    };
+    const language = languages_1.default.find((language) => language.languageId === languageId);
+    if (!language) {
+        console.error(`Can't find language with id ${languageId}`);
+        return defaultReturn;
+    }
+    const questionsCurriculum = questionsCurriculums_1.default.find((questionCurriculum) => questionCurriculum.curriculumId === language.curriculum.questions);
+    const foundationsCurriculum = foundationsCurriculums_1.default.find((foundationsCurriculum) => foundationsCurriculum.curriculumId === language.curriculum.foundations);
+    const topicsCurriculum = topicsCurriculums_1.default.find((topicsCurriculum) => topicsCurriculum.curriculumId === language?.curriculum.topics);
+    let sets = [];
+    if (foundationsCurriculum)
+        sets.push(...foundationsCurriculum.sets);
+    if (topicsCurriculum)
+        sets.push(...topicsCurriculum.sets);
+    if (language.dmCourseStatus === 'launched' ||
+        language.dmCourseStatus === 'testing' ||
+        language.videoBridgeLanguage)
+        sets.push('03.009');
+    if (language.gdmcStatus === 'launched' || language.gdmcStatus === 'testing') {
+        sets.push('03.005');
+        sets.push('03.006');
+        sets.push('03.007');
+    }
+    if (language.unsupportedDbsSets)
+        sets = sets.filter((set) => !language.unsupportedDbsSets?.includes(set));
+    const toReturn = {
+        ...language,
+        isRtl: getIsRtl(language.script),
+        sets,
+        questionSets: questionsCurriculum?.questionSets ?? defaultReturn.questionSets,
+        bible: getBibleInfo(language.bible) || defaultReturn.bible,
+        bibleFallback: getBibleInfo(language.bibleFallback),
+        trainingVideoLanguage: language.videoBridgeLanguage ?? language.languageId,
+    };
+    return toReturn;
+}
+function getInitialAppInterfaceLanguage(userPhoneLanguages) {
+    for (const userPhoneLanguage of userPhoneLanguages) {
+        if (!userPhoneLanguage)
+            continue;
+        for (const phoneLanguage of phoneLanguages_1.default) {
+            // Step 1: find the matching phone language.
+            if (phoneLanguage.twoLetterId !== userPhoneLanguage.slice(0, 2))
+                continue;
+            // Step 2: search through alternatives to find the best option.
+            for (const alternative of phoneLanguage.alternatives) {
+                // If the alternative is a valid waha app interface language, we've found a match.
+                if (languages_1.default.some((wahaLanguage) => wahaLanguage.appInterface !== undefined &&
+                    isLanguageAvailable(wahaLanguage.status) &&
+                    wahaLanguage.languageId === alternative.threeLetterId))
+                    return alternative.threeLetterId;
+            }
+        }
+    }
+    return 'eng';
+}
+function isLanguageAvailable(status, isDev) {
+    return process.env.EXPO_PUBLIC_APP_ENV === 'language-testing' || isDev
+        ? status === 'launched' || status === 'testing'
+        : status === 'launched';
+}
+const superscriptToRegular = {
+    '⁰': '0',
+    '¹': '1',
+    '²': '2',
+    '³': '3',
+    '⁴': '4',
+    '⁵': '5',
+    '⁶': '6',
+    '⁷': '7',
+    '⁸': '8',
+    '⁹': '9',
+};
+function numerals(text, script) {
+    if (script in numeralMaps_1.default) {
+        const map = numeralMaps_1.default[script];
+        if (!map)
+            return text;
+        return text
+            .split('')
+            .map((char) => {
+            const regularChar = char in superscriptToRegular ? superscriptToRegular[char] : char;
+            if (regularChar in map)
+                return map[regularChar];
+            return char;
+        })
+            .join('');
+    }
+    return text;
+}
+/**
+ * These values are not the name of the font necessarily, but the identifier of
+ * the font which can be found by inspecting the font in an app like Font Book.
+ */
+exports.fonts = {
+    arabic: 'IBMPlexSansArabic',
+    cyrillic: 'NotoSans',
+    chinese: 'NotoSans',
+    devanagari: 'NotoSans',
+    latin: 'EudoxusSans',
+    greek: 'NotoSans',
+    japanese: 'NotoSans',
+    korean: 'NotoSans',
+    thai: 'NotoSans',
+    hebrew: 'NotoSans',
+    khmer: 'KhmerOSContent',
+    bengali: null,
+    telugu: 'AnekTelugu',
+    burmese: 'Padauk',
+    geez: null,
+    georgian: null,
+    gujarati: null,
+    kannada: null,
+    malayalam: null,
+    tamil: null,
+    gurmukhi: null,
+    uyghur: 'UKIJ Tuz',
+};
+/**
+ * Get the font family for a given script and weight.
+ *
+ * @param script The script to get the font family for.
+ * @param bold Whether to use the bold variant of the font.
+ * @returns The font family for the given script and weight.
+ */
+function getFontFamily(script, bold) {
+    const font = exports.fonts[script];
+    if (!font)
+        return 'EudoxusSans-Regular'; // Fallback font
+    return bold ? `${font}-Bold` : `${font}-Regular`;
+}
+function getAppTranslations(appLanguageId) {
+    return (appTranslations_1.default[appLanguageId ?? 'eng'] ??
+        appTranslations_1.default.eng);
+}
+function getMeetTranslations(meetLanguageInfo) {
+    return {
+        sets: setTranslations_1.default[meetLanguageInfo.titles ?? meetLanguageInfo.languageId] ??
+            setTranslations_1.default.eng,
+        questions: questionTranslations_1.default[meetLanguageInfo.languageId] ??
+            questionTranslations_1.default.eng,
+        introductions: introductionTranslations_1.default[meetLanguageInfo.introBridge ??
+            meetLanguageInfo.titles ??
+            meetLanguageInfo.languageId] ?? introductionTranslations_1.default.eng,
+    };
+}

package/dist/functions/scripturePassages.d.ts

@@ -0,0 +1,47 @@
+import { type BibleChapters } from '../data/typescript/bibleChapters';
+import type { LanguageInfo } from '../types/languages';
+type BibleChapter = BibleChapters[number];
+export interface ScripturePassage {
+    passageId: string;
+    bibleId: string;
+    header: string;
+    verses: BibleChapter['verses'][number][];
+}
+/**
+ * Condenses a list of USFM passage IDs into a readable string format. Groups
+ * consecutive passages from the same book together.
+ *
+ * @example
+ *   ["GEN.1.1-GEN.1.25"] -> "Genesis 1: 1-25"
+ *   ["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"
+ */
+export declare function getPassagesString(passageIds: string[] | undefined, language: LanguageInfo): string;
+export interface GetChapterParams {
+    chapterId: string;
+    bibleId: string;
+}
+export type GetChapter = (params: GetChapterParams) => Promise<BibleChapter | undefined>;
+interface GetLessonScriptureParams {
+    bibleId: string;
+    bibleFallbackId: string | undefined;
+    passageIds: string[];
+    getChapter: (params: GetChapterParams) => Promise<BibleChapter | undefined>;
+    languageInfo: LanguageInfo;
+}
+/**
+ * Gets multiple scripture passages efficiently (Future optimization: could
+ * batch the chapter fetches)
+ */
+export declare function getLessonScripture(params: GetLessonScriptureParams): Promise<Array<ScripturePassage | undefined>>;
+export declare function parseBibleSnapshot(snapshot: any, bible: string): BibleChapters;
+/**
+ * Converts a verse number to a superscript string. This is useful for
+ * displaying verse numbers in a more visually appealing way. For example, "1"
+ * becomes "¹", "2" becomes "²", etc
+ *
+ * @param num The verse number to convert to superscript.
+ * @returns The superscript string representation of the verse number.
+ */
+export declare function verseToSuperscript(num: string | undefined): string;
+export {};

package/dist/functions/scripturePassages.js

@@ -0,0 +1,261 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPassagesString = getPassagesString;
+exports.getLessonScripture = getLessonScripture;
+exports.parseBibleSnapshot = parseBibleSnapshot;
+exports.verseToSuperscript = verseToSuperscript;
+const bibleStatuses_1 = __importDefault(require("../data/bibleStatuses"));
+const bibleChapters_1 = require("../data/typescript/bibleChapters");
+const languages_1 = require("../functions/languages");
+/**
+ * Parses a verse range string like "GEN.1.1-GEN.1.25" or "JHN.3.16" 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 [startBook, startChapter, startVerse] = parts[0].split('.');
+    const [endBook, endChapter, endVerse] = parts[1].split('.');
+    return {
+        startBook,
+        startChapter,
+        startVerse,
+        endBook,
+        endChapter,
+        endVerse,
+    };
+}
+/** Extracts verses from a chapter based on verse numbers */
+function extractVersesFromChapter(chapter, startVerse, endVerse) {
+    const verses = chapter.verses.filter((verse) => {
+        const verseIdPart = verse.verseId.split('.')[2];
+        // Handle verse ranges (e.g., "7-9")
+        if (verseIdPart.includes('-')) {
+            const [rangeStart, rangeEnd] = verseIdPart
+                .split('-')
+                .map((v) => parseInt(v));
+            // Check if the requested range overlaps with this verse range
+            return rangeEnd >= startVerse && rangeStart <= endVerse;
+        }
+        // Handle single verse numbers
+        const verseNum = parseInt(verseIdPart);
+        return verseNum >= startVerse && verseNum <= endVerse;
+    });
+    return verses;
+}
+/**
+ * Condenses a list of USFM passage IDs into a readable string format. Groups
+ * consecutive passages from the same book together.
+ *
+ * @example
+ *   ["GEN.1.1-GEN.1.25"] -> "Genesis 1: 1-25"
+ *   ["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 '';
+    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.default.BSB.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}`);
+            }
+        }
+        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}`);
+            }
+        }
+    }
+    return (0, languages_1.numerals)(parts.join(', '), language.script);
+}
+/**
+ * Gets a scripture passage by extracting verses from chapters This is the core
+ * parsing logic, independent of the data source
+ */
+async function getScripturePassage({ bibleId, bibleFallbackId, passageId, getChapter, languageInfo, }) {
+    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;
+            }
+            return {
+                passageId,
+                bibleId,
+                header: getPassagesString([passageId], languageInfo),
+                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,
+        };
+    }
+    catch (error) {
+        console.error(`Error getting scripture passage ${passageId} in ${bibleId}`, error);
+        return;
+    }
+}
+/**
+ * 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.bibleChapters.element.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;
+    }
+}
+/**
+ * Converts a verse number to a superscript string. This is useful for
+ * displaying verse numbers in a more visually appealing way. For example, "1"
+ * becomes "¹", "2" becomes "²", etc
+ *
+ * @param num The verse number to convert to superscript.
+ * @returns The superscript string representation of the verse number.
+ */
+function verseToSuperscript(num) {
+    const superscriptObj = {
+        '0': '⁰',
+        '1': '¹',
+        '2': '²',
+        '3': '³',
+        '4': '⁴',
+        '5': '⁵',
+        '6': '⁶',
+        '7': '⁷',
+        '8': '⁸',
+        '9': '⁹',
+        '-': '⁻',
+    };
+    if (!num)
+        return '';
+    return num
+        .split('')
+        .map((digit) => {
+        if (digit in superscriptObj)
+            return superscriptObj[digit];
+        else
+            return digit;
+    })
+        .join('');
+}

package/dist/functions/sets.d.ts

@@ -0,0 +1,30 @@
+import type { AppTranslations } from '../data/typescript/appTranslations';
+import type { LanguageInfo, MeetTranslations } from '../types/languages';
+import { Lesson, LessonInfo, SetInfo, type Section } from '../types/sets';
+export declare const firebaseUrl = "https://firebasestorage.googleapis.com/v0/b/waha-app-db.appspot.com/o/";
+export declare function getSetInfo({ setId, meetLanguageId, sets, t, }: {
+    setId: string;
+    meetLanguageId: string;
+    t: MeetTranslations & AppTranslations[string];
+    sets: string[];
+}): SetInfo | undefined;
+export declare function getLessonInfo({ lessonId, meetLanguageInfo, setInfo, t, }: {
+    lessonId: Lesson['lessonId'] | undefined;
+    meetLanguageInfo: LanguageInfo;
+    setInfo?: SetInfo;
+    t: MeetTranslations & AppTranslations[string];
+}): LessonInfo | undefined;
+export declare function convertSToString(time: number): string;
+/** Determines whether a lesson should be visible in Waha. */
+export declare function shouldShowLesson(lessonInfo: LessonInfo | undefined, languageInfo: LanguageInfo): boolean;
+/**
+ * Calculate start times for each section based on question durations and total
+ * audio duration. Must be called after audio is loaded to get accurate total
+ * duration.
+ *
+ * @param sections - The lesson sections to calculate timings for
+ * @param totalDuration - Total duration of the lesson audio in seconds
+ * @param languageId - The language ID to look up question durations
+ * @returns Map of section ID to start time in seconds
+ */
+export declare function calculateSectionTimings(sections: Section[], totalDuration: number, languageId: string): Map<string, number>;