node-sword-interface 1.0.99 → 1.0.101

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-sword-interface",
-  "version": "1.0.99",
+  "version": "1.0.101",
   "description": "Javascript (N-API) interface to SWORD library",
   "keywords": [
     "C++",

package/src/sword_backend/text_processor.cpp

@@ -71,7 +71,7 @@ string TextProcessor::getFileUrl(const string& nativePath)
 #endif
 }
 
-string TextProcessor::getFilteredText(const string& text, int chapter, int verseNr, bool hasStrongs, bool hasInconsistentClosingEndDivs, const string& moduleDataPath)
+string TextProcessor::getFilteredText(const string& text, int chapter, int verseNr, bool hasStrongs, bool hasInconsistentClosingEndDivs, const string& moduleFileUrl)
 {
     static string chapterFilter = "<chapter";
     static regex pbElement = regex("<pb .*?/> ");
@@ -244,18 +244,17 @@ string TextProcessor::getFilteredText(const string& text, int chapter, int verse
         filteredText = this->replaceSpacesInStrongs(filteredText);
     }
 
-    // Prefix img src attributes starting with "/" with the module data path as a file:// URL
-    if (!moduleDataPath.empty()) {
-        string fileUrl = this->getFileUrl(moduleDataPath);
+    // Prefix img src attributes starting with "/" with the module file URL
+    if (!moduleFileUrl.empty()) {
         static string imgSrcSlash = "src=\"/";
-        string imgSrcReplacement = "src=\"" + fileUrl + "/";
+        string imgSrcReplacement = "src=\"" + moduleFileUrl + "/";
         this->findAndReplaceAll(filteredText, imgSrcSlash, imgSrcReplacement);
     }
 
     return filteredText;
 }
 
-string TextProcessor::getCurrentChapterHeading(sword::SWModule* module)
+string TextProcessor::getCurrentChapterHeading(sword::SWModule* module, const string& moduleFileUrl)
 {
     string currentModuleName = string(module->getName());
     string chapterHeading = "";
@@ -288,15 +287,62 @@ string TextProcessor::getCurrentChapterHeading(sword::SWModule* module)
             // Therefore we do not render chapter headings for the first verse of the chapter in this case.
             chapterHeading = "";
         } else {
-            string moduleDataPath = this->_moduleStore.getModuleDataPath(module);
-            chapterHeading = this->getFilteredText(chapterHeading, currentChapter, currentVerseNr, false, false, moduleDataPath);
+            chapterHeading = this->getFilteredText(chapterHeading, currentChapter, currentVerseNr, false, false, moduleFileUrl);
         }
     }
 
     return chapterHeading;
 }
 
+string TextProcessor::getCurrentPreverseHeading(sword::SWModule* module, const string& moduleFileUrl)
+{
+    string preverse = "";
+    VerseKey currentVerseKey = module->getKey();
+    int currentChapter = currentVerseKey.getChapter();
+    int currentVerseNr = currentVerseKey.getVerse();
+
+    // First, we need to access the rendered text to populate entry attributes
+    // The entry attributes are only available after rendering/stripping
+    module->renderText();
+
+    // Get the entry attributes map
+    sword::AttributeTypeList& attributes = module->getEntryAttributes();
+
+    // Look for Heading/Preverse entries (indexed 0, 1, 2, ...)
+    auto headingIt = attributes.find("Heading");
+    if (headingIt != attributes.end()) {
+        auto preverseIt = headingIt->second.find("Preverse");
+        if (preverseIt != headingIt->second.end()) {
+            // Iterate through all preverse entries (0, 1, 2, ...)
+            for (auto& entry : preverseIt->second) {
+                string preverseContent = string(entry.second.c_str());
+                StringHelper::trim(preverseContent);
+                
+                if (!preverseContent.empty()) {
+                    // Render the preverse content through the module
+                    sword::SWBuf renderedBuf = module->renderText(preverseContent.c_str());
+                    string rendered = string(renderedBuf.c_str());
+                    
+                    if (this->_markupEnabled && !this->_rawMarkupEnabled) {
+                        rendered = this->getFilteredText(rendered, currentChapter, currentVerseNr, false, false, moduleFileUrl);
+                    }
+                    
+                    preverse += rendered;
+                }
+            }
+        }
+    }
+
+    return preverse;
+}
+
 string TextProcessor::getCurrentVerseText(sword::SWModule* module, bool hasStrongs, bool hasInconsistentClosingEndDivs, bool forceNoMarkup)
