react-native-nitro-markdown 0.4.3 → 0.5.0

package/nitrogen/generated/android/kotlin/com/margelo/nitro/com/nitromarkdown/Func_void_double_double.kt

@@ -0,0 +1,80 @@
+///
+/// Func_void_double_double.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.com.nitromarkdown
+
+import androidx.annotation.Keep
+import com.facebook.jni.HybridData
+import com.facebook.proguard.annotations.DoNotStrip
+import dalvik.annotation.optimization.FastNative
+
+
+/**
+ * Represents the JavaScript callback `(from: number, to: number) => void`.
+ * This can be either implemented in C++ (in which case it might be a callback coming from JS),
+ * or in Kotlin/Java (in which case it is a native callback).
+ */
+@DoNotStrip
+@Keep
+@Suppress("ClassName", "RedundantUnitReturnType")
+fun interface Func_void_double_double: (Double, Double) -> Unit {
+  /**
+   * Call the given JS callback.
+   * @throws Throwable if the JS function itself throws an error, or if the JS function/runtime has already been deleted.
+   */
+  @DoNotStrip
+  @Keep
+  override fun invoke(from: Double, to: Double): Unit
+}
+
+/**
+ * Represents the JavaScript callback `(from: number, to: number) => void`.
+ * This is implemented in C++, via a `std::function<...>`.
+ * The callback might be coming from JS.
+ */
+@DoNotStrip
+@Keep
+@Suppress(
+  "KotlinJniMissingFunction", "unused",
+  "RedundantSuppression", "RedundantUnitReturnType", "FunctionName",
+  "ConvertSecondaryConstructorToPrimary", "ClassName", "LocalVariableName",
+)
+class Func_void_double_double_cxx: Func_void_double_double {
+  @DoNotStrip
+  @Keep
+  private val mHybridData: HybridData
+
+  @DoNotStrip
+  @Keep
+  private constructor(hybridData: HybridData) {
+    mHybridData = hybridData
+  }
+
+  @DoNotStrip
+  @Keep
+  override fun invoke(from: Double, to: Double): Unit
+    = invoke_cxx(from,to)
+
+  @FastNative
+  private external fun invoke_cxx(from: Double, to: Double): Unit
+}
+
+/**
+ * Represents the JavaScript callback `(from: number, to: number) => void`.
+ * This is implemented in Java/Kotlin, via a `(Double, Double) -> Unit`.
+ * The callback is always coming from native.
+ */
+@DoNotStrip
+@Keep
+@Suppress("ClassName", "RedundantUnitReturnType", "unused")
+class Func_void_double_double_java(private val function: (Double, Double) -> Unit): Func_void_double_double {
+  @DoNotStrip
+  @Keep
+  override fun invoke(from: Double, to: Double): Unit {
+    return this.function(from, to)
+  }
+}

package/nitrogen/generated/android/kotlin/com/margelo/nitro/com/nitromarkdown/HybridMarkdownSessionSpec.kt

