codexparser 0.1.39 → 0.1.41

package/package.json

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

@@ -248,7 +248,6 @@ class CodexParser {
                 index: passage.index,
                 version: this._handleVersion(passage.version, testament),
             }
-
             const parts = passage.reference.split(",")
             const isSingleChapter = this.singleChapterBook.some((singleChapterBook) => singleChapterBook[book])
 
@@ -316,10 +315,8 @@ class CodexParser {
             parsedPassage.passages = this.populate(parsedPassage)
             parsedPassage.scripture = this.scripturize(parsedPassage)
             parsedPassage.valid = this._isValid(parsedPassage, passage.reference)
-
             return parsedPassage
         })
-
         this.versification()
         return this
     }
@@ -416,6 +413,7 @@ class CodexParser {
     populate(parsedPassage) {
         const passages = []
         const { book, chapter, verses, type } = parsedPassage
+        this._setVersion(parsedPassage)
         if (type === "single_chapter") {
             // Handle single chapter references
             if (this.chapterVerses[book] && this.chapterVerses[book][chapter]) {
@@ -457,16 +455,30 @@ class CodexParser {
                 },
             ]
 
-            // Iterate over the range of chapters and verses
-            for (let i = refs[0].chapter; i <= refs[1].chapter; i++) {
-                const startVerse = i === refs[0].chapter ? refs[0].verse : 1
-                const endVerse = i === refs[1].chapter ? refs[1].verse : this.chapterVerses[book][i].length
+            const startChapter = refs[0].chapter
+            const startVerse = refs[0].verse
+            const endChapter = refs[refs.length - 1].chapter
+            const endVerse = refs[refs.length - 1].verse
+
+            // Loop through the range of chapters
+            for (let chapter = startChapter; chapter <= endChapter; chapter++) {
+                // Determine the starting verse for the current chapter
+                const chapterStartVerse = chapter === startChapter ? startVerse : 1
+                // Determine the ending verse for the current chapter
+                const chapterEndVerse = chapter === endChapter ? endVerse : this.chapterVerses[book][chapter].length
+
+                // Get the array of verses for the current chapter
+                const verses = this.chapterVerses[book][chapter].slice(chapterStartVerse - 1, chapterEndVerse)
 
-                for (let j = startVerse; j <= endVerse; j++) {
+                // Loop through the verses in the current chapter
+                for (let j = 0; j < verses.length; j++) {
+                    const currentVerse = chapterStartVerse + j
+
+                    // Add the verse to the passages array
                     passages.push({
                         book,
-                        chapter: i,
-                        verse: j,
+                        chapter,
+                        verse: currentVerse,
                     })
                 }
             }
@@ -545,49 +557,63 @@ class CodexParser {
      * @return {object} The object with the human-readable name, chapter and verses and a hash.
      */
     scripturize(passage) {
-        const { book, chapter, passages } = passage
+        const { book, chapter, passages, to } = passage
 
         // Extract verses from the passages array
-        const verses = passages.map((p) => p.verse)
+        const verses = passages.map((p) => ({ chapter: p.chapter, verse: p.verse }))
         let formattedVerses = ""
 
-        if (verses.length === 1) {
-            // If there is only one verse
-            formattedVerses = verses[0].toString()
-        } else if (verses.length === 2 && verses[1] === verses[0] + 1) {
-            // If there are exactly two verses and they are consecutive, use a comma
-            formattedVerses = `${verses[0]},${verses[1]}`
+        if (to && to.chapter && to.chapter !== chapter) {
+            // Handle multi-chapter range
+            const startChapter = chapter
+            const startVerses = verses.filter((v) => v.chapter === startChapter).map((v) => v.verse)
+
+            const endChapter = to.chapter
+            const endVerses = verses.filter((v) => v.chapter === endChapter).map((v) => v.verse)
+
+            const startFormatted =
+                startVerses.length > 1 ? `${startVerses[0]}-${startVerses[startVerses.length - 1]}` : startVerses[0]
+
+            const endFormatted =
+                endVerses.length > 1 ? `${endVerses[0]}-${endVerses[endVerses.length - 1]}` : endVerses[0]
+
+            formattedVerses = `${startChapter}:${startFormatted}-${endChapter}:${endFormatted}`
         } else {
-            // For more than two verses, or non-consecutive verses
-            let ranges = []
-            let tempRange = [verses[0]]
-
-            for (let i = 1; i < verses.length; i++) {
-                if (verses[i] === verses[i - 1] + 1) {
-                    // If the verse is consecutive, add to tempRange
-                    tempRange.push(verses[i])
-                } else {
-                    // If not consecutive, finalize tempRange
-                    ranges.push(tempRange)
-                    tempRange = [verses[i]]
+            // Handle single-chapter range
+            const startVerses = verses.map((v) => v.verse)
+
+            if (startVerses.length === 1) {
+                formattedVerses = startVerses[0].toString()
+            } else {
+                // Group consecutive verses into ranges
+                let ranges = []
+                let tempRange = [startVerses[0]]
+
+                for (let i = 1; i < startVerses.length; i++) {
+                    if (startVerses[i] === startVerses[i - 1] + 1) {
+                        tempRange.push(startVerses[i])
+                    } else {
+                        ranges.push(tempRange)
+                        tempRange = [startVerses[i]]
+                    }
                 }
+                ranges.push(tempRange)
+
+                formattedVerses = ranges
+                    .map((range) => (range.length > 1 ? `${range[0]}-${range[range.length - 1]}` : range[0]))
+                    .join(",")
             }
-            ranges.push(tempRange) // Push the last range
 
-            // Format ranges: convert consecutive numbers to ranges, non-consecutive remain separate
-            formattedVerses = ranges
-                .map((range) => (range.length > 1 ? `${range[0]}-${range[range.length - 1]}` : range[0]))
-                .join(",")
+            formattedVerses = `${chapter}:${formattedVerses}`
         }
 
         // Format the final passage
-        const colon = formattedVerses ? ":" : ""
-        const full = `${book} ${chapter}${colon}${formattedVerses}`.trim()
+        const full = `${book} ${formattedVerses}`.trim()
         const hash = full.toLowerCase().replace(/ /g, "_").replace(/:/g, ".").replace(/-/g, ".").replace(/,/g, ".")
 
         return {
             passage: full,
-            cv: `${chapter}${colon}${formattedVerses}`,
+            cv: formattedVerses,
             hash,
         }
     }
@@ -612,7 +638,7 @@ class CodexParser {
         passages.forEach((passageSet) => {
             passageSet.passages.forEach((passage) => {
                 if (passage.versification) {
-                    newPassages.push(passage.book + " " + passage.versification.eng)
+                    newPassages.push(passage.book + " " + passage.versification[this.version])
                 } else {
                     newPassages.push(passage.book + " " + passage.chapter + ":" + passage.verse)
                 }