react-native-nitro-markdown 0.4.3 → 0.5.1

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());
@@ -100,6 +118,20 @@ namespace margelo::nitro::Markdown {
       auto __value = std::move(__result.value());
       return __value;
     }
+    inline void reset(const std::string& text) override {
+      auto __result = _swiftPart.reset(text);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline double replace(double from, double to, const std::string& text) override {
+      auto __result = _swiftPart.replace(std::forward<decltype(from)>(from), std::forward<decltype(to)>(to), text);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
 
   private:
     NitroMarkdown::HybridMarkdownSessionSpec_cxx _swiftPart;

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,14 @@ 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
+  func reset(text: String) throws -> Void
+  func replace(from: Double, to: Double, text: String) throws -> Double
 }
 
 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.addListener(listener: { () -> () -> Void in
-        let __wrappedFunction = bridge.wrap_Func_void(listener)
-        return { () -> Void in
-          __wrappedFunction.call()
+      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: { () -> (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
@@ -186,4 +211,27 @@ open class HybridMarkdownSessionSpec_cxx {
       return bridge.create_Result_std__function_void____(__exceptionPtr)
     }
   }
+  
+  @inline(__always)
+  public final func reset(text: std.string) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.reset(text: String(text))
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func replace(from: Double, to: Double, text: std.string) -> bridge.Result_double_ {
+    do {
+      let __result = try self.__implementation.replace(from: from, to: to, text: String(text))
+      let __resultCpp = __result
+      return bridge.create_Result_double_(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_double_(__exceptionPtr)
+    }
+  }
 }

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,7 +19,11 @@ 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);
+      prototype.registerHybridMethod("reset", &HybridMarkdownSessionSpec::reset);
+      prototype.registerHybridMethod("replace", &HybridMarkdownSessionSpec::replace);
     });
   }
 

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

@@ -50,10 +50,14 @@ 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;
+      virtual void reset(const std::string& text) = 0;
+      virtual double replace(double from, double to, const std::string& text) = 0;
 
     protected:
       // Hybrid Setup

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-nitro-markdown",
-  "version": "0.4.3",
+  "version": "0.5.1",
   "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\"",
@@ -61,7 +61,8 @@
     "benchmark": "node ../../scripts/benchmark-comparison.js",
     "prepack": "node -e \"const fs=require('fs'); fs.copyFileSync('../../README.md','./README.md'); fs.copyFileSync('../../LICENSE','./LICENSE')\"",
     "postpack": "node -e \"const fs=require('fs'); if(fs.existsSync('./README.md'))fs.unlinkSync('./README.md'); if(fs.existsSync('./LICENSE'))fs.unlinkSync('./LICENSE')\"",
-    "test:cpp": "node scripts/test-cpp.js"
+    "test:cpp": "node scripts/test-cpp.js",
+    "size": "size-limit"
   },
   "keywords": [
     "react-native",
@@ -87,16 +88,19 @@
     "registry": "https://registry.npmjs.org/"
   },
   "devDependencies": {
+    "@size-limit/preset-small-lib": "^11.0.0",
     "@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",
+    "size-limit": "^11.0.0",
     "typescript": "^5.9.3"
   },
   "peerDependencies": {
     "react": "*",
     "react-native": ">=0.75.0",
-    "react-native-nitro-modules": "*",
+    "react-native-nitro-modules": ">=0.35.0",
     "react-native-mathjax-svg": ">=0.9.0",
     "react-native-svg": ">=13.0.0"
   },

package/react-native-nitro-markdown.podspec

@@ -10,7 +10,7 @@ Pod::Spec.new do |s|
   s.license      = package["license"]
   s.authors      = package["author"]
 
-  s.platforms    = { :ios => "13.0" }
+  s.platforms    = { :ios => "15.1" }
   s.source       = { :git => "https://github.com/JoaoPauloCMarra/react-native-nitro-markdown.git", :tag => "#{s.version}" }
   s.module_name  = "NitroMarkdown"
 

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/MarkdownContext.ts

@@ -11,6 +11,7 @@ import {
   type NodeStyleOverrides,
   type StylingStrategy,
 } from "./theme";
+import type { CodeHighlighter } from "./utils/code-highlight";
 
 export type NodeRendererProps = {
   node: MarkdownNode;
@@ -91,6 +92,11 @@ export type MarkdownContextValue = {
   styles?: NodeStyleOverrides;
   stylingStrategy: StylingStrategy;
   onLinkPress?: LinkPressHandler;
+  highlightCode?: boolean | CodeHighlighter;
+  tableOptions?: {
+    minColumnWidth?: number;
+    measurementStabilizeMs?: number;
+  };
 };
 
 export const MarkdownContext = createContext<MarkdownContextValue>({

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 };
@@ -169,3 +207,15 @@ export const getFlattenedText = (node: MarkdownNode): string => {
       return childrenText;
   }
 };
+
+/**
+ * Recursively removes `beg`/`end` source offset fields from an AST.
+ * Useful to reduce memory in environments that don't need source mapping.
+ */
+export function stripSourceOffsets(node: MarkdownNode): MarkdownNode {
+  const { beg: _beg, end: _end, children, ...rest } = node;
+  return {
+    ...rest,
+    ...(children ? { children: children.map(stripSourceOffsets) } : {}),
+  };
+}

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 {
@@ -48,3 +55,6 @@ export { MathInline, MathBlock } from "./renderers/math";
 export { createMarkdownSession } from "./MarkdownSession";
 export type { MarkdownSession } from "./MarkdownSession";
 export { useMarkdownSession, useStream } from "./use-markdown-stream";
+
+export type { HighlightedToken, TokenType, CodeHighlighter } from "./utils/code-highlight";
+export { defaultHighlighter } from "./utils/code-highlight";