@@ -51,7 +51,7 @@ abstract class HybridMarkdownSessionSpec: HybridObject() {
   // Methods
   @DoNotStrip
   @Keep
-  abstract fun append(chunk: String): Unit
+  abstract fun append(chunk: String): Double
   
   @DoNotStrip
   @Keep
@@ -61,11 +61,19 @@ abstract class HybridMarkdownSessionSpec: HybridObject() {
   @Keep
   abstract fun getAllText(): String
   
-  abstract fun addListener(listener: () -> Unit): () -> Unit
+  @DoNotStrip
+  @Keep
+  abstract fun getLength(): Double
+  
+  @DoNotStrip
+  @Keep
+  abstract fun getTextRange(from: Double, to: Double): String
+  
+  abstract fun addListener(listener: (from: Double, to: Double) -> Unit): () -> Unit
   
   @DoNotStrip
   @Keep
-  private fun addListener_cxx(listener: Func_void): Func_void {
+  private fun addListener_cxx(listener: Func_void_double_double): Func_void {
     val __result = addListener(listener)
     return Func_void_java(__result)
   }

package/nitrogen/generated/ios/NitroMarkdown-Swift-Cxx-Bridge.cpp

@@ -22,6 +22,14 @@ namespace margelo::nitro::Markdown::bridge::swift {
     };
   }
   
+  // pragma MARK: std::function<void(double /* from */, double /* to */)>
+  Func_void_double_double create_Func_void_double_double(void* NON_NULL swiftClosureWrapper) noexcept {
+    auto swiftClosure = NitroMarkdown::Func_void_double_double::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](double from, double to) mutable -> void {
+      swiftClosure.call(from, to);
+    };
+  }
+  
   // pragma MARK: std::shared_ptr<HybridMarkdownSessionSpec>
   std::shared_ptr<HybridMarkdownSessionSpec> create_std__shared_ptr_HybridMarkdownSessionSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
     NitroMarkdown::HybridMarkdownSessionSpec_cxx swiftPart = NitroMarkdown::HybridMarkdownSessionSpec_cxx::fromUnsafe(swiftUnsafePointer);

package/nitrogen/generated/ios/NitroMarkdown-Swift-Cxx-Bridge.hpp

@@ -51,6 +51,28 @@ namespace margelo::nitro::Markdown::bridge::swift {
     return Func_void_Wrapper(std::move(value));
   }
   
+  // pragma MARK: std::function<void(double /* from */, double /* to */)>
+  /**
+   * Specialized version of `std::function<void(double, double)>`.
+   */
+  using Func_void_double_double = std::function<void(double /* from */, double /* to */)>;
+  /**
+   * Wrapper class for a `std::function<void(double / * from * /, double / * to * /)>`, this can be used from Swift.
+   */
+  class Func_void_double_double_Wrapper final {
+  public:
+    explicit Func_void_double_double_Wrapper(std::function<void(double /* from */, double /* to */)>&& func): _function(std::make_unique<std::function<void(double /* from */, double /* to */)>>(std::move(func))) {}
+    inline void call(double from, double to) const noexcept {
+      _function->operator()(from, to);
+    }
+  private:
+    std::unique_ptr<std::function<void(double /* from */, double /* to */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_double_double create_Func_void_double_double(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_double_double_Wrapper wrap_Func_void_double_double(Func_void_double_double value) noexcept {
+    return Func_void_double_double_Wrapper(std::move(value));
+  }
+  
   // pragma MARK: std::shared_ptr<HybridMarkdownSessionSpec>
   /**
    * Specialized version of `std::shared_ptr<HybridMarkdownSessionSpec>`.
@@ -63,6 +85,15 @@ namespace margelo::nitro::Markdown::bridge::swift {
   using std__weak_ptr_HybridMarkdownSessionSpec_ = std::weak_ptr<HybridMarkdownSessionSpec>;
   inline std__weak_ptr_HybridMarkdownSessionSpec_ weakify_std__shared_ptr_HybridMarkdownSessionSpec_(const std::shared_ptr<HybridMarkdownSessionSpec>& strong) noexcept { return strong; }
   
+  // pragma MARK: Result<double>
+  using Result_double_ = Result<double>;
+  inline Result_double_ create_Result_double_(double value) noexcept {
+    return Result<double>::withValue(std::move(value));
+  }
+  inline Result_double_ create_Result_double_(const std::exception_ptr& error) noexcept {
+    return Result<double>::withError(error);
+  }
+  
   // pragma MARK: Result<void>
   using Result_void_ = Result<void>;
   inline Result_void_ create_Result_void_() noexcept {

package/nitrogen/generated/ios/c++/HybridMarkdownSessionSpecSwift.hpp

@@ -72,11 +72,13 @@ namespace margelo::nitro::Markdown {
 
   public:
     // Methods
-    inline void append(const std::string& chunk) override {
+    inline double append(const std::string& chunk) override {
       auto __result = _swiftPart.append(chunk);
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());
       }
+      auto __value = std::move(__result.value());
+      return __value;
     }
     inline void clear() override {
       auto __result = _swiftPart.clear();
@@ -92,7 +94,23 @@ namespace margelo::nitro::Markdown {
       auto __value = std::move(__result.value());
       return __value;
     }
-    inline std::function<void()> addListener(const std::function<void()>& listener) override {
+    inline double getLength() override {
+      auto __result = _swiftPart.getLength();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::string getTextRange(double from, double to) override {
+      auto __result = _swiftPart.getTextRange(std::forward<decltype(from)>(from), std::forward<decltype(to)>(to));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::function<void()> addListener(const std::function<void(double /* from */, double /* to */)>& listener) override {
       auto __result = _swiftPart.addListener(listener);
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());

package/nitrogen/generated/ios/swift/Func_void_double_double.swift

@@ -0,0 +1,46 @@
+///
+/// Func_void_double_double.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+/**
+ * Wraps a Swift `(_ from: Double, _ to: Double) -> Void` as a class.
+ * This class can be used from C++, e.g. to wrap the Swift closure as a `std::function`.
+ */
+public final class Func_void_double_double {
+  public typealias bridge = margelo.nitro.Markdown.bridge.swift
+
+  private let closure: (_ from: Double, _ to: Double) -> Void
+
+  public init(_ closure: @escaping (_ from: Double, _ to: Double) -> Void) {
+    self.closure = closure
+  }
+
+  @inline(__always)
+  public func call(from: Double, to: Double) -> Void {
+    self.closure(from, to)
+  }
+
+  /**
+   * Casts this instance to a retained unsafe raw pointer.
+   * This acquires one additional strong reference on the object!
+   */
+  @inline(__always)
+  public func toUnsafe() -> UnsafeMutableRawPointer {
+    return Unmanaged.passRetained(self).toOpaque()
+  }
+
+  /**
+   * Casts an unsafe pointer to a `Func_void_double_double`.
+   * The pointer has to be a retained opaque `Unmanaged<Func_void_double_double>`.
+   * This removes one strong reference from the object!
+   */
+  @inline(__always)
+  public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_double_double {
+    return Unmanaged<Func_void_double_double>.fromOpaque(pointer).takeRetainedValue()
+  }
+}

package/nitrogen/generated/ios/swift/HybridMarkdownSessionSpec.swift

@@ -13,10 +13,12 @@ public protocol HybridMarkdownSessionSpec_protocol: HybridObject {
   var highlightPosition: Double { get set }
 
   // Methods
-  func append(chunk: String) throws -> Void
+  func append(chunk: String) throws -> Double
   func clear() throws -> Void
   func getAllText() throws -> String
-  func addListener(listener: @escaping () -> Void) throws -> () -> Void
+  func getLength() throws -> Double
+  func getTextRange(from: Double, to: Double) throws -> String
+  func addListener(listener: @escaping (_ from: Double, _ to: Double) -> Void) throws -> () -> Void
 }
 
 public extension HybridMarkdownSessionSpec_protocol {

package/nitrogen/generated/ios/swift/HybridMarkdownSessionSpec_cxx.swift

@@ -134,13 +134,14 @@ open class HybridMarkdownSessionSpec_cxx {
 
   // Methods
   @inline(__always)
-  public final func append(chunk: std.string) -> bridge.Result_void_ {
+  public final func append(chunk: std.string) -> bridge.Result_double_ {
     do {
-      try self.__implementation.append(chunk: String(chunk))
-      return bridge.create_Result_void_()
+      let __result = try self.__implementation.append(chunk: String(chunk))
+      let __resultCpp = __result
+      return bridge.create_Result_double_(__resultCpp)
     } catch (let __error) {
       let __exceptionPtr = __error.toCpp()
-      return bridge.create_Result_void_(__exceptionPtr)
+      return bridge.create_Result_double_(__exceptionPtr)
     }
   }
   
@@ -168,12 +169,36 @@ open class HybridMarkdownSessionSpec_cxx {
   }
   
   @inline(__always)
-  public final func addListener(listener: bridge.Func_void) -> bridge.Result_std__function_void____ {
+  public final func getLength() -> bridge.Result_double_ {
+    do {
+      let __result = try self.__implementation.getLength()
+      let __resultCpp = __result
+      return bridge.create_Result_double_(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_double_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func getTextRange(from: Double, to: Double) -> bridge.Result_std__string_ {
+    do {
+      let __result = try self.__implementation.getTextRange(from: from, to: to)
+      let __resultCpp = std.string(__result)
+      return bridge.create_Result_std__string_(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__string_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func addListener(listener: bridge.Func_void_double_double) -> bridge.Result_std__function_void____ {
     do {
-      let __result = try self.__implementation.addListener(listener: { () -> () -> Void in
-        let __wrappedFunction = bridge.wrap_Func_void(listener)
-        return { () -> Void in
-          __wrappedFunction.call()
+      let __result = try self.__implementation.addListener(listener: { () -> (Double, Double) -> Void in
+        let __wrappedFunction = bridge.wrap_Func_void_double_double(listener)
+        return { (__from: Double, __to: Double) -> Void in
+          __wrappedFunction.call(__from, __to)
         }
       }())
       let __resultCpp = { () -> bridge.Func_void in

package/nitrogen/generated/shared/c++/HybridMarkdownParserSpec.cpp

@@ -16,6 +16,8 @@ namespace margelo::nitro::Markdown {
     registerHybrids(this, [](Prototype& prototype) {
       prototype.registerHybridMethod("parse", &HybridMarkdownParserSpec::parse);
       prototype.registerHybridMethod("parseWithOptions", &HybridMarkdownParserSpec::parseWithOptions);
+      prototype.registerHybridMethod("extractPlainText", &HybridMarkdownParserSpec::extractPlainText);
+      prototype.registerHybridMethod("extractPlainTextWithOptions", &HybridMarkdownParserSpec::extractPlainTextWithOptions);
     });
   }
 

package/nitrogen/generated/shared/c++/HybridMarkdownParserSpec.hpp

@@ -52,6 +52,8 @@ namespace margelo::nitro::Markdown {
       // Methods
       virtual std::string parse(const std::string& text) = 0;
       virtual std::string parseWithOptions(const std::string& text, const ParserOptions& options) = 0;
+      virtual std::string extractPlainText(const std::string& text) = 0;
+      virtual std::string extractPlainTextWithOptions(const std::string& text, const ParserOptions& options) = 0;
 
     protected:
       // Hybrid Setup

package/nitrogen/generated/shared/c++/HybridMarkdownSessionSpec.cpp

@@ -19,6 +19,8 @@ namespace margelo::nitro::Markdown {
       prototype.registerHybridMethod("append", &HybridMarkdownSessionSpec::append);
       prototype.registerHybridMethod("clear", &HybridMarkdownSessionSpec::clear);
       prototype.registerHybridMethod("getAllText", &HybridMarkdownSessionSpec::getAllText);
+      prototype.registerHybridMethod("getLength", &HybridMarkdownSessionSpec::getLength);
+      prototype.registerHybridMethod("getTextRange", &HybridMarkdownSessionSpec::getTextRange);
       prototype.registerHybridMethod("addListener", &HybridMarkdownSessionSpec::addListener);
     });
   }

package/nitrogen/generated/shared/c++/HybridMarkdownSessionSpec.hpp

@@ -50,10 +50,12 @@ namespace margelo::nitro::Markdown {
 
     public:
       // Methods
-      virtual void append(const std::string& chunk) = 0;
+      virtual double append(const std::string& chunk) = 0;
       virtual void clear() = 0;
       virtual std::string getAllText() = 0;
-      virtual std::function<void()> addListener(const std::function<void()>& listener) = 0;
+      virtual double getLength() = 0;
+      virtual std::string getTextRange(double from, double to) = 0;
+      virtual std::function<void()> addListener(const std::function<void(double /* from */, double /* to */)>& listener) = 0;
 
     protected:
       // Hybrid Setup

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-nitro-markdown",
-  "version": "0.4.3",
+  "version": "0.5.0",
   "description": "High-performance Markdown parser for React Native using Nitro Modules and md4c",
   "main": "lib/commonjs/index.js",
   "module": "lib/module/index.js",
@@ -50,7 +50,7 @@
     "!scripts"
   ],
   "scripts": {
-    "prebuild": "npm run codegen",
+    "prebuild": "bun run codegen",
     "build": "bob build",
     "clean": "rimraf lib nitrogen/generated",
     "codegen": "nitrogen --logLevel=\"debug\"",
@@ -89,8 +89,9 @@
   "devDependencies": {
     "@types/react": "^19.2.14",
     "@types/react-native": "^0.73.0",
+    "@types/react-test-renderer": "^19.1.0",
     "react-native-builder-bob": "^0.40.18",
-    "react-native-nitro-modules": "*",
+    "react-test-renderer": "^19.2.4",
     "typescript": "^5.9.3"
   },
   "peerDependencies": {

package/src/Markdown.nitro.ts

@@ -11,4 +11,6 @@ export interface MarkdownParser extends HybridObject<{
 }> {
   parse(text: string): string;
   parseWithOptions(text: string, options: ParserOptions): string;
+  extractPlainText(text: string): string;
+  extractPlainTextWithOptions(text: string, options: ParserOptions): string;
 }

package/src/headless.ts

@@ -71,6 +71,10 @@ export type MarkdownNode = {
   isHeader?: boolean;
   /** Text alignment for table cells: 'left', 'center', or 'right'. */
   align?: string;
+  /** Source start offset in original markdown text (when provided by native parser). */
+  beg?: number;
+  /** Source end offset in original markdown text (when provided by native parser). */
+  end?: number;
   /** Nested child nodes for hierarchical elements like paragraphs, lists, and tables. */
   children?: MarkdownNode[];
 };
@@ -84,8 +88,12 @@ export const MarkdownParserModule =
  * @returns The root node of the parsed AST
  */
 export function parseMarkdown(text: string): MarkdownNode {
-  const jsonStr = MarkdownParserModule.parse(text);
-  return JSON.parse(jsonStr) as MarkdownNode;
+  if (typeof MarkdownParserModule.parse === "function") {
+    const jsonStr = MarkdownParserModule.parse(text);
+    return JSON.parse(jsonStr) as MarkdownNode;
+  }
+
+  return { type: "document", children: [] };
 }
 
 /**
@@ -98,8 +106,38 @@ export function parseMarkdownWithOptions(
   text: string,
   options: ParserOptions,
 ): MarkdownNode {
-  const jsonStr = MarkdownParserModule.parseWithOptions(text, options);
-  return JSON.parse(jsonStr) as MarkdownNode;
+  if (typeof MarkdownParserModule.parseWithOptions === "function") {
+    const jsonStr = MarkdownParserModule.parseWithOptions(text, options);
+    return JSON.parse(jsonStr) as MarkdownNode;
+  }
+
+  return { type: "document", children: [] };
+}
+
+/**
+ * Parse markdown and return flattened plain text directly from native parser.
+ * Useful for search/indexing flows that don't need full AST rendering.
+ */
+export function extractPlainText(text: string): string {
+  if (typeof MarkdownParserModule.extractPlainText === "function") {
+    return MarkdownParserModule.extractPlainText(text);
+  }
+
+  return getFlattenedText(parseMarkdown(text));
+}
+
+/**
+ * Parse markdown with options and return flattened plain text from native parser.
+ */
+export function extractPlainTextWithOptions(
+  text: string,
+  options: ParserOptions,
+): string {
+  if (typeof MarkdownParserModule.extractPlainTextWithOptions === "function") {
+    return MarkdownParserModule.extractPlainTextWithOptions(text, options);
+  }
+
+  return getFlattenedText(parseMarkdownWithOptions(text, options));
 }
 
 export type { MarkdownParser };

package/src/index.ts

@@ -1,7 +1,14 @@
 export * from "./headless";
 
 export { Markdown } from "./markdown";
+export type {
+  MarkdownProps,
+  AstTransform,
+  MarkdownPlugin,
+  MarkdownVirtualizationOptions,
+} from "./markdown";
 export { MarkdownStream } from "./markdown-stream";
+export type { MarkdownStreamProps } from "./markdown-stream";
 
 export { useMarkdownContext, MarkdownContext } from "./MarkdownContext";
 export type {