json-bible 1.0.0

package/lib/get.ts

@@ -0,0 +1,164 @@
+import { Bible, Book, Chapter, Metadata, Verse } from "./Bible"
+import { getDefault, getDefaultBooks, getDefaultMetadata } from "./defaults"
+import { bibleFromFile, validateBible } from "./load"
+import { parseMarkdown, stripMarkdown } from "./markdown"
+import { getVerseReferences } from "./reference"
+import { isNumber, stripText } from "./util"
+
+// BIBLE //
+
+export async function _getBible(bibleOrPath: Bible | string) {
+    let bible: Bible
+    if (typeof bibleOrPath === "string") bible = await bibleFromFile(bibleOrPath)
+    else bible = bibleOrPath
+
+    validateBible(bible)
+
+    return bible
+}
+
+export function _getShortName(bible: Bible) {
+    if (bible.abbreviation) return bible.abbreviation
+    if (bible.metadata.identifier) return bible.metadata.identifier
+    if (bible.name.length < 5) return bible.name.toUpperCase()
+
+    return bible.name
+        .trim()
+        .split(" ")
+        .filter((word) => isNaN(Number(word))) // filter out numbers
+        .map((word) => word[0]) // get the first letter of each word
+        .join("")
+        .toUpperCase()
+}
+
+// MAIN //
+
+export function getBookIndex(bible: Bible, numberOrName: string | number) {
+    if (isNumber(numberOrName)) return bible.books.findIndex((a) => 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
+}
+
+export function getChapterIndex(book: Book, number: number) {
+    return book.chapters.findIndex((a) => a.number === Number(number))
+}
+
+export function _getChapter(book: Book, index: number) {
+    return book.chapters[index] || 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))
+}
+
+export function _getVerse(chapter: Chapter, index: number) {
+    return chapter.verses[index] || getDefault().verse
+}
+
+// BOOK //
+
+export function getBookNumber(numberOrNameOrId: number | string, bible?: Bible) {
+    if (isNumber(numberOrNameOrId)) return Number(numberOrNameOrId)
+    if (bible?.books) return bible.books.findIndex((a) => a.name === numberOrNameOrId || a.id === numberOrNameOrId)
+
+    const index = Object.entries(getDefaultBooks().data).findIndex(([id, name]) => name === numberOrNameOrId || id === numberOrNameOrId)
+    return index + 1
+}
+
+export function getBookName(numberOrId: number | string, bible?: Bible) {
+    let bibleName = bible?.books.find((a) => a.number === numberOrId || a.id === numberOrId)
+    if (bibleName?.name) return bibleName.name
+
+    if (isNumber(numberOrId)) return getDefaultBooks().byNumber(Number(numberOrId))
+    return getDefaultBooks().byId(numberOrId.toString())
+}
+
+// CHAPTER //
+
+export function _getCloseChapter(bible: Bible, currentBookNumberOrName: number | string, currentChapterNumber: number, next: boolean) {
+    let bookIndex = getBookIndex(bible, currentBookNumberOrName)
+    let book = _getBook(bible, bookIndex)
+    let chapterIndex = getChapterIndex(book, Number(currentChapterNumber))
+    let chapter = book.chapters[chapterIndex + (next ? 1 : -1)]
+
+    if (!chapter) {
+        book = _getBook(bible, bookIndex + (next ? 1 : -1))
+        chapter = book.chapters[next ? 0 : book.chapters.length - 1]
+    }
+    if (!chapter) return null
+
+    return getVerseReferences(bible, { book: book.number, chapter: chapter.number, verses: [] })[0]
+}
+
+// VERSE //
+
+export function _getText(verse: Verse, includeNumber: boolean = false) {
+    let text = stripMarkdown(stripText(verse.text))
+    if (includeNumber) text = `${getVerseNumber(verse)} ${text.trim()}`
+    return text
+}
+
+export function _getHTML(verse: Verse, includeNumber: boolean = false, bigNumber: boolean = false) {
+    let html = parseMarkdown(verse.text || "")
+    if (includeNumber) html = `<span class="number${bigNumber ? " big" : ""}">${getVerseNumber(verse)}</span> ${html.trim()}`
+    return html
+}
+
+export function formatText(value: string, html: boolean = false) {
+    value = stripText(value)
+    if (html) value = parseMarkdown(value)
+    return value
+}
+
+function getVerseNumber(verse: Verse) {
+    let number = verse.number.toString()
+    if (verse.endNumber) number += `-${verse.endNumber}`
+    return number
+}
+
+export function _getRandomVerse(bible: Bible) {
+    let bookIndex = randomNum(bible.books.length)
+    const book = bible.books[bookIndex]
+    let chapterIndex = randomNum(book.chapters.length)
+    const chapter = book.chapters[chapterIndex]
+    let verseIndex = randomNum(chapter.verses.length)
+    const verse = chapter.verses[verseIndex]
+
+    return getVerseReferences(bible, { book: book.number, chapter: chapter.number, verses: [verse.number] })[0]
+
+    function randomNum(end: number) {
+        return Math.floor(Math.random() * end)
+    }
+}
+
+// METADATA //
+
+export function _getMetadata(bible: Bible) {
+    if (typeof bible.metadata !== "object") throw new Error("Missing metadata!")
+
+    // trim metadata values
+    let metadata: Metadata = {}
+    Object.keys(bible.metadata).forEach((key) => {
+        let value = trim(bible.metadata[key])
+        if (value.length) metadata[key] = value
+    })
+
+    // add all default values
+    const defaultMetadata = getDefaultMetadata()
+    Object.keys(defaultMetadata).forEach((key) => {
+        if (!metadata[key]) metadata[key] = defaultMetadata[key]
+    })
+
+    // add known values
+    if (!metadata.title) metadata.title = bible.name
+    if (!metadata.identifier) metadata.identifier = _getShortName(bible)
+
+    return metadata
+
+    function trim(value: string) {
+        return stripText(value).trim()
+    }
+}

