json-bible 1.0.0 → 1.1.0

package/index.ts

@@ -1,8 +1,9 @@
 import { Bible } from "./lib/Bible"
 import { BIBLE_SIZE, getBookCategory, getDefault, getDefaultBooks, NT_SIZE, OT_SIZE } from "./lib/defaults"
-import { _getBible, _getBook, _getChapter, _getCloseChapter, _getHTML, _getMetadata, _getRandomVerse, _getShortName, _getText, _getVerse, formatText, getBookIndex, getChapterIndex, getVerseIndex } from "./lib/get"
+import { _getBible, _getBook, _getChapter, _getCloseChapter, _getHTML, _getMetadata, _getRandomVerse, _getShortName, _getText, _getVerse, formatText, getBookAbbreviation, getBookIndex, getChapterIndex, getVerseIndex } from "./lib/get"
 import { getReferenceString, getVerseReferences } from "./lib/reference"
 import { _bookSearch, _textSearch } from "./lib/search"
+import "./lib/api/index" // api alternative reader (same structure)
 
 /**
  * JSON Bible Helper
@@ -11,7 +12,7 @@ import { _bookSearch, _textSearch } from "./lib/search"
 export default async function Bible(bibleOrPath: Bible | string) {
     const bible = await _getBible(bibleOrPath)
 
-    return { data: bible, getBook, getAbbreviation, getMetadata, getDefaultBooks, getDefault, getOT, getNT, getRandom, getFromReference, bookSearch, textSearch }
+    return { data: bible, getBook, getAbbreviation, getMetadata, getBooksData, getDefaultBooks, getDefault, getOT, getNT, getRandom, getFromReference, bookSearch, textSearch }
 
     /**
      * Get a specified book or the first one if not provided
@@ -156,8 +157,7 @@ export default async function Bible(bibleOrPath: Bible | string) {
          * @return e.g. "Genesis" = "Gen"
          */
         function getNameShort() {
-            const abbr = getDefaultBooks().ids[book.number - 1]
-            return abbr[0] + abbr.slice(1).toLowerCase()
+            return getBookAbbreviation(bible, bookIndex)
         }
 
         /**
@@ -184,6 +184,23 @@ export default async function Bible(bibleOrPath: Bible | string) {
         return _getMetadata(bible)
     }
 
+    /**
+     * Get books data with category info and calculated abbreviation
+     * @return array with book data
+     */
+    function getBooksData() {
+        return bible.books.map((book, bookIndex) => {
+            const category = getBookCategory(book)
+            return {
+                id: book.id,
+                name: book.name,
+                number: book.number,
+                abbreviation: getBookAbbreviation(bible, bookIndex),
+                category
+            }
+        })
+    }
+
     /**
      * Get all books in the Bible from the Old Testament
      * @return list of max 39 books

package/lib/Bible.ts

@@ -9,6 +9,7 @@ export interface Bible {
 export type Book = {
     number: number // starting from 1
     name: string // e.g. "Genesis"
+    abbreviation?: string // e.g. "Gen"
     id?: string // e.g. "GEN"
 
     chapters: Chapter[]

package/lib/api/ApiBible.ts

@@ -0,0 +1,147 @@
+// BIBLES
+
+// Bible.API format
+export interface BibleListContent {
+    id: string
+    dblId: string // id without "-01"
+    relatedDbl: string | null
+    name: string
+    nameLocal: string // usually same as name
+    abbreviation: string
+    abbreviationLocal: string // usually same as abbreviation
+    description: string
+    descriptionLocal: string // usually same as description
+    language: {
+        id: string // e.g., "eng"
+        name: string // English name
+        nameLocal: string // native name
+        script: string // e.g., Latin
+        scriptDirection: string // e.g., LTR
+    }
+    countries: { id: string; name: string; nameLocal: string }[]
+    type: string // "text" or "audio"
+    updatedAt: string // ISO date string
+    audioBibles: any[]
+}
+
+// contentapi.churchapps.org/bibles format
+export interface CustomBibleListContent {
+    id: string // custom id
+    abbreviation: string
+    name: string
+    nameLocal: string
+    description: string
+    source: string // "api.bible"
+    sourceKey: string // api.bible id
+    language: string // language.id
+    copyright: string // custom deals with copyright info
+    attributionRequired: boolean // custom deal that needs to show attribution string
+    attributionString: string // custom attribution string
+    countryList: string[] // countries.id (lowercase)
+}
+
+// BOOK
+
+export interface BibleBookContent {
+    id: string
+    bibleId: string
+    abbreviation: string
+    name: string
+    nameLong: string
+}
+
+// contentapi.churchapps.org format
+export interface CustomBibleBookContent {
+    id: string // custom id
+    translationKey: string // bibleId
+    keyName: string // id
+    abbreviation: string
+    name: string
+    sort: number // book index
+}
+
+// CHAPTER
+
+export interface BibleChapterContent {
+    id: string // e.g., GEN.1
+    bibleId: string
+    bookId: string // e.g., GEN
+    number: string // can be "intro"
+    reference: string
+}
+
+// contentapi.churchapps.org format
+export interface CustomChapterContent {
+    id: string // custom id
+    translationKey: string // bibleId
+    bookKey: string // bookId
+    keyName: string // id
+    number: number // chapter number
+}
+
+// VERSE
+
+export interface BibleVerseListContent {
+    id: string // e.g., GEN.1.1
+    orgId: string
+    bookId: string // e.g., GEN
+    chapterId: string // e.g., GEN.1
+    bibleId: string
+    reference: string
+}
+
+// contentapi.churchapps.org format
+export interface CustomVerseListContent {
+    id: string // custom id
+    translationKey: string // bibleId
+    chapterKey: string // chapterId
+    keyName: string // id
+    number: number // verse number
+}
+
+export interface BibleVerseContent {
+    id: string // e.g., GEN.1.1
+    orgId: string
+    bookId: string // e.g., GEN
+    chapterId: string // e.g., GEN.1
+    bibleId: string
+    reference: string
+    content: string // HTML content
+    verseCount: number
+    copyright: string
+    next: { id: string; number: string } | null
+    previous: { id: string; number: string } | null
+}
+
+// contentapi.churchapps.org format
+export interface CustomVerseContent {
+    id: string // custom id
+    translationKey: string // bibleId
+    verseKey: string // id
+    bookKey: string // bookId
+    chapterNumber: number // chapter number
+    verseNumber: number // verse number
+    content: string // plain text content
+    newParagraph: boolean // if new paragraph starts here
+}
+
+// SEARCH
+
+export interface BibleContentSearchResult {
+    query: string
+    limit: number
+    offset: number
+    total: number
+    verseCount: number
+    verses: BibleVerseSearchContent[]
+}
+
+export interface BibleVerseSearchContent {
+    id: string // e.g., GEN.1.1
+    orgId: string // usually same as id
+    bookId: string // e.g., GEN
+    bibleId: string // api bible id
+    chapterId: string // e.g., GEN.1
+    reference: string // e.g., Genesis 1:1
+    text: string // plain text content
+}

package/lib/api/converters.ts

@@ -0,0 +1,120 @@
+import type { Verse } from "../Bible"
+import type { BibleBookContent, BibleChapterContent, BibleListContent, BibleVerseContent, BibleVerseListContent, CustomBibleBookContent, CustomBibleListContent, CustomChapterContent, CustomVerseContent, CustomVerseListContent } from "./ApiBible"
+
+export function getCustomBibleListContent(data: (BibleListContent | CustomBibleListContent)[]): CustomBibleListContent[] {
+    if (!data?.length) return []
+    if ((data[0] as CustomBibleListContent).sourceKey) return data as CustomBibleListContent[]
+
+    return (data as BibleListContent[]).map((item) => {
+        return {
+            id: item.id,
+            abbreviation: item.abbreviation,
+            name: item.name,
+            nameLocal: item.nameLocal,
+            description: item.description,
+            source: "api.bible",
+            sourceKey: item.id,
+            language: item.language.id,
+            copyright: "",
+            attributionRequired: false,
+            attributionString: "",
+            countryList: item.countries.map((country) => country.id.toLowerCase())
+        } as CustomBibleListContent
+    })
+}
+
+export function getCustomBookContent(data: (BibleBookContent | CustomBibleBookContent)[]): CustomBibleBookContent[] {
+    if (!data?.length) return []
+    if ((data[0] as CustomBibleBookContent).keyName) return data as CustomBibleBookContent[]
+
+    return (data as BibleBookContent[]).map((book, i) => {
+        return {
+            id: book.id,
+            translationKey: book.bibleId,
+            keyName: book.id,
+            abbreviation: book.abbreviation,
+            name: book.name,
+            sort: i
+        } as CustomBibleBookContent
+    })
+}
+
+export function getCustomChapterContent(data: (BibleChapterContent | CustomChapterContent)[]): CustomChapterContent[] {
+    if (!data?.length) return []
+    if ((data[0] as CustomChapterContent).keyName) return data as CustomChapterContent[]
+
+    return (data as BibleChapterContent[]).map((chapter) => {
+        return {
+            id: chapter.id,
+            translationKey: chapter.bibleId,
+            bookKey: chapter.bookId,
+            keyName: chapter.id,
+            number: parseInt(chapter.number)
+        } as CustomChapterContent
+    })
+}
+
+export function getCustomVerseContent(data: (BibleVerseListContent | CustomVerseListContent)[]): CustomVerseListContent[] {
+    if (!data?.length) return []
+    if ((data as CustomVerseListContent[])[0]?.keyName) return data as CustomVerseListContent[]
+
+    return (data as BibleVerseListContent[]).map((verse) => {
+        return {
+            keyName: verse.id,
+            number: parseInt(verse.id.split(".")[2]),
+            id: verse.id,
+            translationKey: verse.bibleId,
+            chapterKey: verse.chapterId
+        } as CustomVerseListContent
+    })
+}
+
+export function convertVerseTextToJson(verses: BibleVerseContent | CustomVerseContent[]) {
+    // custom data format
+    if (Array.isArray(verses)) {
+        return verses.map((verse) => {
+            const verseNumber = verse.verseNumber
+            const plainText = verse.content || ""
+            return { number: verseNumber, text: plainText } as Verse
+        })
+    }
+
+    // Parse HTML content to extract verses with their numbers
+    const text = verses.content || ""
+    const verseRegex = /<span data-number="(\d+)"[^>]*class="v"[^>]*>\d+<\/span>/g
+    const versesArray: Verse[] = []
+
+    let match: RegExpExecArray | null
+    while ((match = verseRegex.exec(text)) !== null) {
+        const verseNumber = parseInt(match[1])
+        const startIndex = match.index + match[0].length
+
+        // Find the next verse or end of text
+        const nextMatch = verseRegex.exec(text)
+        const endIndex = nextMatch ? nextMatch.index : text.length
+
+        // Reset regex position to continue from where we left off
+        verseRegex.lastIndex = startIndex
+
+        // Extract text between current verse and next verse (or end)
+        let verseText = text.substring(startIndex, endIndex)
+
+        // Clean up HTML tags and normalize whitespace
+        verseText = verseText
+            .replace(/<\/p>/g, " ") // Replace closing p tags with space
+            .replace(/<[^>]*>/g, " ") // Remove all other HTML tags
+            .replace(/\s+/g, " ") // Normalize whitespace
+            .trim()
+
+        if (verseText) {
+            versesArray.push({ number: verseNumber, text: verseText } as Verse)
+        }
+
+        // If we found a next match, we need to process it in the next iteration
+        if (nextMatch) {
+            verseRegex.lastIndex = nextMatch.index
+        }
+    }
+
+    return versesArray
+}

package/lib/api/get.ts

@@ -0,0 +1,156 @@
+import type { Bible, Book, Chapter } from "../Bible"
+import type { BibleContentSearchResult, BibleVerseContent, CustomVerseContent } from "./ApiBible"
+import { convertVerseTextToJson, getCustomBibleListContent, getCustomBookContent, getCustomChapterContent, getCustomVerseContent } from "./converters"
+
+const APIBIBLE_URL = "https://api.scripture.api.bible/v1/bibles"
+
+export default function ApiBibleHelper(key: string, customApiUrl?: string) {
+    if (!key) throw new Error("No API key!")
+
+    let apiUrl = customApiUrl || APIBIBLE_URL
+    if (apiUrl.endsWith("/")) apiUrl = apiUrl.slice(0, -1)
+
+    const headers: { [key: string]: string } = { "api-key": key }
+
+    return { getBibles, bible, clearCache }
+
+    async function getBibles() {
+        return getCustomBibleListContent(await fetchWrapper(apiUrl, headers, 3))
+    }
+
+    async function bible(bibleId: string) {
+        const bibleUrl = `${apiUrl}/${bibleId}`
+
+        // BOOKS
+
+        const booksData = await getApiBooks()
+
+        const json: Bible = {
+            name: "",
+            abbreviation: "",
+            metadata: {},
+            books: booksData.map((book, i) => {
+                return { number: i + 1, name: book.name, id: book.keyName, chapters: [] } as Book
+            })
+        }
+
+        return { json, booksData, getChapters, getVerses, contentSearch }
+
+        async function getApiBooks() {
+            const booksUrl = `${bibleUrl}/books`
+            return getCustomBookContent(await fetchWrapper(booksUrl, headers, 60))
+        }
+
+        // CHAPTERS
+
+        // GEN
+        async function getChapters(bookId: string) {
+            const chaptersData = await getApiChapters(bookId)
+
+            const json = chaptersData.map((chapter) => {
+                return { number: chapter.number, verses: [] } as Chapter
+            })
+
+            return { json, chaptersData }
+        }
+
+        async function getApiChapters(bookId: string) {
+            const chaptersUrl = customApiUrl ? `${bibleUrl}/${bookId}/chapters` : `${bibleUrl}/books/${bookId}/chapters`
+            return getCustomChapterContent(await fetchWrapper(chaptersUrl, headers, 60)).filter((a) => !a.keyName.includes("intro"))
+        }
+
+        // VERSES
+
+        // GEN.1
+        async function getVerses(chapterId: string) {
+            const versesData = await getApiVerses(chapterId)
+            const reference = versesData[0].keyName + "-" + versesData[versesData.length - 1].keyName
+            const versesContent = await getApiVersesContent(reference)
+
+            const json = convertVerseTextToJson(versesContent)
+
+            return { json, versesData }
+        }
+
+        async function getApiVerses(chapterId: string) {
+            const versesUrl = `${bibleUrl}/chapters/${chapterId}/verses`
+            return getCustomVerseContent(await fetchWrapper(versesUrl, headers, 60))
+        }
+
+        // GEN.1.1-GEN.1.10
+        async function getApiVersesContent(reference: string) {
+            const versesReferenceUrl = `${bibleUrl}/verses/${reference}`
+            return (await fetchWrapper(versesReferenceUrl, headers, 60)) as BibleVerseContent | CustomVerseContent[]
+        }
+
+        // SEARCH
+
+        // no api key needed, just the bible id
+        async function contentSearch(query: string, { limit } = { limit: 20 }) {
+            const url = `${bibleUrl}/search?query=${query}&limit=${limit}`
+            return ((await fetchWrapper(url, headers, 14)) as BibleContentSearchResult).verses
+        }
+    }
+
+    function clearCache(key: string) {
+        clearCachedContent(key)
+    }
+}
+
+// HTTP
+
+export function fetchWrapper(url: string, headers: any, cacheTimeDays: number) {
+    if (getCachedContent(url)) return Promise.resolve(getCachedContent(url, cacheTimeDays))
+
+    // console.info("Fetching:", url)
+    return fetch(url, { headers })
+        .then((response) => {
+            if (response.status !== 200) {
+                throw new Error("Bad response from server: " + response.status)
+            }
+
+            return response.json()
+        })
+        .then((data) => {
+            if (!Array.isArray(data) && data?.data) data = data.data
+            if (!data) throw new Error("No data found")
+
+            cacheContent(url, data)
+            return data
+        })
+        .catch((e) => {
+            throw new Error(e)
+        })
+}
+
+// CACHE
+
+export function cacheContent(key: string, data: any) {
+    if (typeof localStorage === "undefined") return
+
+    const cacheEntry = { data, timestamp: Date.now() }
+    localStorage.setItem(key, JSON.stringify(cacheEntry))
+}
+
+const ONE_DAY_MS = 24 * 60 * 60 * 1000
+export function getCachedContent(key: string, maxAgeDays: number = 7) {
+    if (typeof localStorage === "undefined") return null
+
+    const cached = localStorage.getItem(key)
+    if (!cached) return null
+
+    const { data, timestamp } = JSON.parse(cached)
+    const age = Date.now() - timestamp
+
+    if (age > maxAgeDays * ONE_DAY_MS) {
+        clearCachedContent(key)
+        return null
+    }
+
+    return data
+}
+
+export function clearCachedContent(key: string) {
+    if (typeof localStorage === "undefined") return
+    localStorage.removeItem(key)
+}

package/lib/api/index.ts

@@ -0,0 +1,293 @@
+import { BIBLE_SIZE, getBookCategory, getDefault, getDefaultBooks, NT_SIZE, OT_SIZE } from "../defaults"
+import { _getBook, _getChapter, _getCloseChapter, _getHTML, _getMetadata, _getShortName, _getText, _getVerse, formatText, getBookAbbreviation, getBookIndex, getChapterIndex, getVerseIndex } from "../get"
+import { getReferenceString, getVerseReferences, VerseReference } from "../reference"
+import { _bookSearch } from "../search"
+import ApiBibleHelper from "./get"
+
+///// API BIBLE (requests one part at a time) /////
+// Works with the Bible.API format
+// Any custom API URL uses a smaller, but similar format (see ApiBible.ts)
+// Used by FreeShow Presentation Software through the ChurchApps ContentAPI
+
+/**
+ * API.Bible Bibles List
+ * @param apiKey API key from https://api.bible
+ * @param apiUrl custom api URL
+ * @returns
+ */
+export function ApiBiblesList(apiKey: string, apiUrl?: string) {
+    return ApiBibleHelper(apiKey, apiUrl).getBibles()
+}
+
+/**
+ * API.Bible Helper
+ * @param apiKey API key from https://api.bible
+ * @param apiUrl custom api URL
+ */
+export async function ApiBible(apiKey: string, bibleKey: string, apiUrl?: string) {
+    const apiData = await ApiBibleHelper(apiKey, apiUrl)
+    const bibleData = await apiData.bible(bibleKey)
+    const bible = bibleData.json
+
+    return { data: bible, getBook, getAbbreviation, getMetadata, getBooksData, getDefaultBooks, getDefault, getOT, getNT, getFromReference, bookSearch, textSearch }
+
+    /**
+     * Get a specified book or the first one if not provided
+     * @param number book number/name/id
+     * @return book data
+     */
+    async function getBook(numberOrId?: string | number) {
+        if (numberOrId === undefined) numberOrId = bible.books[0].number
+        let bookIndex = getBookIndex(bible, numberOrId)
+        const book = _getBook(bible, bookIndex)
+
+        const bookId = bible.books[bookIndex]?.id || ""
+        const chapters = await bibleData.getChapters(bookId)
+        book.chapters = chapters.json
+
+        return { data: book, index: bookIndex, number: book.number, name: book.name, getChapter, getAbbreviation: getNameShort, getCategory }
+
+        /**
+         * Get a specified chapter or the first one if no number provided
+         * @param number chapter number
+         * @return chapter data
+         */
+        async function getChapter(number?: number) {
+            if (number === undefined) number = book.chapters[0].number
+            let chapterIndex = getChapterIndex(book, number)
+            const chapter = _getChapter(book, chapterIndex)
+
+            const chapterId = `${bookId}.${number}`
+            const verses = await bibleData.getVerses(chapterId)
+            chapter.verses = verses.json
+
+            return { data: chapter, index: chapterIndex, number, getVerse, getVerses, getNext, getPrevious, getReference }
+
+            /**
+             * Get a specified verse or the first one if no number provided
+             * @param number verse number
+             * @return verse data
+             */
+            function getVerse(number?: number) {
+                if (number === undefined) number = chapter.verses[0].number
+                let verseIndex = getVerseIndex(chapter, number)
+                const verse = _getVerse(chapter, verseIndex)
+
+                return { data: verse, index: verseIndex, number, getText, getHTML, getReference }
+
+                /**
+                 * A plain text string of the verse
+                 * @param includeNumbers should verse numbers be included
+                 * @return verse text
+                 */
+                function getText(includeNumber: boolean = false) {
+                    return _getText(verse, includeNumber)
+                }
+
+                /**
+                 * A HTML string of the verse with parsed markdown
+                 * @param includeNumbers should verse numbers be included
+                 * @return HTML string value
+                 */
+                function getHTML(includeNumber: boolean = false) {
+                    return _getHTML(verse, includeNumber)
+                }
+
+                /**
+                 * Get verse reference
+                 * @param addBibleVersion add Bible abbreviation at the end of the reference
+                 * @return reference string, e.g. "Genesis 1:1"
+                 */
+                function getReference(addBibleVersion: boolean = false) {
+                    return _getReference([verse.number], addBibleVersion)
+                }
+            }
+
+            /**
+             * Get a selection of verses based in an array of numbers
+             * @param verseNumbers verse numbers
+             * @param html should markdown text be parsed to HTML
+             * @return verses data
+             */
+            function getVerses(verseNumbers: number[] = [], html: boolean = false) {
+                let verses = chapter.verses
+                if (verseNumbers.length) verses = verses.filter((a) => verseNumbers.includes(a.number))
+
+                const data = verses.reduce((obj, { number, text }) => ({ ...obj, [number]: formatText(text, html) }), {} as { [key: number]: string })
+                const numbers = verseNumbers.length ? verseNumbers : verses.map((a) => a.number)
+
+                return { data, numbers, getText, getHTML, getReference }
+
+                /**
+                 * A plain text string of the verses
+                 * @param includeNumbers should verse numbers be included
+                 * @return verse text
+                 */
+                function getText(includeNumbers: boolean = false) {
+                    return verses.map((v) => _getText(v, includeNumbers)).join(" ")
+                }
+
+                /**
+                 * A HTML string of the verses with parsed markdown
+                 * @param includeNumbers should verse numbers be included
+                 * @return HTML string value
+                 */
+                function getHTML(includeNumbers: boolean = false) {
+                    return verses.map((v, i) => _getHTML(v, includeNumbers, i === 0)).join(" ")
+                }
+
+                /**
+                 * Get verses reference
+                 * @param addBibleVersion add Bible abbreviation at the end of the reference
+                 * @return reference string, e.g. "Genesis 1:1-3"
+                 */
+                function getReference(addBibleVersion: boolean = false) {
+                    return _getReference(numbers, addBibleVersion)
+                }
+            }
+
+            /**
+             * Get next chapter relative to the one currently selected
+             * @return a reference to the next chapter, including possibly changed book - null if none available
+             */
+            function getNext() {
+                return _getCloseChapter(bible, book.number, chapter.number, true)
+            }
+
+            /**
+             * Get previous chapter relative to the one currently selected
+             * @return a reference to the previous chapter, including possibly changed book - null if none available
+             */
+            function getPrevious() {
+                return _getCloseChapter(bible, book.number, chapter.number, false)
+            }
+
+            /**
+             * Get chapter reference
+             * @param addBibleVersion add Bible abbreviation at the end of the reference
+             * @return reference string, e.g. "Genesis 1"
+             */
+            function getReference(addBibleVersion: boolean = false) {
+                return _getReference([], addBibleVersion)
+            }
+
+            // HELPER
+            function _getReference(verses: number[], addBibleVersion: boolean = false) {
+                return getReferenceString({ book: book.number, chapter: chapter.number, verses }, bible) + (addBibleVersion ? ` ${getAbbreviation()}` : "")
+            }
+        }
+
+        /**
+         * Get three letter book abbreviation/short name
+         * @return e.g. "Genesis" = "Gen"
+         */
+        function getNameShort() {
+            return getBookAbbreviation(bible, bookIndex)
+        }
+
+        /**
+         * Get current book category name/color, all categories are:
+         * "The Law", "History", "Poetry & Wisdom", "Prophets", "The Gospels & Acts", "Letters" & "Apocalyptic"
+         * @return book category object
+         */
+        function getCategory() {
+            return getBookCategory(book)
+        }
+    }
+
+    /**
+     * @return bible name abbreviation/identifier
+     */
+    function getAbbreviation() {
+        return _getShortName(bible)
+    }
+
+    /**
+     * @return trimmed metadata object
+     */
+    function getMetadata() {
+        return _getMetadata(bible)
+    }
+
+    /**
+     * Get books data with category info and calculated abbreviation
+     * @return array with book data
+     */
+    function getBooksData() {
+        return bible.books.map((book, bookIndex) => {
+            const category = getBookCategory(book)
+            return {
+                id: book.id,
+                name: book.name,
+                number: book.number,
+                abbreviation: getBookAbbreviation(bible, bookIndex),
+                category
+            }
+        })
+    }
+
+    /**
+     * Get all books in the Bible from the Old Testament
+     * @return list of max 39 books
+     */
+    function getOT() {
+        if (bible.books.length === OT_SIZE) return bible.books
+        if (bible.books.length === BIBLE_SIZE) return bible.books.slice(0, OT_SIZE)
+        return bible.books.filter((a) => a.number >= 1 && a.number <= OT_SIZE)
+    }
+
+    /**
+     * Get all books in the Bible from the New Testament
+     * @return list of max 27 books
+     */
+    function getNT() {
+        if (bible.books.length === NT_SIZE) return bible.books
+        if (bible.books.length === BIBLE_SIZE) return bible.books.slice(OT_SIZE)
+        return bible.books.filter((a) => a.number > OT_SIZE && a.number <= BIBLE_SIZE)
+    }
+
+    /**
+     * Get book/chapter/verses from a string reference
+     * @param value e.g. "Genesis 1:1-3" / "GEN.1.2-3" / "1.1.1"
+     * @return matching content
+     */
+    function getFromReference(value: string) {
+        return getVerseReferences(bible, value)
+    }
+
+    /**
+     * Search for book/chapter/verses with autocomplete
+     * @param value e.g. "Genesis 1:1-3"
+     * @return matching content
+     */
+    function bookSearch(value: string) {
+        return _bookSearch(bible, value)
+    }
+
+    /**
+     * Search for text content in the entire Bible
+     * @param value search string
+     * @param limit max results, lower number means quicker search
+     * @param bookNumber search only in a specified book
+     * @return an array of verses
+     */
+    async function textSearch(value: string, limit: number = 50) {
+        const result = await bibleData.contentSearch(value, { limit })
+
+        // convert result to VerseReference[]
+        return result.map((r) => {
+            const bookIndex = bible.books.findIndex((b) => b.id === r.bookId)
+            const book = bookIndex >= 0 ? bookIndex + 1 : r.bookId
+            const chapter = Number(r.id.split(".")[1])
+            const verse = Number(r.id.split(".")[2])
+
+            return {
+                book,
+                chapter,
+                verse: { number: verse, text: r.text },
+                reference: r.reference,
+                id: `${r.bookId}.${chapter}.${verse}`
+            } as VerseReference
+        })
+    }
+}

