codexparser 0.1.23 → 0.1.25

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codexparser",
-  "version": "0.1.23",
+  "version": "0.1.25",
   "description": "This is a Javascript Bible parser and text scanner. It will search through texts and collate all scripture references into an array and parse them into objects, and it will parse passages into objects by book, chapter, verse, and testament. ",
   "main": "index.js",
   "scripts": {

package/src/CodexParser.js

@@ -232,6 +232,7 @@ class CodexParser {
 
         this.passages = this.found.map((passage) => {
             const book = this.bookify(passage.book)
+            const testament = this.bible.old.find((bible) => bible === book) ? "old" : "new"
             // Initialize the parsed passage object
             const parsedPassage = {
                 original: passage.book + " " + passage.reference,
@@ -239,9 +240,9 @@ class CodexParser {
                 chapter: null,
                 verses: [], // Verse stored as an array
                 type: null, // Set type based on reference
-                testament: this.bible.old.find((bible) => bible === book) ? "old" : "new",
+                testament: testament,
                 index: passage.index,
-                version: this._handleVersion(passage.version),
+                version: this._handleVersion(passage.version, testament),
             }
 
             // Split reference by commas to handle multiple ranges or verses (e.g., "Ge 27:27-29,39-41")
@@ -504,6 +505,133 @@ class CodexParser {
         }
     }
 
+    /**
+     * Combine multiple passages into one. The method checks for duplicates, merges overlapping or adjacent ranges,
+     * and builds the original and scripture properties.
+     * **This method will always combine based on English versification. LXX and MT versifications will be reflected in the combined passage.passages.versification.**
+     * This method will fail if the passages are not to the same book and chapter.
+     * @param {array} passages - An array of passage objects to combine.
+     * @return {object} The combined passage object.
+     */
+    combine(passages) {
+        const noDuplicates = [...new Set(passages.map((p) => p.book + " " + p.chapter))]
+        if (noDuplicates.length > 1) {
+            throw new Error("Passages are not from the same book and chapter.")
+        }
+        const newPassages = []
+        passages.forEach((passageSet) => {
+            passageSet.passages.forEach((passage) => {
+                if (passage.versification) {
+                    newPassages.push(passage.book + " " + passage.versification.eng)
+                } else {
+                    newPassages.push(passage.book + " " + passage.chapter + ":" + passage.verse)
+                }
+            })
+        })
+        const noDuplicates2 = [...new Set(newPassages)]
+        const parsed = this.parse(noDuplicates2.join(" // ")).getPassages()
+        return this.join(parsed)
+    }
+
+    /**
+     * Combine multiple passages into one. The method checks for duplicates, merges overlapping or adjacent ranges,
+     * and builds the original and scripture properties.
+     *
+     * @param {array} passages - An array of passage objects to combine.
+     * @return {object} The combined passage object.
+     */
+    join(passages) {
+        const newObject = { ...passages[0] }
+
+        for (let i = 1; i < passages.length; i++) {
+            // Combine passages, but check for duplicates
+            passages[i].passages.forEach((passage) => {
+                // Add passage only if it's not already in newObject.passages
+                const isDuplicate = newObject.passages.some(
+                    (p) => p.book === passage.book && p.chapter === passage.chapter && p.verse === passage.verse
+                )
+                if (!isDuplicate) {
+                    newObject.passages = newObject.passages.concat(passage)
+                }
+            })
+            const verses = passages[i].verses
+            for (let j = 0; j < verses.length; j++) {
+                const verse = verses[j]
+                newObject.verses = newObject.verses.concat(verse)
+            }
+        }
+
+        // Remove lone numbers that are part of a range
+        newObject.verses = newObject.verses.filter((v, i, arr) => {
+            if (!v.includes("-")) {
+                const num = parseInt(v, 10)
+                return !arr.some((item) => {
+                    if (item.includes("-")) {
+                        const [start, end] = item.split("-").map(Number)
+                        return num >= start && num <= end
+                    }
+                    return false
+                })
+            }
+            return true // Keep ranges
+        })
+
+        // Convert to a Set to remove duplicates
+        newObject.verses = [...new Set(newObject.verses)]
+
+        // Helper function to merge overlapping or adjacent ranges
+        const mergeRanges = (verses) => {
+            const rangeObjects = verses.map((v) => {
+                if (v.includes("-")) {
+                    const [start, end] = v.split("-").map(Number)
+                    return { start, end }
+                } else {
+                    const num = Number(v)
+                    return { start: num, end: num }
+                }
+            })
+
+            // Sort the ranges by starting number
+            rangeObjects.sort((a, b) => a.start - b.start)
+
+            const merged = []
+            let currentRange = rangeObjects[0]
+
+            for (let i = 1; i < rangeObjects.length; i++) {
+                const nextRange = rangeObjects[i]
+
+                if (currentRange.end >= nextRange.start - 1) {
+                    // Overlapping or adjacent, merge the ranges
+                    currentRange.end = Math.max(currentRange.end, nextRange.end)
+                } else {
+                    // No overlap, push the current range and start a new one
+                    merged.push(currentRange)
+                    currentRange = nextRange
+                }
+            }
+
+            // Push the last range
+            merged.push(currentRange)
+
+            // Convert merged ranges back to strings
+            return merged.map(({ start, end }) => (start === end ? `${start}` : `${start}-${end}`))
+        }
+
+        // Merge and sort the ranges
+        newObject.verses = mergeRanges(newObject.verses)
+
+        // Build the original and scripture properties
+        newObject.original = newObject.book + " " + newObject.chapter + ":" + newObject.verses.join(",")
+        newObject.scripture = {
+            passage: newObject.book + " " + newObject.chapter + ":" + newObject.verses.join(","),
+            cv: newObject.chapter + ":" + newObject.verses.join(","),
+            hash: newObject.book + "_" + newObject.chapter + "." + newObject.verses.join("."),
+        }
+        newObject.scripture.hash = newObject.scripture.hash.toLowerCase()
+
+        return newObject
+    }
+
     _isValid(passage, reference) {
         const singleChapterBook = this.singleChapterBook.find((bible) => bible[passage.book])
         if (!passage.verses) {
@@ -541,11 +669,11 @@ class CodexParser {
         }
         return true
     }
-    _handleVersion(version) {
+    _handleVersion(version, testament) {
         if (!version) {
             return null
         }
-        if (version.toLowerCase() === "lxx") {
+        if (version.toLowerCase() === "lxx" && testament.toLowerCase() === "old") {
             return {
                 name: "Septuagint",
                 value: "LXX",
@@ -553,7 +681,7 @@ class CodexParser {
             }
         }
 
-        if (version.toLowerCase() === "mt") {
+        if (version.toLowerCase() === "mt" && testament.toLowerCase() === "old") {
             return {
                 name: "Masoretic Text",
                 value: "MT",