package/lib/load.ts

@@ -0,0 +1,70 @@
+import { Bible } from "./Bible"
+import { getDefaultBooks } from "./defaults"
+import { getBookName, getBookNumber } from "./get"
+
+export async function bibleFromFile(filePath: string) {
+    let content = ""
+
+    if (filePath.match(/^https?:\/\//)) {
+        content = await fetchFile(filePath)
+    } else {
+        try {
+            content = await loadFileNode(filePath)
+        } catch (_) {
+            // not node environment
+            content = await fetchFile(filePath)
+        }
+    }
+
+    if (!content) throw new Error("No file content!")
+
+    let bible: Bible
+    try {
+        bible = JSON.parse(content)
+    } catch (err) {
+        throw new Error("Error parsing JSON: " + err)
+    }
+
+    return bible
+}
+
+async function loadFileNode(filePath: string) {
+    const fs = require("fs")
+    try {
+        return await fs.readFile(filePath, "utf8")
+    } catch (err) {
+        throw new Error("Error getting file: " + err)
+    }
+}
+
+async function fetchFile(filePath: string) {
+    try {
+        const response = await fetch(filePath)
+        return await response.text()
+    } catch (err) {
+        throw new Error("Error getting file: " + err)
+    }
+}
+
+export function validateBible(bible: Bible) {
+    if (!bible.name) incomplete("Missing name!")
+    if (!bible.books?.length) incomplete("No books!")
+
+    // this only checks first
+    if (!bible.books[0]?.chapters?.length) incomplete("No initial chapters!")
+    if (!bible.books[0]?.chapters[0]?.verses?.length) incomplete("No initial verses!")
+    if (!bible.books[0]?.chapters[0]?.verses[0]?.text?.length) incomplete("No initial text!")
+
+    // set book names/id if missing
+    bible.books = bible.books.map((book) => {
+        if (!book.name) book.name = getBookName(book.id || book.number)
+        if (!book.number) book.number = getBookNumber(book.name)
+        if (!book.id) book.id = getDefaultBooks().ids[book.number - 1]
+
+        return book
+    })
+
+    function incomplete(message: string) {
+        throw new Error("Incorrect Bible format: " + message)
+    }
+}

package/lib/markdown.ts

@@ -0,0 +1,63 @@
+export function parseMarkdown(input: string) {
+    // Undertitle: # Text #
+    input = input.replace(/#\s*(.*?)\s*#/g, "<h4>$1</h4>")
+
+    // Cross Reference & Notes: *{text}* | *{[reference](id) text}*
+    input = parseCrossReferences()
+
+    // Jesus Red Words: !{text}!
+    input = input.replace(/!\{(.*?)\}!/g, '<span style="color:red;">$1</span>')
+
+    // Uncertain: [text]
+    input = input.replace(/\[(.*?)\]/g, '<span class="uncertain">[$1]</span>')
+
+    ///// https://www.markdownguide.org/basic-syntax/
+
+    // Bold: **text** or __text__
+    input = input.replace(/(\*\*|__)(.*?)\1/g, "<strong>$2</strong>")
+
+    // Italic: *text* or _text_
+    input = input.replace(/(\*|_)(.*?)\1/g, "<em>$2</em>")
+
+    // Underline: ++text++
+    input = input.replace(/\+\+(.*?)\+\+/g, "<u>$1</u>")
+
+    // Strikethrough: ~~text~~
+    input = input.replace(/~~(.*?)~~/g, "<del>$1</del>")
+
+    /////
+
+    // Quote: "text"
+    input = input.replace(/(?<!<[^>]*?)"([^"]*?)"(?![^<]*?>)/g, "<q>$1</q>")
+
+    // Line Break: \n
+    input = input.replace(/\n/g, "<br>")
+
+    // Paragraph: ¶
+    input = input.replace(/¶/g, "<br><br>")
+
+    return input
+
+    function parseCrossReferences() {
+        return input.replace(/\*\{(.*?)\}\*/g, (_, content) => {
+            const transformedContent = content.replace(/\[(.*?)\]\((.*?)\)/g, '<span id="$2" class="cross-ref-id">$1</span>')
+            return `<span class="cross-ref"><span class="content">${transformedContent}</span></span>`
+        })
+    }
+}
+
+export function stripMarkdown(input: string) {
+    input = input.replace(/#\s*(.*?)\s*#/g, "")
+    input = input.replace(/\*\{(.*?)\}\*/g, "$1")
+    input = input.replace(/!\{(.*?)\}!/g, "$1")
+    // input = input.replace(/\[(.*?)\]/g, "[$1]")
+    input = input.replace(/(\*\*|__)(.*?)\1/g, "$2")
+    input = input.replace(/(\*|_)(.*?)\1/g, "$2")
+    input = input.replace(/\+\+(.*?)\+\+/g, "$1")
+    input = input.replace(/~~(.*?)~~/g, "$1")
+    input = input.replace(/"([^"]*?)"/g, "$1")
+    input = input.replace(/\n/g, "")
+    input = input.replace(/¶/g, "")
+
+    return input
+}

package/lib/reference.ts

@@ -0,0 +1,205 @@
+import { Bible, Verse } from "./Bible"
+import { getBookName, getBookNumber } from "./get"
+
+// TYPES //
+
+type Reference = {
+    book: number // 1
+    chapter: number // 1
+    verses: number[] // 1, 2, 3
+}
+
+type UniversalReference = {
+    book: number | string // 1 / "GEN" / "Genesis"
+    chapter: number // 1
+    verse?: number // 1
+    verses?: number[] | string // [1, 2, 3] / "1-3"
+}
+
+export type VerseReference = {
+    book: number // 1
+    chapter: number // 1
+    verse: Verse // { number: 1, text: "" }
+    reference: string // "Genesis 1:1"
+    id: string // "1.1.1"
+}
+
+export interface SearchReference extends Reference {
+    autocompleted: string // "Genesis ..."
+    versesContent: Verse[] // [{ text: "", ... }]
+}
+
+// MAIN //
+
+// OUTPUT: "1" | "1.1" | "1.1.1"
+export function getReferenceId(ref: UniversalReference | Reference) {
+    return referenceBuilder(ref as UniversalReference, [".", "."])
+}
+
+// OUTPUT: "Genesis" | "Genesis 1" | "Genesis 1:1"
+export function getReferenceString(ref: UniversalReference | Reference, bible?: Bible) {
+    return referenceBuilder(ref as UniversalReference, [" ", ":"], { bookName: true, bible })
+}
+
+export function getVerseReferences(bible: Bible, ref: Reference | string) {
+    if (!ref) return []
+    if (typeof ref === "string") ref = getReference(ref)
+    let verses = getVersesFromReference(bible, ref)
+    if (!verses.length) verses.push({ number: 0, text: "" })
+
+    let verseReferences: VerseReference[] = verses.map((a) => ({
+        book: ref.book,
+        chapter: ref.chapter,
+        verse: a,
+        reference: getReferenceString({ ...ref, verse: a.number }, bible),
+        id: getReferenceId({ ...ref, verse: a.number })
+    }))
+
+    return verseReferences
+}
+
+// search input
+export function getReferenceFromSearchString(searchRef: string, bible?: Bible) {
+    let { book, chapter, verses } = splitReferenceString(searchRef)
+
+    const reference: Reference = {
+        book: getBookNumber(book, bible),
+        chapter: Number(chapter || 0),
+        verses: verses ? extractVerseReference(verses) : []
+    }
+
+    return { name: book.trim(), reference }
+}
+
+// GETTERS //
+
+function getReference(referenceString: string) {
+    const referenceId = referenceStringToId(referenceString)
+    const split = referenceId.split(".")
+    const ref: Reference = { book: Number(split[0]), chapter: Number(split[1]), verses: extractVerseReference(split[2] || "") }
+    return ref
+}
+
+function referenceBuilder(ref: UniversalReference, [chapterSeperator, verseSeperator]: string[], options: { bookName?: boolean; bible?: Bible } = {}) {
+    const { book, chapter, verses } = parseUniversalReference(ref)
+
+    let reference = ""
+    if (!book) return reference
+
+    reference += `${options.bookName ? getBookName(book, options.bible) : book}`
+    if (!chapter) return reference
+
+    reference += `${chapterSeperator}${chapter}`
+    if (!verses.length) return reference
+
+    reference += `${verseSeperator}${getVerseReference(verses)}`
+    return reference
+}
+
+function parseUniversalReference(ref: UniversalReference) {
+    const book = getBookNumber(ref.book)
+    const chapter = ref.chapter
+    const verses = ref.verse ? [ref.verse] : getVerses(ref.verses || [])
+    return { book, chapter, verses } as Reference
+
+    function getVerses(verses: number[] | string) {
+        if (Array.isArray(verses)) return verses
+        return extractVerseReference(verses)
+    }
+}
+
+// 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 isId = ref.match(regex) !== null
+    if (isId) return parseReferenceId(ref)
+
+    let { book, chapter, verses } = splitReferenceString(ref)
+    return `${getBookNumber(book)}.${chapter}.${verses}`
+
+    function parseReferenceId(ref: string) {
+        const split = ref.split(".")
+        split[0] = getBookNumber(split[0]).toString()
+        return split.join(".")
+    }
+}
+
+// "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 match = ref.match(regex)
+
+    if (!match) return { book: "", chapter: "", verses: "" }
+    const groups = match.groups || {}
+
+    const book = groups.book?.trim() || ""
+    const chapter = groups.chapter || ""
+    const verses = groups.verses || ""
+
+    return { book, chapter, verses }
+}
+
+// VERSE REFERENCE //
+
+// [1, 2, 3] = "1-3" / [4, 2, 7, 1, 9, 10] = "1-2+4+7+9-10"
+function getVerseReference(verses: number[]) {
+    // sort in ascending order
+    verses.sort((a, b) => a - b)
+
+    let verseRef = ""
+    let i = 0
+
+    while (i < verses.length) {
+        // get consecutive verses
+        let start = verses[i]
+        while (i < verses.length - 1 && verses[i] + 1 === verses[i + 1]) i++
+        let end = verses[i]
+
+        // if start and end are the same add the number, if not add the range
+        verseRef += start === end ? `${start}` : `${start}-${end}`
+
+        i++
+
+        // add a '+' if there are more verses
+        if (i < verses.length) verseRef += "+"
+    }
+
+    return verseRef
+}
+
+// "1-3+5" = [1, 2, 3, 5]
+function extractVerseReference(verseRef: string) {
+    const result: number[] = []
+
+    verseRef.split("+").forEach((part) => {
+        if (part.includes("-")) {
+            let [start, end] = part.split("-").filter(Boolean).map(Number)
+
+            // ending in + or -
+            if (isNaN(end)) result.push(start)
+            else {
+                // swap inverted numbers
+                if (start > end) [start, end] = [end, start]
+
+                for (let i = start; i <= end; i++) {
+                    result.push(i)
+                }
+            }
+        } else if (part) {
+            result.push(Number(part))
+        }
+    })
+
+    return result
+}
+
+function getVersesFromReference(bible: Bible, ref: Reference | string) {
+    if (typeof ref === "string") ref = getReference(ref)
+
+    const bookIndex = bible.books.findIndex((a) => a.number === ref.book)
+    const chapterIndex = bible.books[bookIndex]?.chapters.findIndex((a) => a.number === ref.chapter)
+    const verses = (bible.books[bookIndex]?.chapters[chapterIndex]?.verses || []).filter((a) => ref.verses.includes(a.number))
+
+    return verses
+}