package/lib/defaults.ts

@@ -32,6 +32,7 @@ export function getDefaultMetadata() {
 // BOOKS
 
 const BOOKS = {
+    // GT
     GEN: "Genesis",
     EXO: "Exodus",
     LEV: "Leviticus",
@@ -57,21 +58,22 @@ const BOOKS = {
     ISA: "Isaiah",
     JER: "Jeremiah",
     LAM: "Lamentations",
-    EZE: "Ezekiel",
+    EZK: "Ezekiel",
     DAN: "Daniel",
     HOS: "Hosea",
-    JOE: "Joel",
+    JOL: "Joel",
     AMO: "Amos",
     OBA: "Obadiah",
     JON: "Jonah",
     MIC: "Micah",
-    NAH: "Nahum",
+    NAM: "Nahum",
     HAB: "Habakkuk",
     ZEP: "Zephaniah",
     HAG: "Haggai",
     ZEC: "Zechariah",
     MAL: "Malachi",
 
+    // NT
     MAT: "Matthew",
     MRK: "Mark",
     LUK: "Luke",
@@ -98,7 +100,18 @@ const BOOKS = {
     "2JN": "2 John",
     "3JN": "3 John",
     JUD: "Jude",
-    REV: "Revelation"
+    REV: "Revelation",
+
+    // APOCRYPHA
+    TOB: "Tobit",
+    JDT: "Judith",
+    ESG: "Esther (Greek)",
+    WIS: "Wisdom",
+    SIR: "Sirach",
+    BAR: "Baruch",
+    LJE: "Letter of Jeremiah",
+    "1MA": "1 Maccabees",
+    "2MA": "2 Maccabees"
 }
 type BookId = keyof typeof BOOKS
 
@@ -109,7 +122,8 @@ const categories = [
     { id: "prophets", start: "ISA", name: "Prophets", color: "#42e84d" },
     { id: "gospels", start: "MAT", name: "The Gospels & Acts", color: "#42c4e8" },
     { id: "letters", start: "ROM", name: "Letters", color: "#e8de42" }, // #b542e8
-    { id: "prophecy", start: "REV", name: "Apocalyptic", color: "#e842e5" }
+    { id: "prophecy", start: "REV", name: "Apocalyptic", color: "#e842e5" },
+    { id: "apocrypha", start: "TOB", name: "Apocrypha", color: "#8269fa" }
 ]
 
 export function getDefaultBooks() {
@@ -128,9 +142,23 @@ export function getDefaultBooks() {
 }
 
 export function getBookCategory(book: Book) {
-    return categories.find((a, i) => {
-        const startNumber = Object.keys(BOOKS).indexOf(a.start) + 1
-        const endNumber = Object.keys(BOOKS).indexOf(categories[i + 1]?.start) + 1 || startNumber + 1
-        return book.number >= startNumber && book.number < endNumber
-    })
+    const bookId = book.id
+    const bookNumber = book.number
+
+    const defaults = getDefaultBooks()
+
+    let currentIndex = defaults.ids.indexOf(bookId as any)
+    if (bookId?.length === 3 && currentIndex < 0) return null
+
+    if (currentIndex < 0) currentIndex = bookNumber - 1
+    if (currentIndex > defaults.names.length - 1) return null
+
+    // find category based on current index
+    let categoryIndex = 0
+    for (let i = 0; i < categories.length; i++) {
+        const startIndex = defaults.ids.indexOf(categories[i].start as any)
+        if (currentIndex >= startIndex) categoryIndex = i
+    }
+
+    return categories[categoryIndex]
 }

package/lib/get.ts

@@ -34,28 +34,28 @@ export function _getShortName(bible: Bible) {
 // MAIN //
 
 export function getBookIndex(bible: Bible, numberOrName: string | number) {
-    if (isNumber(numberOrName)) return bible.books.findIndex((a) => a.number === Number(numberOrName))
+    if (isNumber(numberOrName)) return bible.books.findIndex((a) => Number(a.number) === Number(numberOrName))
     return bible.books.findIndex((a) => a.name === numberOrName || a.id === numberOrName)
 }
 
 export function _getBook(bible: Bible, index: number) {
-    return bible.books[index] || getDefault().book
+    return bible.books[index] || bible.books[0] || getDefault().book
 }
 
 export function getChapterIndex(book: Book, number: number) {
-    return book.chapters.findIndex((a) => a.number === Number(number))
+    return book.chapters.findIndex((a) => Number(a.number) === Number(number))
 }
 
 export function _getChapter(book: Book, index: number) {
-    return book.chapters[index] || getDefault().chapter
+    return book.chapters[index] || book.chapters[0] || getDefault().chapter
 }
 
 export function getVerseIndex(chapter: Chapter, number: number) {
-    return chapter.verses.findIndex((a) => a.number === number || (a.endNumber && number > a.number && number <= a.endNumber))
+    return chapter.verses.findIndex((a) => Number(a.number) === Number(number) || (a.endNumber && Number(number) > Number(a.number) && Number(number) <= Number(a.endNumber)))
 }
 
 export function _getVerse(chapter: Chapter, index: number) {
-    return chapter.verses[index] || getDefault().verse
+    return chapter.verses[index] || chapter.verses[0] || getDefault().verse
 }
 
 // BOOK //
@@ -76,6 +76,30 @@ export function getBookName(numberOrId: number | string, bible?: Bible) {
     return getDefaultBooks().byId(numberOrId.toString())
 }
 
+export function getBookAbbreviation(bible: Bible, bookIndex: number) {
+    const currentBook = bible.books[bookIndex]
+    if (!currentBook) return ""
+
+    if (currentBook.abbreviation) return currentBook.abbreviation
+
+    const abbr = currentBook.id || ""
+    const name = currentBook.name
+    const defaultBookName = (getDefaultBooks().data as any)[abbr]
+
+    if (name === defaultBookName) return abbr[0] + abbr.slice(1).toLowerCase()
+
+    const hasNumber = isNaN(parseInt(name[0]))
+    let shortName = hasNumber ? name.slice(0, 3) : name.replace(/[^\w]/g, "").slice(0, 4)
+
+    // use four characters if same short name ("Jud"ges="Jud"e)
+    if (shortName.length === 3 && bible.books.some((a) => a.abbreviation === shortName)) {
+        shortName = name.slice(0, 4)
+    }
+
+    currentBook.abbreviation = shortName
+    return shortName
+}
+
 // CHAPTER //
 
 export function _getCloseChapter(bible: Bible, currentBookNumberOrName: number | string, currentChapterNumber: number, next: boolean) {

package/lib/reference.ts

@@ -110,7 +110,7 @@ function parseUniversalReference(ref: UniversalReference) {
 
 // Genesis 1:1-3 / GEN 1:1-3 / GEN.1.1-3 = 1.1.1-3
 function referenceStringToId(ref: string) {
-    const regex = /^(?:[A-Z]+|[0-9]+)(?:\.[0-9]+)?(?:\.[0-9+-]+)?$/
+    const regex = /^(?:[\p{Lu}]+|[0-9]+)(?:\.[0-9]+)?(?:\.[0-9+-]+)?$/u
     const isId = ref.match(regex) !== null
     if (isId) return parseReferenceId(ref)
 
@@ -127,7 +127,7 @@ function referenceStringToId(ref: string) {
 // "Genesis 1:1-3" = { book: "Genesis ", chapter: 1, verses: [1, 2, 3] }
 function splitReferenceString(ref: string) {
     // (:,.) allowed between chapter/verse - (-+) allowed between verses
-    const regex = /(?<book>[1-3]?\s?[A-Za-z]+)(?:\s(?<chapter>\d+))?(?:[:,.](?<verses>[0-9,.\-+]+))?/
+    const regex = /(?<book>(?:\d+\.?\s?)?[\p{L}](?:[\p{L}\s']*[\p{L}])?)(?:\s(?<chapter>\d+))?(?:[:,.](?<verses>[0-9,.\-+]+))?/u
     const match = ref.match(regex)
 
     if (!match) return { book: "", chapter: "", verses: "" }
@@ -143,9 +143,14 @@ function splitReferenceString(ref: string) {
 // VERSE REFERENCE //
 
 // [1, 2, 3] = "1-3" / [4, 2, 7, 1, 9, 10] = "1-2+4+7+9-10"
-function getVerseReference(verses: number[]) {
+// WIP reference array might also contain subverses e.g. ["1_b", 2, "6_a"], which will become "1b-2+6a"
+function getVerseReference(verses: (number | string)[]) {
     // sort in ascending order
-    verses.sort((a, b) => a - b)
+    verses.sort((a, b) => {
+        const numA = typeof a === "number" ? a : Number(a.split("_")[0])
+        const numB = typeof b === "number" ? b : Number(b.split("_")[0])
+        return numA - numB
+    })
 
     let verseRef = ""
     let i = 0
@@ -153,7 +158,7 @@ function getVerseReference(verses: number[]) {
     while (i < verses.length) {
         // get consecutive verses
         let start = verses[i]
-        while (i < verses.length - 1 && verses[i] + 1 === verses[i + 1]) i++
+        while (i < verses.length - 1 && Number(verses[i]) + 1 === Number(verses[i + 1])) i++
         let end = verses[i]
 
         // if start and end are the same add the number, if not add the range

package/lib/search.ts

@@ -1,4 +1,5 @@
 import { Bible } from "./Bible"
+import { getDefaultBooks } from "./defaults"
 import { getBookIndex } from "./get"
 import { getReferenceFromSearchString, getReferenceString, getVerseReferences, SearchReference, VerseReference } from "./reference"
 
@@ -31,9 +32,25 @@ export function _bookSearch(bible: Bible, searchValue: string) {
     returnValue.chapter = chapter.number
 
     const verses = findVerses(reference.verses)
+    if (!verses.length) {
+        // add divider (:) automatically if space at end
+        if (searchValue.endsWith(" ") && !searchValue.trim().includes(":")) returnValue.autocompleted = returnValue.autocompleted.trim() + ":"
+        else returnValue.autocompleted = returnValue.autocompleted.trim()
+
+        return finish()
+    }
     returnValue.verses = verses.map(({ number }) => number)
     returnValue.versesContent = verses
 
+    // add divider (+/-) automatically if space at end
+    if (searchValue.endsWith(" ") && !searchValue.trim().endsWith("-") && !searchValue.trim().endsWith("+")) {
+        const minus = (searchValue.match(/-/g) || []).length
+        const plus = (searchValue.match(/\+/g) || []).length
+        returnValue.autocompleted = returnValue.autocompleted.trim() + (minus === plus ? "-" : "+")
+    } else {
+        returnValue.autocompleted = returnValue.autocompleted.trim()
+    }
+
     return finish()
 
     /////
@@ -44,16 +61,21 @@ export function _bookSearch(bible: Bible, searchValue: string) {
     }
 
     function findBooks(name: string) {
-        const formatText = (a: string) => a.replace(/\s/g, "").toLowerCase()
-        name = formatText(name)
+        name = removeSpaces(formatText(name))
 
         let matches = []
         for (let book of bible.books) {
-            const bookName = formatText(book.name)
+            const bookName = removeSpaces(formatText(book.name))
             if (bookName === name) return [book]
             if (bookName.includes(name)) matches.push(book)
         }
 
+        // find any abbreviation matches
+        for (let book of bible.books) {
+            let abbr = getDefaultBooks().ids[book.number - 1] || ""
+            if (abbr.toLowerCase() === name) return [book]
+        }
+
         // remove books with numbers if no number at search start (John)
         const hasNum = (str: string) => /\d/.test(str)
         if (!hasNum(name[0])) matches = matches.filter((book) => !hasNum(book.name))
@@ -62,11 +84,11 @@ export function _bookSearch(bible: Bible, searchValue: string) {
     }
 
     function findChapter(number: number) {
-        return book.chapters.find((a) => a.number === number)
+        return book.chapters.find((a) => Number(a.number) === number)
     }
 
     function findVerses(verses: number[]) {
-        return chapter?.verses.filter((a) => verses.includes(a.number)) || []
+        return chapter?.verses.filter((a) => verses.includes(Number(a.number))) || []
     }
 }
 
@@ -74,7 +96,6 @@ export function _bookSearch(bible: Bible, searchValue: string) {
 
 let textSearchCache: { [key: string]: string } = {}
 export function _textSearch(bible: Bible, searchValue: string, limit: number, bookNumber?: number) {
-    const formatText = (a: string) => a.replace(/[`!*()-?;:'",.]/gi, "").toLowerCase()
     searchValue = formatText(searchValue).trim()
     if (!searchValue.length) return []
 
@@ -120,3 +141,20 @@ export function _textSearch(bible: Bible, searchValue: string, limit: number, bo
         return matches
     }
 }
+
+// HELPERS //
+
+function formatText(text: string) {
+    return (
+        text
+            // replace diacritic values like á -> a & ö -> o
+            .normalize("NFD")
+            .replace(/\p{Diacritic}/gu, "")
+            // remove special characters
+            .replace(/[`!*()\-?;:'",.]/gi, "")
+            .toLowerCase()
+    )
+}
+function removeSpaces(text: string) {
+    return text.replace(/\s/g, "")
+}

package/package.json

@@ -1,18 +1,18 @@
-{
-    "name": "json-bible",
-    "description": "Universal JSON Bible Format",
-    "version": "1.0.0",
-    "main": "index.js",
-    "type": "module",
-    "scripts": {
-        "dev": "node dist/index.js",
-        "build": "tsc && node add-js-extension.js",
-        "test": "echo \"Error: no test specified\" && exit 1"
-    },
-    "author": "vassbo",
-    "license": "ISC",
-    "devDependencies": {
-        "@types/node": "^22.7.6",
-        "typescript": "^5.6.2"
-    }
-}
+{
+    "name": "json-bible",
+    "description": "Universal JSON Bible Format",
+    "version": "1.1.0",
+    "main": "index.js",
+    "type": "module",
+    "scripts": {
+        "dev": "node dist/index.js",
+        "build": "tsc && node add-js-extension.js",
+        "test": "echo \"Error: no test specified\" && exit 1"
+    },
+    "author": "vassbo",
+    "license": "ISC",
+    "devDependencies": {
+        "@types/node": "^22.7.6",
+        "typescript": "^5.6.2"
+    }
+}