node-sword-interface 1.0.111 → 1.0.113

package/API.md

@@ -49,6 +49,7 @@ This is the main class of node-sword-interface and it provides a set of static f
     * [.refreshLocalModules()](#NodeSwordInterface+refreshLocalModules)
     * [.saveModuleUnlockKey(moduleCode, key)](#NodeSwordInterface+saveModuleUnlockKey)
     * [.isModuleReadable(moduleCode)](#NodeSwordInterface+isModuleReadable) ⇒ <code>Boolean</code>
+    * [.mapVerseReference(sourceOsisRef, sourceModuleName, targetModuleName, [allowRange])](#NodeSwordInterface+mapVerseReference) ⇒ <code>String</code>
     * [.getModuleDescription(repositoryName, moduleCode)](#NodeSwordInterface+getModuleDescription) ⇒ <code>String</code>
     * [.enableMarkup()](#NodeSwordInterface+enableMarkup)
     * [.disableMarkup()](#NodeSwordInterface+disableMarkup)
@@ -311,6 +312,21 @@ Checks whether the module is readable.
 | --- | --- | --- |
 | moduleCode | <code>String</code> | The module code of the SWORD module. |
 
+<a name="NodeSwordInterface+mapVerseReference"></a>
+
+### nodeSwordInterface.mapVerseReference(sourceOsisRef, sourceModuleName, targetModuleName, [allowRange]) ⇒ <code>String</code>
+Maps a verse reference from one module's versification to another module's versification.
+
+**Kind**: instance method of [<code>NodeSwordInterface</code>](#NodeSwordInterface)  
+**Returns**: <code>String</code> - The mapped OSIS reference in the target module's versification.  
+
+| Param | Type | Default | Description |
+| --- | --- | --- | --- |
+| sourceOsisRef | <code>String</code> |  | The OSIS reference in the source module's versification (e.g. "Ps.13.1"). |
+| sourceModuleName | <code>String</code> |  | The module code of the source SWORD module. |
+| targetModuleName | <code>String</code> |  | The module code of the target SWORD module. |
+| [allowRange] | <code>Boolean</code> | <code>false</code> | If true, may return a verse range (e.g. "Ps.50.1-Ps.50.3"). If false, returns only the first verse of a possible range. |
+
 <a name="NodeSwordInterface+getModuleDescription"></a>
 
 ### nodeSwordInterface.getModuleDescription(repositoryName, moduleCode) ⇒ <code>String</code>
@@ -352,11 +368,11 @@ If no entry exists for the given key the return value is undefined.
 
 **Kind**: instance method of [<code>NodeSwordInterface</code>](#NodeSwordInterface)  
 
-| Param | Type | Description |
-| --- | --- | --- |
-| moduleCode | <code>String</code> | The module code of the SWORD module. |
-| key | <code>String</code> | The key of the entry. |
-| processImageUrls | <code>Boolean</code> | Whether to pre-process image URLs with platform-specific file paths (Optional, default: false). |
+| Param | Type | Default | Description |
+| --- | --- | --- | --- |
+| moduleCode | <code>String</code> |  | The module code of the SWORD module. |
+| key | <code>String</code> |  | The key of the entry. |
+| processImageUrls | <code>Boolean</code> | <code>false</code> | Whether to pre-process image URLs with platform-specific file paths (Optional, default: false). |
 
 <a name="NodeSwordInterface+getReferenceText"></a>
 

package/index.js

@@ -342,6 +342,19 @@ class NodeSwordInterface {
     return this.nativeInterface.isModuleReadable(moduleCode);
   }
 
+  /**
+   * Maps a verse reference from one module's versification to another module's versification.
+   *
+   * @param {String} sourceOsisRef - The OSIS reference in the source module's versification (e.g. "Ps.13.1").
+   * @param {String} sourceModuleName - The module code of the source SWORD module.
+   * @param {String} targetModuleName - The module code of the target SWORD module.
+   * @param {Boolean} [allowRange=false] - If true, may return a verse range (e.g. "Ps.50.1-Ps.50.3"). If false, returns only the first verse of a possible range.
+   * @return {String} The mapped OSIS reference in the target module's versification.
+   */
+  mapVerseReference(sourceOsisRef, sourceModuleName, targetModuleName, allowRange = false) {
+    return this.nativeInterface.mapVerseReference(sourceOsisRef, sourceModuleName, targetModuleName, allowRange);
+  }
+
   /**
    * Returns the description of a module.
    *

package/package.json

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

package/src/napi_module/node_sword_interface.cpp

@@ -114,6 +114,7 @@ Napi::Object NodeSwordInterface::Init(Napi::Env env, Napi::Object exports)
         InstanceMethod("refreshLocalModules", &NodeSwordInterface::refreshLocalModules),
         InstanceMethod("saveModuleUnlockKey", &NodeSwordInterface::saveModuleUnlockKey),
         InstanceMethod("isModuleReadable", &NodeSwordInterface::isModuleReadable),
+        InstanceMethod("mapVerseReference", &NodeSwordInterface::mapVerseReference),
         InstanceMethod("getSwordTranslation", &NodeSwordInterface::getSwordTranslation),
         InstanceMethod("getBookAbbreviation", &NodeSwordInterface::getBookAbbreviation),
         InstanceMethod("getSwordVersion", &NodeSwordInterface::getSwordVersion),
@@ -375,6 +376,10 @@ ModuleType NodeSwordInterface::getModuleTypeFromString(std::string moduleTypeStr
         return ModuleType::dict;
     } else if (moduleTypeString == "COMMENTARY") {
         return ModuleType::commentary;
+    } else if (moduleTypeString == "IMAGES") {
+        return ModuleType::images;
+    } else if (moduleTypeString == "MAPS") {
+        return ModuleType::maps;
     } else {
         return ModuleType::any;
     }
@@ -1095,6 +1100,43 @@ Napi::Value NodeSwordInterface::getSwordPath(const Napi::CallbackInfo& info)
     return swordPath;
 }
 
+Napi::Value NodeSwordInterface::mapVerseReference(const Napi::CallbackInfo& info)
+{
+    lockApi();
+    Napi::Env env = info.Env();
+    Napi::HandleScope scope(env);
+
+    if (info.Length() < 3 || info.Length() > 4) {
+        Napi::TypeError::New(env, "Expected 3 or 4 parameters!").ThrowAsJavaScriptException();
+        unlockApi();
+        return env.Null();
+    }
+    if (!info[0].IsString() || !info[1].IsString() || !info[2].IsString()) {
+        Napi::TypeError::New(env, "First 3 arguments must be strings!").ThrowAsJavaScriptException();
+        unlockApi();
+        return env.Null();
+    }
+
+    Napi::String sourceOsisRef = info[0].As<Napi::String>();
+    Napi::String sourceModuleName = info[1].As<Napi::String>();
+    Napi::String targetModuleName = info[2].As<Napi::String>();
+
+    bool allowRange = false;
+    if (info.Length() == 4) {
+        if (!info[3].IsBoolean()) {
+            Napi::TypeError::New(env, "Boolean expected for argument 4").ThrowAsJavaScriptException();
+            unlockApi();
+            return env.Null();
+        }
+        allowRange = info[3].As<Napi::Boolean>().Value();
+    }
+
+    string result = this->_textProcessor->mapVerseReference(sourceOsisRef, sourceModuleName, targetModuleName, allowRange);
+
+    unlockApi();
+    return Napi::String::New(env, result);
+}
+
 Napi::Value NodeSwordInterface::unTarGZ(const Napi::CallbackInfo& info)
 {
     Napi::Env env = info.Env();

package/src/napi_module/node_sword_interface.hpp

@@ -98,6 +98,8 @@ private:
     Napi::Value isModuleReadable(const Napi::CallbackInfo& info);
     Napi::Value refreshLocalModules(const Napi::CallbackInfo& info);
 
+    Napi::Value mapVerseReference(const Napi::CallbackInfo& info);
+
     Napi::Value getSwordTranslation(const Napi::CallbackInfo& info);
     Napi::Value getBookAbbreviation(const Napi::CallbackInfo& info);
     Napi::Value getSwordVersion(const Napi::CallbackInfo& info);

package/src/node_sword_cli.cpp

@@ -191,6 +191,111 @@ void get_strongs_entry(TextProcessor& text_processor)
     }
 }
 
+void install_if_missing(ModuleInstaller& module_installer, ModuleStore& module_store, const string& repo, const string& moduleName)
+{
+    SWModule* m = module_store.getLocalModule(moduleName);
+    if (m == 0) {
+        cout << "Installing module " << moduleName << " from " << repo << " ..." << endl;
+        int error = module_installer.installModule(repo, moduleName);
+        if (error) {
+            cout << "  ERROR: Failed to install " << moduleName << endl;
+        } else {
+            cout << "  Successfully installed " << moduleName << endl;
+            module_store.refreshMgr();
+        }
+    } else {
+        cout << "Module " << moduleName << " already installed." << endl;
+    }
+}
+
+void test_verse_reference_mapping(ModuleInstaller& module_installer, ModuleStore& module_store, TextProcessor& text_processor)
+{
+    cout << "=== Verse Reference Mapping Test ===" << endl;
+
+    // Install required modules for the tests
+    // KJV uses KJV versification
+    install_if_missing(module_installer, module_store, "CrossWire", "KJV");
+    // RusSynodal uses Synodal versification
+    install_if_missing(module_installer, module_store, "CrossWire", "RusSynodal");
+    // VulgClementine uses Vulg versification
+    install_if_missing(module_installer, module_store, "CrossWire", "VulgClementine");
+
+    cout << endl;
+
+    // Test 1: Same versification (should return unchanged)
+    string result1 = text_processor.mapVerseReference("Gen.1.1", "KJV", "KJV");
+    cout << "KJV Gen.1.1 -> KJV: " << result1 << endl;
+
+    // Test 2: KJV to Synodal (Psalm numbering and superscription shift)
+    string result2 = text_processor.mapVerseReference("Ps.13.1", "KJV", "RusSynodal");
+    cout << "KJV Ps.13.1 -> RusSynodal (Synodal): " << result2 << endl;
+
+    // Test 3: KJV to Vulg (Psalm 51 -> Psalm 50, default allowRange=false returns first verse only)
+    string result3 = text_processor.mapVerseReference("Ps.51.1", "KJV", "VulgClementine");
+    cout << "KJV Ps.51.1 -> VulgClementine (Vulg, no range): " << result3 << endl;
+
+    // Test 3b: Same mapping with allowRange=true (returns full range)
+    string result3b = text_processor.mapVerseReference("Ps.51.1", "KJV", "VulgClementine", true);
+    cout << "KJV Ps.51.1 -> VulgClementine (Vulg, with range): " << result3b << endl;
+
+    // Test 3c: Reverse - take the second verse of the range (Ps.50.3) and map back to KJV
+    string result3c = text_processor.mapVerseReference("Ps.50.3", "VulgClementine", "KJV");
+    cout << "VulgClementine Ps.50.3 -> KJV: " << result3c << endl;
+
+    // Test 4: Synodal to KJV (reverse mapping)
+    string result4 = text_processor.mapVerseReference("Ps.12.2", "RusSynodal", "KJV");
+    cout << "RusSynodal Ps.12.2 -> KJV: " << result4 << endl;
+
+    // Test 5: Synodal to Vulg (non-KJV to non-KJV, routes through KJVA hub)
+    string result5 = text_processor.mapVerseReference("Ps.50.1", "RusSynodal", "VulgClementine");
+    cout << "RusSynodal Ps.50.1 -> VulgClementine (Vulg): " << result5 << endl;
+
+    // --- NT mapping tests ---
+    cout << endl << "--- NT Mapping Tests ---" << endl;
+
+    // Test 6: KJV Rev.13.1 -> Vulg (default: first verse only)
+    string result6 = text_processor.mapVerseReference("Rev.13.1", "KJV", "VulgClementine");
+    cout << "KJV Rev.13.1 -> VulgClementine (Vulg, no range): " << result6 << endl;
+
+    // Test 6b: Same with allowRange=true
+    string result6b = text_processor.mapVerseReference("Rev.13.1", "KJV", "VulgClementine", true);
+    cout << "KJV Rev.13.1 -> VulgClementine (Vulg, with range): " << result6b << endl;
+
+    // Test 6c: Reverse - take the second verse of the range (Rev.12.19) and map back to KJV
+    string result6c = text_processor.mapVerseReference("Rev.12.19", "VulgClementine", "KJV");
+    cout << "VulgClementine Rev.12.19 -> KJV: " << result6c << endl;
+
+    // Test 7: KJV Mark.9.1 -> Vulg (Vulg has Mark 9:1 as Mark 8:39)
+    string result7 = text_processor.mapVerseReference("Mark.9.1", "KJV", "VulgClementine");
+    cout << "KJV Mark.9.1 -> VulgClementine (Vulg): " << result7 << endl;
+
+    // Test 8: KJV Acts.19.41 -> Vulg (Vulg merges Acts 19:40-41)
+    string result8 = text_processor.mapVerseReference("Acts.19.41", "KJV", "VulgClementine");
+    cout << "KJV Acts.19.41 -> VulgClementine (Vulg): " << result8 << endl;
+
+    // Test 9: KJV 3John.1.14 -> Synodal (default: first verse only)
+    string result9 = text_processor.mapVerseReference("3John.1.14", "KJV", "RusSynodal");
+    cout << "KJV 3John.1.14 -> RusSynodal (Synodal, no range): " << result9 << endl;
+
+    // Test 9b: Same with allowRange=true (Synodal splits 3 John 1:14 into 14-15)
+    string result9b = text_processor.mapVerseReference("3John.1.14", "KJV", "RusSynodal", true);
+    cout << "KJV 3John.1.14 -> RusSynodal (Synodal, with range): " << result9b << endl;
+
+    // Test 9c: Reverse - take the second verse of the range (3John.1.15) and map back to KJV
+    string result9c = text_processor.mapVerseReference("3John.1.15", "RusSynodal", "KJV");
+    cout << "RusSynodal 3John.1.15 -> KJV: " << result9c << endl;
+
+    // Test 10: KJV Rom.16.25 -> Synodal (Synodal moves the doxology to Rom.14.24)
+    string result10 = text_processor.mapVerseReference("Rom.16.25", "KJV", "RusSynodal");
+    cout << "KJV Rom.16.25 -> RusSynodal (Synodal): " << result10 << endl;
+
+    // Test 11: KJV Mark.4.41 -> Vulg (Vulg merges Mark 4:40-41 into one verse)
+    string result11 = text_processor.mapVerseReference("Mark.4.41", "KJV", "VulgClementine");
+    cout << "KJV Mark.4.41 -> VulgClementine (Vulg): " << result11 << endl;
+
+    cout << "=== End of Mapping Test ===" << endl;
+}
+
 int main(int argc, char** argv)
 {
     ModuleStore moduleStore;
@@ -218,7 +323,9 @@ int main(int argc, char** argv)
 
     /*show_repos(repoInterface);*/
 
-    show_modules(repoInterface);
+    //show_modules(repoInterface);
+
+    test_verse_reference_mapping(moduleInstaller, moduleStore, textProcessor);
 
     /*int error = moduleInstaller.installModule("CrossWire", "UKJV");
 
@@ -245,7 +352,7 @@ int main(int argc, char** argv)
 
     //get_reference_text(moduleStore, textProcessor);
 
-    get_book_intro(textProcessor);
+    //get_book_intro(textProcessor);
 
     //get_book_list(moduleHelper);
 

package/src/sword_backend/common_defs.hpp

@@ -31,6 +31,8 @@ enum class ModuleType {
     bible,
     dict,
     commentary,
+    images,
+    maps,
     any
 };
 

package/src/sword_backend/repository_interface.hpp

@@ -91,6 +91,12 @@ public:
             case ModuleType::commentary:
                 moduleTypeFilter = "Commentaries";
                 break;
+            case ModuleType::images:
+                moduleTypeFilter = "Images";
+                break;
+            case ModuleType::maps:
+                moduleTypeFilter = "Maps";
+                break;
             default:
                 moduleTypeFilter = "ANY";
         }

package/src/sword_backend/text_processor.cpp

@@ -31,6 +31,7 @@
 #include <listkey.h>
 #include <swmodule.h>
 #include <swkey.h>
+#include <versificationmgr.h>
 
 // Own includes
 #include "text_processor.hpp"
@@ -868,3 +869,66 @@ void TextProcessor::removePbElementsWithSpace(std::string& data)
         }
     }
 }
+
+string TextProcessor::mapVerseReference(string sourceOsisRef, string sourceModuleName, string targetModuleName, bool allowRange)
+{
+    // Look up both modules to read their versification systems
+    SWModule* sourceModule = this->_moduleStore.getLocalModule(sourceModuleName);
+    SWModule* targetModule = this->_moduleStore.getLocalModule(targetModuleName);
+
+    // Determine versification system names (default to KJV if not specified)
+    string sourceV11n = "KJV";
+    string targetV11n = "KJV";
+
+    if (sourceModule != 0) {
+        const char* v11nEntry = sourceModule->getConfigEntry("Versification");
+        if (v11nEntry != 0) {
+            sourceV11n = v11nEntry;
+        }
+    }
+
+    if (targetModule != 0) {
+        const char* v11nEntry = targetModule->getConfigEntry("Versification");
+        if (v11nEntry != 0) {
+            targetV11n = v11nEntry;
+        }
+    }
+
+    // If both modules use the same versification, no mapping is needed
+    if (sourceV11n == targetV11n) {
+        return sourceOsisRef;
+    }
+
+    // Get the versification systems from VersificationMgr
+    VersificationMgr* vMgr = VersificationMgr::getSystemVersificationMgr();
+    const VersificationMgr::System* sourceSys = vMgr->getVersificationSystem(sourceV11n.c_str());
+    const VersificationMgr::System* targetSys = vMgr->getVersificationSystem(targetV11n.c_str());
+
+    if (sourceSys == 0 || targetSys == 0) {
+        return sourceOsisRef;
+    }
+
+    // Parse the source OSIS reference using a VerseKey with the source versification
+    VerseKey sourceKey;
+    sourceKey.setVersificationSystem(sourceV11n.c_str());
+    sourceKey.setText(sourceOsisRef.c_str());
+
+    // Extract the components for translateVerse
+    const char* book = sourceKey.getOSISBookName();
+    int chapter = sourceKey.getChapter();
+    int verse = sourceKey.getVerse();
+    int verseEnd = verse;
+
+    // Perform the mapping
+    sourceSys->translateVerse(targetSys, &book, &chapter, &verse, &verseEnd);
+
+    // Build the mapped OSIS reference
+    stringstream result;
+    result << book << "." << chapter << "." << verse;
+
+    if (allowRange && verseEnd > verse) {
+        result << "-" << book << "." << chapter << "." << verseEnd;
+    }
+
+    return result.str();
+}

package/src/sword_backend/text_processor.hpp

@@ -59,6 +59,8 @@ public:
     std::string padStrongsNumber(const std::string strongsNumber);
     bool isModuleReadable(sword::SWModule* module, std::string key="John 1:1");
 
+    std::string mapVerseReference(std::string sourceOsisRef, std::string sourceModuleName, std::string targetModuleName, bool allowRange = false);
+
 private:
     std::vector<Verse> getText(std::string moduleName,
                                std::string key,