mg-bibles/dist/index.js

A package for accessing Bible verses in Malagasy (MG), Diem, King James (KJV), and Louis Segond (APEE) versions

"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    var desc = Object.getOwnPropertyDescriptor(m, k);
    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
      desc = { enumerable: true, get: function() { return m[k]; } };
    }
    Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || (function () {
    var ownKeys = function(o) {
        ownKeys = Object.getOwnPropertyNames || function (o) {
            var ar = [];
            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
            return ar;
        };
        return ownKeys(o);
    };
    return function (mod) {
        if (mod && mod.__esModule) return mod;
        var result = {};
        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
        __setModuleDefault(result, mod);
        return result;
    };
})();
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.getVerses = getVerses;
exports.listBooks = listBooks;
exports.chapterCount = chapterCount;
exports.versesCount = versesCount;
exports.countVerses = countVerses;
const diem = __importStar(require("./diem"));
const mg = __importStar(require("./mg"));
const en_kjv_json_1 = __importDefault(require("./en_kjv.json"));
const fr_apee_json_1 = __importDefault(require("./fr_apee.json"));
const BIBLE_VERSIONS = ['mg', 'diem', 'kjv', 'apee'];
function getBibleData(version) {
    switch (version) {
        case 'diem':
            return diem;
        case 'mg':
            return mg;
        case 'kjv':
            return convertKJVAPEEFormat(en_kjv_json_1.default);
        case 'apee':
            return convertKJVAPEEFormat(fr_apee_json_1.default);
        default:
            throw new Error(`Unsupported Bible version: ${version}`);
    }
}
function convertKJVAPEEFormat(data) {
    return data.reduce((acc, book) => {
        const bookData = {
            name: book.name,
            order: 0,
            chapter_number: book.chapters.length,
        };
        book.chapters.forEach((chapter, chapterIndex) => {
            const chapterData = {};
            chapter.forEach((verse, verseIndex) => {
                chapterData[(verseIndex + 1).toString()] = verse;
            });
            bookData[(chapterIndex + 1).toString()] = chapterData;
        });
        acc[book.abbrev.toLowerCase()] = bookData;
        acc[book.name.toLowerCase()] = bookData;
        return acc;
    }, {});
}
function mapBookName(bookName, version) {
    // Only apply special mapping for MG and DIEM versions
    if (version === 'mg' || version === 'diem') {
        // Handle numbered books
        const numberedMatch = bookName.match(/^(\d+)\s+(\w+)$/);
        if (numberedMatch) {
            const [_, number, name] = numberedMatch;
            return `${name}${number}`;
        }
    }
    return bookName;
}
function parseVerseReference(reference, version) {
    const parts = reference.toLowerCase().split(' ');
    if (/^\d/.test(parts[0]) && parts.length >= 2) {
        const number = parts[0];
        const bookName = parts[1];
        const versePart = parts[2];
        const combinedBookName = mapBookName(`${number} ${bookName}`, version);
        if (!versePart) {
            return {
                book: combinedBookName,
                chapter: 1,
            };
        }
        const [chapter, verseRange] = versePart.split(':');
        if (!chapter) {
            throw new Error('Chapter not found in reference');
        }
        if (!verseRange) {
            return {
                book: combinedBookName,
                chapter: parseInt(chapter),
            };
        }
        let verses = [];
        if (verseRange.includes('-')) {
            const [start, end] = verseRange.split('-').map(Number);
            if (!end || !start || end < start) {
                throw new Error('Invalid verse range');
            }
            verses = Array.from({ length: end - start + 1 }, (_, i) => start + i);
        }
        else if (verseRange.includes(',')) {
            verses = verseRange.split(',').map(Number);
        }
        else {
            verses = [parseInt(verseRange)];
        }
        return {
            book: combinedBookName,
            chapter: parseInt(chapter),
            verses,
        };
    }
    const bookPart = mapBookName(parts[0], version);
    const versePart = parts[1];
    if (!bookPart) {
        throw new Error('Book not found in reference');
    }
    if (!versePart) {
        return {
            book: bookPart,
            chapter: 1,
        };
    }
    const [chapter, verseRange] = versePart.split(':');
    if (!chapter) {
        throw new Error('Chapter not found in reference');
    }
    if (!verseRange) {
        return {
            book: bookPart,
            chapter: parseInt(chapter),
        };
    }
    let verses = [];
    if (verseRange.includes('-')) {
        const [start, end] = verseRange.split('-').map(Number);
        if (!end || !start || end < start) {
            throw new Error('Invalid verse range');
        }
        verses = Array.from({ length: end - start + 1 }, (_, i) => start + i);
    }
    else if (verseRange.includes(',')) {
        verses = verseRange.split(',').map(Number);
    }
    else {
        verses = [parseInt(verseRange)];
    }
    return {
        book: bookPart,
        chapter: parseInt(chapter),
        verses,
    };
}
function getVerses(version, reference) {
    if (!BIBLE_VERSIONS.includes(version)) {
        throw new Error(`Invalid Bible version: ${version}. Available versions: ${BIBLE_VERSIONS.join(', ')}`);
    }
    const parsed = parseVerseReference(reference, version);
    const bookData = getBibleData(version)[parsed.book];
    if (!bookData) {
        throw new Error(`Book not found: ${parsed.book}`);
    }
    const chapter = bookData[parsed.chapter.toString()];
    if (!chapter) {
        throw new Error(`Chapter not found: ${parsed.chapter}`);
    }
    if (!parsed.verses) {
        return getChapter(version, reference);
    }
    const verses = parsed.verses.reduce((acc, v) => {
        const verse = chapter[v.toString()];
        if (!verse) {
            throw new Error(`Verse not found: ${v}`);
        }
        acc[v.toString()] = `${v}. ${verse}`;
        return acc;
    }, {});
    return {
        reference,
        verses,
    };
}
function getChapter(version, reference) {
    const parsed = parseVerseReference(reference, version);
    const bookData = getBibleData(version)[parsed.book];
    if (!bookData) {
        throw new Error(`Book not found: ${parsed.book}`);
    }
    const chapter = bookData[parsed.chapter.toString()];
    if (!chapter) {
        throw new Error(`Chapter not found: ${parsed.chapter}`);
    }
    const versesWithNumbers = Object.entries(chapter).reduce((acc, [num, text]) => {
        acc[num] = `${num}. ${text}`;
        return acc;
    }, {});
    return {
        reference,
        verses: versesWithNumbers,
    };
}
function listBooks(version) {
    if (!BIBLE_VERSIONS.includes(version)) {
        throw new Error(`Invalid Bible version: ${version}. Available versions: ${BIBLE_VERSIONS.join(', ')}`);
    }
    const bibleData = getBibleData(version);
    return Object.keys(bibleData).sort((a, b) => {
        // Handle numbered books (e.g., 1-samoela, 2-samoela)
        const aMatch = a.match(/^(\d+)-(.+)$/);
        const bMatch = b.match(/^(\d+)-(.+)$/);
        if (aMatch && bMatch) {
            // If both are numbered books, sort by number first
            const aNum = parseInt(aMatch[1]);
            const bNum = parseInt(bMatch[1]);
            if (aNum !== bNum)
                return aNum - bNum;
            // If numbers are the same, sort by name
            return aMatch[2].localeCompare(bMatch[2]);
        }
        else if (aMatch) {
            // If only a is numbered, it should come first
            return -1;
        }
        else if (bMatch) {
            // If only b is numbered, it should come first
            return 1;
        }
        // If neither is numbered, sort alphabetically
        return a.localeCompare(b);
    });
}
function chapterCount(version, bookName) {
    if (!BIBLE_VERSIONS.includes(version)) {
        throw new Error(`Invalid Bible version: ${version}. Available versions: ${BIBLE_VERSIONS.join(', ')}`);
    }
    const bibleData = getBibleData(version);
    const book = bibleData[bookName.toLowerCase()];
    if (!book) {
        throw new Error(`Book not found: ${bookName}`);
    }
    let count = 0;
    Object.keys(book).forEach(chapter => {
        if (chapter !== 'name' && chapter !== 'order' && chapter !== 'chapter_number') {
            count++;
        }
    });
    return count;
}
function versesCount(version, bookName, chapter) {
    if (!BIBLE_VERSIONS.includes(version)) {
        throw new Error(`Invalid Bible version: ${version}. Available versions: ${BIBLE_VERSIONS.join(', ')}`);
    }
    const bibleData = getBibleData(version);
    const book = bibleData[bookName.toLowerCase()];
    if (!book) {
        throw new Error(`Book not found: ${bookName}`);
    }
    const chapterData = book[chapter.toString()];
    if (!chapterData) {
        throw new Error(`Chapter not found: ${chapter}`);
    }
    return Object.keys(chapterData).length;
}
function countVerses(version, bookName) {
    if (!BIBLE_VERSIONS.includes(version)) {
        throw new Error(`Invalid Bible version: ${version}. Available versions: ${BIBLE_VERSIONS.join(', ')}`);
    }
    const bibleData = getBibleData(version);
    const book = bibleData[bookName.toLowerCase()];
    if (!book) {
        throw new Error(`Book not found: ${bookName}`);
    }
    let totalVerses = 0;
    Object.keys(book).forEach(chapter => {
        if (chapter !== 'name' && chapter !== 'order' && chapter !== 'chapter_number') {
            const chapterData = book[chapter];
            totalVerses += Object.keys(chapterData).length;
        }
    });
    return totalVerses;
}