package/lib/search.ts

@@ -0,0 +1,122 @@
+import { Bible } from "./Bible"
+import { getBookIndex } from "./get"
+import { getReferenceFromSearchString, getReferenceString, getVerseReferences, SearchReference, VerseReference } from "./reference"
+
+// BOOK SEARCH //
+
+let previousSearch: string = ""
+export function _bookSearch(bible: Bible, searchValue: string) {
+    const returnValue: SearchReference = { autocompleted: searchValue, book: 0, chapter: 0, verses: [], versesContent: [] }
+    if (!searchValue.length) return finish()
+
+    const { name, reference } = getReferenceFromSearchString(searchValue)
+    if (!reference || !name) return finish()
+
+    let books = findBooks(name)
+    if (books.length !== 1) return finish()
+
+    const book = books[0]
+    returnValue.book = book.number
+
+    // autocomplete book name
+    // this will also "disallow" more text input after full book name
+    if (!reference.chapter && previousSearch.length <= searchValue.length) {
+        reference.book = book.number
+        returnValue.autocompleted = getReferenceString(reference, bible) + " "
+        searchValue = returnValue.autocompleted
+    }
+
+    const chapter = findChapter(reference.chapter)
+    if (!chapter) return finish()
+    returnValue.chapter = chapter.number
+
+    const verses = findVerses(reference.verses)
+    returnValue.verses = verses.map(({ number }) => number)
+    returnValue.versesContent = verses
+
+    return finish()
+
+    /////
+
+    function finish() {
+        previousSearch = searchValue
+        return returnValue
+    }
+
+    function findBooks(name: string) {
+        const formatText = (a: string) => a.replace(/\s/g, "").toLowerCase()
+        name = formatText(name)
+
+        let matches = []
+        for (let book of bible.books) {
+            const bookName = formatText(book.name)
+            if (bookName === name) return [book]
+            if (bookName.includes(name)) matches.push(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))
+
+        return matches
+    }
+
+    function findChapter(number: number) {
+        return book.chapters.find((a) => a.number === number)
+    }
+
+    function findVerses(verses: number[]) {
+        return chapter?.verses.filter((a) => verses.includes(a.number)) || []
+    }
+}
+
+// TEXT SEARCH //
+
+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 []
+
+    const cacheId = searchValue + limit + (bookNumber ?? "")
+    if (textSearchCache[cacheId]) return JSON.parse(textSearchCache[cacheId]) as VerseReference[]
+
+    const matches = bibleSearch().slice(0, limit)
+
+    textSearchCache[cacheId] = JSON.stringify(matches)
+    return matches
+
+    /////
+
+    function bibleSearch() {
+        const searchWords = searchValue.split(" ")
+        const books = bookNumber === undefined ? bible.books : [bible.books[getBookIndex(bible, bookNumber)]]
+
+        let matches: VerseReference[] = []
+
+        for (let book of books) {
+            for (let chapter of book.chapters) {
+                let verses: number[] = []
+
+                for (let verse of chapter.verses) {
+                    const verseValue = formatText(verse.text || "")
+
+                    // check if the full verse, or one of the words contains the search value
+                    if (verseValue.includes(searchValue) || searchWords.every((word) => verseValue.includes(word))) {
+                        verses.push(verse.number)
+                    }
+                }
+
+                if (verses.length) {
+                    const reference = getVerseReferences(bible, { book: book.number, chapter: chapter.number, verses })
+                    matches.push(...reference)
+
+                    // return early if we have reached the limit
+                    if (matches.length >= limit) return matches
+                }
+            }
+        }
+
+        return matches
+    }
+}

package/lib/util.ts

@@ -0,0 +1,21 @@
+export function clone<T>(object: T): T {
+    if (typeof object !== "object") return object
+    return JSON.parse(JSON.stringify(object))
+}
+
+export function isNumber(value: any) {
+    return typeof value === "number" || !isNaN(Number(value))
+}
+
+export function stripText(value: string) {
+    if (!value) return ""
+
+    // remove any HTML tags
+    value = value.replace(/<[^>]*>/g, "")
+    // value = value.replace(/(<([^>]+)>)/g, "")
+
+    // remove [1], not [text]
+    value = value.replace(/ *\[[0-9\]]*]/g, "")
+
+    return value
+}

package/package.json

@@ -0,0 +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"
+    }
+}