react-native-nitro-markdown 0.5.2 → 0.5.4

package/android/CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.22.1)
+cmake_minimum_required(VERSION 3.18.1...3.28)
 project(NitroMarkdown)
 
 set(CMAKE_CXX_STANDARD 20)
@@ -13,6 +13,7 @@ set(CPP_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/../cpp")
 file(GLOB MD4C_SOURCES "${CPP_ROOT}/md4c/*.c")
 file(GLOB CORE_SOURCES "${CPP_ROOT}/core/*.cpp")
 file(GLOB BINDING_SOURCES "${CPP_ROOT}/bindings/*.cpp")
+list(FILTER CORE_SOURCES EXCLUDE REGEX ".*Test\\.cpp$")
 
 # Create the shared library with our sources
 add_library(${PROJECT_NAME} SHARED
@@ -38,3 +39,9 @@ target_compile_definitions(${PROJECT_NAME} PRIVATE
 # Include Nitro autolinking (adds nitrogen sources, definitions, and links)
 include(${CMAKE_CURRENT_SOURCE_DIR}/../nitrogen/generated/android/NitroMarkdown+autolinking.cmake)
 
+# L5: Per-build-type optimization flags. Release builds get full optimization and strip debug
+# symbols from the binary. Debug builds disable optimization for easier debugging.
+target_compile_options(${CMAKE_PROJECT_NAME} PRIVATE
+    $<$<CONFIG:Release>:-O3 -DNDEBUG>
+    $<$<CONFIG:Debug>:-O0 -g>
+)

package/android/build.gradle

@@ -11,7 +11,10 @@ buildscript {
 
 def reactNativeArchitectures() {
   def value = rootProject.getProperties().get("reactNativeArchitectures")
-  return value ? value.split(",") : ["armeabi-v7a", "x86", "x86_64", "arm64-v8a"]
+  // L4: Default to 64-bit only. 32-bit ABIs (armeabi-v7a, x86) are excluded from the default
+  // because all Android devices on API 24+ support 64-bit, and 32-bit increases APK size with no
+  // practical benefit for this library. Override via gradle.properties if needed.
+  return value ? value.split(",") : ["arm64-v8a", "x86_64"]
 }
 
 def isNewArchitectureEnabled() {
@@ -44,10 +47,14 @@ android {
     minSdkVersion getExtOrIntegerDefault("minSdkVersion")
     targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
     buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
+    consumerProguardFiles 'consumer-rules.pro'
 
     externalNativeBuild {
       cmake {
-        cppFlags "-frtti -fexceptions -Wall -Wextra -fstack-protector-all"
+        // L3/L5: -fstack-protector-strong replaces -fstack-protector-all (better coverage/perf
+        // tradeoff). -Wformat/-Werror=format-security guard against format-string exploits.
+        // -D_FORTIFY_SOURCE=2 enables glibc/Bionic source fortification for buffer overflows.
+        cppFlags "-frtti -fexceptions -Wall -Wextra -fstack-protector-strong -Wformat -Werror=format-security -D_FORTIFY_SOURCE=2"
         arguments "-DANDROID_STL=c++_shared", "-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON"
         abiFilters (*reactNativeArchitectures())
       }

package/android/consumer-rules.pro

@@ -0,0 +1,31 @@
+# react-native-nitro-markdown consumer ProGuard/R8 rules
+# Preserve all Nitro Hybrid Objects and JNI-facing Kotlin classes
+-keep class com.margelo.nitro.com.nitromarkdown.** { *; }
+-keep class com.nitromarkdown.** { *; }
+
+# C5: Explicitly preserve nitrogen-generated Func_* wrapper classes accessed via JNI reflection.
+# These are already covered by the wildcard above, but explicit rules guard against future
+# refactors that might narrow the wildcard, and make the intent clear to ProGuard/R8.
+-keep class com.margelo.nitro.com.nitromarkdown.Func_void { *; }
+-keep class com.margelo.nitro.com.nitromarkdown.Func_void_cxx { *; }
+-keep class com.margelo.nitro.com.nitromarkdown.Func_void_java { *; }
+-keep class com.margelo.nitro.com.nitromarkdown.Func_void_double_double { *; }
+-keep class com.margelo.nitro.com.nitromarkdown.Func_void_double_double_cxx { *; }
+-keep class com.margelo.nitro.com.nitromarkdown.Func_void_double_double_java { *; }
+-keepclassmembers class com.margelo.nitro.com.nitromarkdown.Func_** {
+    <init>(...);
+    void invoke(...);
+    *;
+}
+
+# Preserve JNI-registered native methods
+-keepclasseswithmembernames class * {
+    native <methods>;
+}
+
+# Preserve Facebook JNI annotations
+-keep @com.facebook.proguard.annotations.DoNotStrip class * { *; }
+-keepclassmembers class * {
+    @com.facebook.proguard.annotations.DoNotStrip *;
+}
+-keep @com.facebook.react.bridge.ReactModule class * { *; }

package/android/gradle.properties

@@ -1,4 +1,6 @@
 NitroMarkdown_compileSdkVersion=34
+# M3: minSdkVersion kept at 24 (Android 7.0) to match the example app's minimum SDK requirement.
+# Bumping to 26 would be preferable for security (full ASLR, etc.) but would break example builds.
 NitroMarkdown_minSdkVersion=24
 NitroMarkdown_targetSdkVersion=34
 NitroMarkdown_ndkVersion=27.1.12297006

package/android/src/main/java/com/margelo/nitro/com/nitromarkdown/HybridMarkdownSession.kt

@@ -1,26 +1,38 @@
 package com.margelo.nitro.com.nitromarkdown
 
+import androidx.annotation.GuardedBy
+
 class HybridMarkdownSession : HybridMarkdownSessionSpec() {
+    @GuardedBy("lock")
     private var buffer = StringBuilder()
+
+    @GuardedBy("lock")
     private val listeners = mutableMapOf<Long, (Double, Double) -> Unit>()
+
+    @GuardedBy("lock")
     private var nextListenerId = 0L
-    private val lock = Any()
 
-    override var highlightPosition: Double = 0.0
-        set(value) {
-            synchronized(lock) { field = value }
-            // No notify for highlighting to avoid flood
-        }
+    private val lock = Any()
 
+    @Volatile
+    private var isDestroyed = false
 
+    @GuardedBy("lock")
+    override var highlightPosition: Double = 0.0
+        get() = synchronized(lock) { field }
+        set(value) = synchronized(lock) { field = value }
+        // No notify for highlighting to avoid flood
 
     override val memorySize: Long
-        get() = buffer.length.toLong()
+        get() = synchronized(lock) { buffer.length.toLong() }
 
     override fun append(chunk: String): Double {
         val from: Int
         val to: Int
         synchronized(lock) {
+            if (buffer.length + chunk.length > MAX_BUFFER_SIZE) {
+                throw IllegalArgumentException("Buffer size limit exceeded (max ${MAX_BUFFER_SIZE} chars)")
+            }
             from = buffer.length
             buffer.append(chunk)
             to = buffer.length
@@ -50,50 +62,84 @@ class HybridMarkdownSession : HybridMarkdownSessionSpec() {
     }
 
     override fun getTextRange(from: Double, to: Double): String {
+        if (!from.isFinite() || !to.isFinite() || from < 0.0 || to < 0.0 || from > to) return ""
         synchronized(lock) {
-            val start = from.toInt().coerceIn(0, buffer.length)
-            val end = to.toInt().coerceIn(start, buffer.length)
+            val start = from.toLong().coerceIn(0L, buffer.length.toLong()).toInt()
+            val end = to.toLong().coerceIn(start.toLong(), buffer.length.toLong()).toInt()
             return buffer.substring(start, end)
         }
     }
 
     override fun addListener(listener: (Double, Double) -> Unit): () -> Unit {
-        val id: Long
         synchronized(lock) {
-            id = nextListenerId++
+            if (isDestroyed) throw IllegalStateException("HybridMarkdownSession is destroyed")
+            val id = nextListenerId++
             listeners[id] = listener
-        }
-        return {
-            synchronized(lock) {
-                listeners.remove(id)
-            }
+            return { synchronized(lock) { listeners.remove(id) } }
         }
     }
 
     override fun reset(text: String) {
         synchronized(lock) {
             buffer.replace(0, buffer.length, text)
+            highlightPosition = 0.0
         }
         notifyListeners(0.0, text.length.toDouble())
     }
 
     override fun replace(from: Double, to: Double, text: String): Double {
+        require(from.isFinite() && to.isFinite() && from >= 0.0 && to >= 0.0 && to >= from) {
+            "Invalid range: from=$from and to=$to must be finite, from must be >= 0, and to must be >= from"
+        }
         val newLength: Double
+        val notifyFrom: Double
+        val notifyTo: Double
         synchronized(lock) {
-            val start = from.toInt().coerceIn(0, buffer.length)
-            val end = to.toInt().coerceIn(start, buffer.length)
+            val start = from.toLong().coerceIn(0L, buffer.length.toLong()).toInt()
+            val end = to.toLong().coerceIn(start.toLong(), buffer.length.toLong()).toInt()
             buffer.replace(start, end, text)
             newLength = buffer.length.toDouble()
+            notifyFrom = start.toDouble()
+            notifyTo = start.toDouble() + text.length.toDouble()
         }
-        notifyListeners(from, from + text.length.toDouble())
+        notifyListeners(notifyFrom, notifyTo)
         return newLength
     }
 
     private fun notifyListeners(from: Double, to: Double) {
-        val currentListeners: Collection<(Double, Double) -> Unit>
+        val snapshot: List<(Double, Double) -> Unit>
+        synchronized(lock) {
+            snapshot = listeners.values.toList()
+        }
+        for (listener in snapshot) {
+            try {
+                listener(from, to)
+            } catch (e: Throwable) {
+                android.util.Log.e(TAG, "Listener callback threw an exception", e)
+            }
+        }
+    }
+
+    fun onDestroyed() {
         synchronized(lock) {
-            currentListeners = listeners.values.toList()
+            isDestroyed = true
+            listeners.clear()
         }
-        currentListeners.forEach { it(from, to) }
+    }
+
+    override fun dispose() {
+        onDestroyed()
+        super.dispose()
+    }
+
+    // H6: The C++ generated file (JHybridMarkdownSessionSpec.cpp) is marked DO NOT MODIFY and
+    // cannot be edited. However, fbjni (used by Nitro) automatically propagates Java/Kotlin
+    // exceptions thrown across the JNI boundary as C++ exceptions. Therefore, an
+    // IllegalArgumentException thrown in append() will be rethrown on the C++ side without
+    // requiring manual JNI exception checks in the generated code.
+
+    companion object {
+        private const val TAG = "HybridMarkdownSession"
+        private const val MAX_BUFFER_SIZE = 10 * 1024 * 1024 // 10 MB
     }
 }

package/android/src/main/java/com/nitromarkdown/NitroMarkdownPackage.kt

@@ -1,28 +1,16 @@
 package com.nitromarkdown
 
-import com.facebook.react.BaseReactPackage
+import com.facebook.react.ReactPackage
 import com.facebook.react.bridge.NativeModule
 import com.facebook.react.bridge.ReactApplicationContext
-import com.facebook.react.module.model.ReactModuleInfoProvider
 import com.facebook.react.uimanager.ViewManager
 import com.margelo.nitro.com.nitromarkdown.NitroMarkdownOnLoad
 
-class NitroMarkdownPackage : BaseReactPackage() {
-    companion object {
-        init {
-            NitroMarkdownOnLoad.initializeNative()
-        }
+class NitroMarkdownPackage : ReactPackage {
+    init {
+        NitroMarkdownOnLoad.initializeNative()
     }
 
-    override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
-        return null
-    }
-
-    override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
-        return ReactModuleInfoProvider { emptyMap() }
-    }
-
-    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
-        return emptyList()
-    }
+    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> = emptyList()
+    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> = emptyList()
 }

package/cpp/bindings/HybridMarkdownParser.cpp

@@ -79,6 +79,37 @@ inline void appendBoolField(std::string& output, const char* key, bool value) {
     output += value ? "true" : "false";
 }
 
+static constexpr size_t kMaxEstimatedSize = 64 * 1024 * 1024; // 64 MB cap
+
+static size_t estimateJsonSize(const std::shared_ptr<InternalMarkdownNode>& node) noexcept {
+    if (!node) return 0;
+    size_t size = 64; // base overhead per node (type, beg, end, braces)
+    auto safeAdd = [](size_t a, size_t b) -> size_t {
+        return (b > kMaxEstimatedSize - a) ? kMaxEstimatedSize : a + b;
+    };
+    if (node->content && size < kMaxEstimatedSize) {
+        size = safeAdd(size, node->content->size());
+    }
+    if (node->href && size < kMaxEstimatedSize) {
+        size = safeAdd(size, node->href->size() + 10);
+    }
+    if (node->title && size < kMaxEstimatedSize) {
+        size = safeAdd(size, node->title->size() + 10);
+    }
+    if (node->alt && size < kMaxEstimatedSize) {
+        size = safeAdd(size, node->alt->size() + 8);
+    }
+    if (node->language && size < kMaxEstimatedSize) {
+        size = safeAdd(size, node->language->size() + 12);
+    }
+    for (const auto& child : node->children) {
+        if (size >= kMaxEstimatedSize) break;
+        size_t childSize = estimateJsonSize(child);
+        size = safeAdd(size, childSize);
+    }
+    return size;
+}
+
 void appendNodeJson(std::string& output, const std::shared_ptr<InternalMarkdownNode>& node) {
     output.push_back('{');
 
@@ -175,10 +206,6 @@ std::string flattenNodeText(const std::shared_ptr<InternalMarkdownNode>& node) {
         case NodeType::MathInline:
         case NodeType::HtmlInline:
             return node->content.value_or("");
-        case NodeType::CodeBlock:
-        case NodeType::MathBlock:
-        case NodeType::HtmlBlock:
-            return trimCopy(node->content.value_or("")) + "\n\n";
         case NodeType::LineBreak:
             return "\n";
         case NodeType::SoftBreak:
@@ -201,6 +228,9 @@ std::string flattenNodeText(const std::shared_ptr<InternalMarkdownNode>& node) {
         case NodeType::Paragraph:
         case NodeType::Heading:
         case NodeType::Blockquote:
+        case NodeType::CodeBlock:
+        case NodeType::MathBlock:
+        case NodeType::HtmlBlock:
             return trimCopy(childrenText) + "\n\n";
         case NodeType::ListItem:
         case NodeType::TaskListItem:
@@ -219,10 +249,8 @@ std::string flattenNodeText(const std::shared_ptr<InternalMarkdownNode>& node) {
 } // namespace
 
 std::string HybridMarkdownParser::parse(const std::string& text) {
-    InternalParserOptions opts;
-    opts.gfm = true;
-    opts.math = true;
-    
+    InternalParserOptions opts{.gfm = true, .math = true, .html = false};
+
     auto ast = parser_->parse(text, opts);
     return nodeToJson(ast);
 }
@@ -231,15 +259,14 @@ std::string HybridMarkdownParser::parseWithOptions(const std::string& text, cons
     InternalParserOptions internalOpts;
     internalOpts.gfm = options.gfm.value_or(true);
     internalOpts.math = options.math.value_or(true);
+    internalOpts.html = options.html.value_or(false);
     
     auto ast = parser_->parse(text, internalOpts);
     return nodeToJson(ast);
 }
 
 std::string HybridMarkdownParser::extractPlainText(const std::string& text) {
-    InternalParserOptions opts;
-    opts.gfm = true;
-    opts.math = true;
+    InternalParserOptions opts{.gfm = true, .math = true, .html = false};
 
     auto ast = parser_->parse(text, opts);
     return flattenNodeText(ast);
@@ -249,6 +276,7 @@ std::string HybridMarkdownParser::extractPlainTextWithOptions(const std::string&
     InternalParserOptions internalOpts;
     internalOpts.gfm = options.gfm.value_or(true);
     internalOpts.math = options.math.value_or(true);
+    internalOpts.html = options.html.value_or(false);
 
     auto ast = parser_->parse(text, internalOpts);
     return flattenNodeText(ast);
@@ -256,7 +284,7 @@ std::string HybridMarkdownParser::extractPlainTextWithOptions(const std::string&
 
 std::string HybridMarkdownParser::nodeToJson(const std::shared_ptr<InternalMarkdownNode>& node) {
     std::string json;
-    json.reserve(1024);
+    json.reserve(estimateJsonSize(node));
     appendNodeJson(json, node);
     return json;
 }

package/cpp/bindings/HybridMarkdownParser.hpp

@@ -17,10 +17,10 @@ public:
     
     ~HybridMarkdownParser() override = default;
 
-    std::string parse(const std::string& text) override;
-    std::string parseWithOptions(const std::string& text, const ParserOptions& options) override;
-    std::string extractPlainText(const std::string& text) override;
-    std::string extractPlainTextWithOptions(const std::string& text, const ParserOptions& options) override;
+    [[nodiscard]] std::string parse(const std::string& text) override;
+    [[nodiscard]] std::string parseWithOptions(const std::string& text, const ParserOptions& options) override;
+    [[nodiscard]] std::string extractPlainText(const std::string& text) override;
+    [[nodiscard]] std::string extractPlainTextWithOptions(const std::string& text, const ParserOptions& options) override;
 
 private:
     std::unique_ptr<::NitroMarkdown::MD4CParser> parser_;

package/cpp/bindings/HybridMarkdownSession.cpp

@@ -0,0 +1,2 @@
+// Implementation is provided by the platform-specific HybridObject (iOS: Swift, Android: Kotlin)
+// via the Nitrogen-generated bridge. No C++ implementation is required here.