+{
+    string moduleFileUrl = this->getFileUrl(this->_moduleStore.getModuleDataPath(module));
+    return this->getCurrentVerseText(module, hasStrongs, hasInconsistentClosingEndDivs, forceNoMarkup, moduleFileUrl);
+}
+
+string TextProcessor::getCurrentVerseText(sword::SWModule* module, bool hasStrongs, bool hasInconsistentClosingEndDivs, bool forceNoMarkup, const string& moduleFileUrl)
 {
     string verseText;
     string filteredText;
@@ -310,8 +356,7 @@ string TextProcessor::getCurrentVerseText(sword::SWModule* module, bool hasStron
         filteredText = verseText;
 
         if (!this->_rawMarkupEnabled) {
-            string moduleDataPath = this->_moduleStore.getModuleDataPath(module);
-            filteredText = this->getFilteredText(verseText, currentChapter, currentVerseNr, hasStrongs, hasInconsistentClosingEndDivs, moduleDataPath);
+            filteredText = this->getFilteredText(verseText, currentChapter, currentVerseNr, hasStrongs, hasInconsistentClosingEndDivs, moduleFileUrl);
         }
     } else {
         verseText = string(module->stripText());
@@ -394,6 +439,9 @@ vector<Verse> TextProcessor::getVersesFromReferences(string moduleName, vector<s
     bool moduleMarkupIsBroken = this->_moduleHelper.isBrokenMarkupModule(moduleName);
     bool hasInconsistentClosingEndDivs = this->_moduleHelper.isInconsistentClosingEndDivModule(moduleName);
 
+    // Compute file URL once for the entire module
+    string moduleFileUrl = this->getFileUrl(this->_moduleStore.getModuleDataPath(module));
+
     for (unsigned int i = 0; i < references.size(); i++) {
         string currentReference = references[i];
         string currentVerseText = "";
@@ -402,7 +450,13 @@ vector<Verse> TextProcessor::getVersesFromReferences(string moduleName, vector<s
         bool entryExisting = module->hasEntry(module->getKey());
 
         if (entryExisting) {
-          currentVerseText = this->getCurrentVerseText(module, false, hasInconsistentClosingEndDivs, moduleMarkupIsBroken);
+          // Add preverse heading before verse text
+          if (!moduleMarkupIsBroken) {
+              string preverseHeading = this->getCurrentPreverseHeading(module, moduleFileUrl);
+              currentVerseText += preverseHeading;
+          }
+          
+          currentVerseText += this->getCurrentVerseText(module, false, hasInconsistentClosingEndDivs, moduleMarkupIsBroken, moduleFileUrl);
         }
 
         Verse currentVerse;
@@ -450,6 +504,9 @@ vector<Verse> TextProcessor::getText(string moduleName, string key, QueryLimit q
     } else {
         bool hasStrongs = this->_moduleHelper.moduleHasGlobalOption(module, "Strongs");
 
+        // Compute file URL once for the entire module
+        string moduleFileUrl = this->getFileUrl(this->_moduleStore.getModuleDataPath(module));
+
         module->setKey(key.c_str());
 
         if (startVerseNumber >= 1) {
@@ -486,17 +543,25 @@ vector<Verse> TextProcessor::getText(string moduleName, string key, QueryLimit q
             // and if the module markup is not broken
             // and if the requested verse count is more than one or the default (-1 / all verses).
             if (firstVerseInChapter && !moduleMarkupIsBroken && (verseCount > 1 || verseCount == -1)) {
-                string chapterHeading = this->getCurrentChapterHeading(module);
+                string chapterHeading = this->getCurrentChapterHeading(module, moduleFileUrl);
                 verseText += chapterHeading;
             }
 
+            // Preverse heading (introductory material attached to this verse via entry attributes)
+            // This includes intro images and other material that should appear before the verse text
+            if (!moduleMarkupIsBroken) {
+                string preverseHeading = this->getCurrentPreverseHeading(module, moduleFileUrl);
+                verseText += preverseHeading;
+            }
+
             // Current verse text
             verseText += this->getCurrentVerseText(module,
                                                    hasStrongs,
                                                    hasInconsistentClosingEndDivs,
                                                    // Note that if markup is broken this will enforce
                                                    // the usage of the "stripped" / non-markup variant of the text
-                                                   moduleMarkupIsBroken);
+                                                   moduleMarkupIsBroken,
+                                                   moduleFileUrl);
 
             // If the current verse does not have any content and if it is the first verse in this book
             // we assume that the book is not existing.
@@ -559,12 +624,11 @@ string TextProcessor::getBookIntroduction(string moduleName, string bookCode)
         filteredText = regex_replace(filteredText, headEndElementFilter, "</div>");
         filteredText = regex_replace(filteredText, chapterDivFilter, "");
 
-        // Prefix img src attributes starting with "/" with the module data path as a file:// URL
-        string moduleDataPath = this->_moduleStore.getModuleDataPath(module);
-        if (!moduleDataPath.empty()) {
-            string fileUrl = this->getFileUrl(moduleDataPath);
+        // Prefix img src attributes starting with "/" with the module file URL
+        string moduleFileUrl = this->getFileUrl(this->_moduleStore.getModuleDataPath(module));
+        if (!moduleFileUrl.empty()) {
             static string imgSrcSlash = "src=\"/";
-            string imgSrcReplacement = "src=\"" + fileUrl + "/";
+            string imgSrcReplacement = "src=\"" + moduleFileUrl + "/";
             this->findAndReplaceAll(filteredText, imgSrcSlash, imgSrcReplacement);
         }
     }

package/src/sword_backend/text_processor.hpp

@@ -63,8 +63,10 @@ private:
                                int startVerseNr=-1,
                                int verseCount=-1);
 
-    std::string getCurrentChapterHeading(sword::SWModule* module);
-    std::string getFilteredText(const std::string& text, int chapter, int verseNr, bool hasStrongs=false, bool hasInconsistentClosingEndDivs=false, const std::string& moduleDataPath="");
+    std::string getCurrentChapterHeading(sword::SWModule* module, const std::string& moduleFileUrl);
+    std::string getCurrentPreverseHeading(sword::SWModule* module, const std::string& moduleFileUrl);
+    std::string getCurrentVerseText(sword::SWModule* module, bool hasStrongs, bool hasInconsistentClosingEndDivs, bool forceNoMarkup, const std::string& moduleFileUrl);
+    std::string getFilteredText(const std::string& text, int chapter, int verseNr, bool hasStrongs, bool hasInconsistentClosingEndDivs, const std::string& moduleFileUrl);
     std::string getFileUrl(const std::string& nativePath);
     std::string replaceSpacesInStrongs(const std::string& text);
     unsigned int findAndReplaceAll(std::string & data, std::string toSearch, std::string replaceStr);