codexparser 0.1.29 → 0.1.31

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codexparser",
-  "version": "0.1.29",
+  "version": "0.1.31",
   "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

@@ -476,7 +476,20 @@ class CodexParser {
      * @return {array} The passages stored in the object.
      */
     getPassages() {
-        return this.passages
+        // Return the array of passages and add a custom first() method to it
+        const passagesArray = [...this.passages] // Clone the array to avoid mutation
+
+        // Add first() method directly to the array
+        passagesArray.first = function () {
+            return this.length > 0 ? this[0] : null
+        }
+
+        return passagesArray
+    }
+
+    // New first() method that can be chained after getPassages()
+    first() {
+        return this.passages.length > 0 ? this.passages[0] : null
     }
 
     /**
@@ -572,96 +585,113 @@ class CodexParser {
      * @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)
-            }
-        }
+        const newObject = { ...passages[0] } // Start with the first passage
 
-        // 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
+        const chapters = {} // Store verses by chapters
+        const uniquePassages = new Set() // Track unique passages to prevent duplicates
+
+        // Add initial passages to the unique set to avoid duplication
+        newObject.passages.forEach((p) => {
+            const passageKey = `${p.book}-${p.chapter}-${p.verse}`
+            uniquePassages.add(passageKey)
         })
 
-        // Convert to a Set to remove duplicates
-        newObject.verses = [...new Set(newObject.verses)]
+        // Iterate through all the passages and group verses by chapter
+        passages.forEach((passage) => {
+            if (!chapters[passage.chapter]) {
+                chapters[passage.chapter] = new Set() // Use Set to avoid duplicates
+            }
+
+            // Add verses to their corresponding chapter
+            passage.passages.forEach((p) => {
+                chapters[p.chapter].add(p.verse)
 
-        // 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 }
+                // Create a unique key for each passage (book-chapter-verse)
+                const passageKey = `${p.book}-${p.chapter}-${p.verse}`
+
+                // Add to the passages array if it hasn't been added yet
+                if (!uniquePassages.has(passageKey)) {
+                    newObject.passages.push(p) // Add the passage
+                    uniquePassages.add(passageKey) // Mark it as added
                 }
             })
+        })
 
-            // Sort the ranges by starting number
-            rangeObjects.sort((a, b) => a.start - b.start)
+        // Prepare to build the final result
+        const chapterStrings = []
+        let firstChapter = null
+        let lastChapter = null
 
-            const merged = []
-            let currentRange = rangeObjects[0]
+        for (const chapter in chapters) {
+            const verses = Array.from(chapters[chapter]).sort((a, b) => a - b)
+            const mergedVerses = this.mergeRanges(verses) // Merge adjacent verses into ranges
+            chapterStrings.push(`${chapter}:${mergedVerses.join(",")}`)
 
-            for (let i = 1; i < rangeObjects.length; i++) {
-                const nextRange = rangeObjects[i]
+            // Track the first and last chapters for the 'to' key
+            if (!firstChapter) firstChapter = Number(chapter) // Ensure chapter is a number
+            lastChapter = Number(chapter) // Always update to the current chapter as a number
 
-                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
-                }
+            // Update the newObject.verses with the merged ranges for the current chapter
+            if (Number(chapter) === firstChapter) {
+                newObject.verses = mergedVerses
             }
+        }
 
-            // Push the last range
-            merged.push(currentRange)
+        // Build the final combined object with `to` key for multi-chapter passages
+        newObject.original = `${newObject.book} ${firstChapter}:${newObject.verses.join(",")}`
 
-            // Convert merged ranges back to strings
-            return merged.map(({ start, end }) => (start === end ? `${start}` : `${start}-${end}`))
+        if (firstChapter !== lastChapter) {
+            newObject.to = {
+                book: newObject.book,
+                chapter: lastChapter,
+                verses: this.mergeRanges(Array.from(chapters[lastChapter])), // Ensure merged range
+            }
         }
 
-        // 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(",")
+        // Build the scripture string with combined chapters (without spaces after commas)
+        const chapterString = chapterStrings.join(",") // No space after comma
         newObject.scripture = {
-            passage: newObject.book + " " + newObject.chapter + ":" + newObject.verses.join(","),
-            cv: newObject.chapter + ":" + newObject.verses.join(","),
-            hash: newObject.book + "_" + newObject.chapter + "." + newObject.verses.join("."),
+            passage: `${newObject.book} ${chapterString}`,
+            cv: chapterString,
+            hash: `${newObject.book.toLowerCase()}_${chapterString.replace(/:/g, ".").replace(/,/g, ".")}`,
         }
-        newObject.scripture.hash = newObject.scripture.hash.toLowerCase()
 
         return newObject
     }
+    mergeRanges(verses) {
+        const sortedVerses = [...new Set(verses)].sort((a, b) => a - b)
+        const merged = []
+        let start = sortedVerses[0]
+        let end = sortedVerses[0]
+
+        for (let i = 1; i < sortedVerses.length; i++) {
+            if (sortedVerses[i] === end + 1) {
+                end = sortedVerses[i]
+            } else {
+                // Push the current range if it's more than 2 consecutive numbers, otherwise separate by commas
+                if (start === end) {
+                    merged.push(`${start}`)
+                } else if (end === start + 1) {
+                    merged.push(`${start},${end}`)
+                } else {
+                    merged.push(`${start}-${end}`)
+                }
+                start = sortedVerses[i]
+                end = sortedVerses[i]
+            }
+        }
+
+        // Push the final range or pair
+        if (start === end) {
+            merged.push(`${start}`)
+        } else if (end === start + 1) {
+            merged.push(`${start},${end}`)
+        } else {
+            merged.push(`${start}-${end}`)
+        }
+
+        return merged
+    }
 
     _isValid(passage, reference) {
         const singleChapterBook = this.singleChapterBook.find((bible) => bible[passage.book])