react-native-nitro-markdown 0.4.2 → 0.5.0

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

@@ -5,7 +5,6 @@
 /// Copyright © Marc Rousavy @ Margelo
 ///
 
-import Foundation
 import NitroModules
 
 /// See ``HybridMarkdownSessionSpec``
@@ -14,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

@@ -5,7 +5,6 @@
 /// Copyright © Marc Rousavy @ Margelo
 ///
 
-import Foundation
 import NitroModules
 
 /**
@@ -135,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)
     }
   }
   
@@ -169,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.2",
+  "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,10 +50,11 @@
     "!scripts"
   ],
   "scripts": {
-    "prebuild": "npm run codegen",
+    "prebuild": "bun run codegen",
     "build": "bob build",
     "clean": "rimraf lib nitrogen/generated",
     "codegen": "nitrogen --logLevel=\"debug\"",
+    "lint": "eslint src --max-warnings=0 --ignore-pattern 'src/**/__tests__/**' --ignore-pattern 'src/**/*.nitro.ts'",
     "typecheck": "tsc --noEmit",
     "test": "jest",
     "test:coverage": "jest --coverage",
@@ -86,10 +87,11 @@
     "registry": "https://registry.npmjs.org/"
   },
   "devDependencies": {
-    "@types/react": "^19.2.11",
+    "@types/react": "^19.2.14",
     "@types/react-native": "^0.73.0",
-    "react-native-builder-bob": "^0.40.17",
-    "react-native-nitro-modules": "*",
+    "@types/react-test-renderer": "^19.1.0",
+    "react-native-builder-bob": "^0.40.18",
+    "react-test-renderer": "^19.2.4",
     "typescript": "^5.9.3"
   },
   "peerDependencies": {

package/src/Markdown.nitro.ts

@@ -1,12 +1,16 @@
-import type { HybridObject } from 'react-native-nitro-modules';
+import type { HybridObject } from "react-native-nitro-modules";
 
 export interface ParserOptions {
   gfm?: boolean;
   math?: boolean;
 }
 
-export interface MarkdownParser
-  extends HybridObject<{ ios: 'c++'; android: 'c++' }> {
+export interface MarkdownParser extends HybridObject<{
+  ios: "c++";
+  android: "c++";
+}> {
   parse(text: string): string;
   parseWithOptions(text: string, options: ParserOptions): string;
+  extractPlainText(text: string): string;
+  extractPlainTextWithOptions(text: string, options: ParserOptions): string;
 }

package/src/MarkdownContext.ts

@@ -4,28 +4,28 @@ import {
   type ReactNode,
   type ComponentType,
 } from "react";
+import type { MarkdownNode } from "./headless";
 import {
   defaultMarkdownTheme,
   type MarkdownTheme,
   type NodeStyleOverrides,
   type StylingStrategy,
 } from "./theme";
-import type { MarkdownNode } from "./headless";
 
-export interface NodeRendererProps {
+export type NodeRendererProps = {
   node: MarkdownNode;
   depth: number;
   inListItem: boolean;
   parentIsText?: boolean;
-}
+};
 
-export interface BaseCustomRendererProps {
+export type BaseCustomRendererProps = {
   node: MarkdownNode;
   children: ReactNode;
   Renderer: ComponentType<NodeRendererProps>;
-}
+};
 
-export interface EnhancedRendererProps extends BaseCustomRendererProps {
+export type EnhancedRendererProps = {
   level?: 1 | 2 | 3 | 4 | 5 | 6;
   href?: string;
   title?: string;
@@ -36,63 +36,69 @@ export interface EnhancedRendererProps extends BaseCustomRendererProps {
   ordered?: boolean;
   start?: number;
   checked?: boolean;
-}
+} & BaseCustomRendererProps;
 
-export interface HeadingRendererProps extends BaseCustomRendererProps {
+export type HeadingRendererProps = {
   level: 1 | 2 | 3 | 4 | 5 | 6;
-}
+} & BaseCustomRendererProps;
 
-export interface LinkRendererProps extends BaseCustomRendererProps {
+export type LinkRendererProps = {
   href: string;
   title?: string;
-}
+} & BaseCustomRendererProps;
 
-export interface ImageRendererProps extends BaseCustomRendererProps {
+export type ImageRendererProps = {
   url: string;
   alt?: string;
   title?: string;
-}
+} & BaseCustomRendererProps;
 
-export interface CodeBlockRendererProps extends BaseCustomRendererProps {
+export type CodeBlockRendererProps = {
   content: string;
   language?: string;
-}
+} & BaseCustomRendererProps;
 
-export interface InlineCodeRendererProps extends BaseCustomRendererProps {
+export type InlineCodeRendererProps = {
   content: string;
-}
+} & BaseCustomRendererProps;
 
-export interface ListRendererProps extends BaseCustomRendererProps {
+export type ListRendererProps = {
   ordered: boolean;
   start?: number;
-}
+} & BaseCustomRendererProps;
 
-export interface TaskListItemRendererProps extends BaseCustomRendererProps {
+export type TaskListItemRendererProps = {
   checked: boolean;
-}
+} & BaseCustomRendererProps;
+
+export type CustomRendererProps = {} & EnhancedRendererProps;
 
-export interface CustomRendererProps extends EnhancedRendererProps {}
+export type LinkPressHandler = (
+  href: string,
+) => void | boolean | Promise<void | boolean>;
 
 export type CustomRenderer = (
-  props: EnhancedRendererProps
+  props: EnhancedRendererProps,
 ) => ReactNode | undefined;
 
 export type CustomRenderers = Partial<
   Record<MarkdownNode["type"], CustomRenderer>
 >;
 
-export interface MarkdownContextValue {
+export type MarkdownContextValue = {
   renderers: CustomRenderers;
   theme: MarkdownTheme;
   styles?: NodeStyleOverrides;
   stylingStrategy: StylingStrategy;
-}
+  onLinkPress?: LinkPressHandler;
+};
 
 export const MarkdownContext = createContext<MarkdownContextValue>({
   renderers: {},
   theme: defaultMarkdownTheme,
   styles: undefined,
   stylingStrategy: "opinionated",
+  onLinkPress: undefined,
 });
 
 export const useMarkdownContext = () => useContext(MarkdownContext);

package/src/headless.ts

@@ -19,7 +19,7 @@ export type { ParserOptions } from "./Markdown.nitro";
  * Represents a node in the Markdown AST (Abstract Syntax Tree).
  * Each node has a type and optional properties depending on the node type.
  */
-export interface MarkdownNode {
+export type MarkdownNode = {
   /** The type of markdown element this node represents. Used to decide how to render the node. */
   type:
     | "document"
@@ -71,9 +71,13 @@ export interface 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[];
-}
+};
 
 export const MarkdownParserModule =
   NitroModules.createHybridObject<MarkdownParser>("MarkdownParser");
@@ -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 {
@@ -18,6 +25,7 @@ export type {
   InlineCodeRendererProps,
   ListRendererProps,
   TaskListItemRendererProps,
+  LinkPressHandler,
   MarkdownContextValue,
 } from "./MarkdownContext";
 

package/src/markdown-stream.tsx

@@ -2,13 +2,55 @@ import {
   useState,
   useEffect,
   useRef,
+  useCallback,
   startTransition,
   type FC,
 } from "react";
+import type { MarkdownNode } from "./headless";
 import { Markdown, type MarkdownProps } from "./markdown";
 import type { MarkdownSession } from "./specs/MarkdownSession.nitro";
+import { getNextStreamAst, parseMarkdownAst } from "./utils/incremental-ast";
 
-export interface MarkdownStreamProps extends Omit<MarkdownProps, "children"> {
+const normalizeOffset = (value: number): number | null => {
+  if (!Number.isFinite(value)) return null;
+  if (value <= 0) return 0;
+  return Math.floor(value);
+};
+
+const resolveStreamText = ({
+  forceFullSync,
+  pendingFrom,
+  pendingTo,
+  previousText,
+  session,
+}: {
+  forceFullSync: boolean;
+  pendingFrom: number | null;
+  pendingTo: number | null;
+  previousText: string;
+  session: MarkdownSession;
+}): string => {
+  if (forceFullSync || pendingFrom === null || pendingTo === null) {
+    return session.getAllText();
+  }
+
+  if (pendingTo < pendingFrom) {
+    return session.getAllText();
+  }
+
+  if (pendingFrom === previousText.length) {
+    const appendedChunk = session.getTextRange(pendingFrom, pendingTo);
+    return `${previousText}${appendedChunk}`;
+  }
+
+  if (pendingFrom === 0) {
+    return session.getTextRange(0, pendingTo);
+  }
+
+  return session.getAllText();
+};
+
+export type MarkdownStreamProps = {
   /**
    * The active MarkdownSession to stream content from.
    */
@@ -29,7 +71,12 @@ export interface MarkdownStreamProps extends Omit<MarkdownProps, "children"> {
    * Useful when you want to prioritize user interactions over stream renders.
    */
   useTransitionUpdates?: boolean;
-}
+  /**
+   * Enable incremental AST updates for append-only streams.
+   * Automatically falls back to full parse when updates are not safely mergeable.
+   */
+  incrementalParsing?: boolean;
+} & Omit<MarkdownProps, "children" | "sourceAst">;
 
 /**
  * A component that renders streaming Markdown from a MarkdownSession.
@@ -40,20 +87,55 @@ export const MarkdownStream: FC<MarkdownStreamProps> = ({
   updateIntervalMs = 50,
   updateStrategy = "interval",
   useTransitionUpdates = false,
+  incrementalParsing = true,
+  options,
+  plugins,
   ...props
 }) => {
-  const [text, setText] = useState(() => session.getAllText());
+  const parseText = useCallback(
+    (text: string): MarkdownNode => parseMarkdownAst(text, options),
+    [options],
+  );
+  const createEmptyAst = (): MarkdownNode => ({
+    type: "document",
+    children: [],
+  });
+  const initialText = session.getAllText();
+  const hasBeforeParsePlugins =
+    plugins?.some((plugin) => typeof plugin.beforeParse === "function") ??
+    false;
+  const [renderState, setRenderState] = useState(() => ({
+    text: initialText,
+    ast: hasBeforeParsePlugins ? createEmptyAst() : parseText(initialText),
+  }));
+  const renderStateRef = useRef(renderState);
   const pendingUpdateRef = useRef(false);
+  const pendingFromRef = useRef<number | null>(null);
+  const pendingToRef = useRef<number | null>(null);
+  const forceFullSyncRef = useRef(false);
   const updateTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
   const rafRef = useRef<number | null>(null);
-  const lastEmittedRef = useRef(text);
+  const allowIncremental = incrementalParsing && !hasBeforeParsePlugins;
+
+  useEffect(() => {
+    renderStateRef.current = renderState;
+  }, [renderState]);
 
   useEffect(() => {
-    // Ensure initial state is synced
     const initialText = session.getAllText();
-    setText(initialText);
-    lastEmittedRef.current = initialText;
+    const initialState = {
+      text: initialText,
+      ast: hasBeforeParsePlugins ? createEmptyAst() : parseText(initialText),
+    };
+    pendingUpdateRef.current = false;
+    pendingFromRef.current = null;
+    pendingToRef.current = null;
+    forceFullSyncRef.current = false;
+    renderStateRef.current = initialState;
+    setRenderState(initialState);
+  }, [hasBeforeParsePlugins, parseText, session]);
 
+  useEffect(() => {
     const flushUpdate = () => {
       updateTimerRef.current = null;
       if (rafRef.current !== null) {
@@ -63,14 +145,44 @@ export const MarkdownStream: FC<MarkdownStreamProps> = ({
       if (!pendingUpdateRef.current) return;
       pendingUpdateRef.current = false;
 
-      const latest = session.getAllText();
-      if (latest === lastEmittedRef.current) return;
-      lastEmittedRef.current = latest;
+      const previousState = renderStateRef.current;
+      const pendingFrom = pendingFromRef.current;
+      const pendingTo = pendingToRef.current;
+      const forceFullSync = forceFullSyncRef.current;
+      pendingFromRef.current = null;
+      pendingToRef.current = null;
+      forceFullSyncRef.current = false;
+
+      const latest = resolveStreamText({
+        forceFullSync,
+        pendingFrom,
+        pendingTo,
+        previousText: previousState.text,
+        session,
+      });
+      if (latest === previousState.text) return;
+
+      const nextAst = hasBeforeParsePlugins
+        ? previousState.ast
+        : getNextStreamAst({
+            allowIncremental,
+            nextText: latest,
+            options,
+            previousAst: previousState.ast,
+            previousText: previousState.text,
+          });
+      const nextState = {
+        text: latest,
+        ast: nextAst,
+      };
+      renderStateRef.current = nextState;
 
       if (useTransitionUpdates) {
-        startTransition(() => setText(latest));
+        startTransition(() => {
+          setRenderState(nextState);
+        });
       } else {
-        setText(latest);
+        setRenderState(nextState);
       }
     };
 
@@ -87,7 +199,22 @@ export const MarkdownStream: FC<MarkdownStreamProps> = ({
       }
     };
 
-    const unsubscribe = session.addListener(() => {
+    const unsubscribe = session.addListener((from, to) => {
+      const nextFrom = normalizeOffset(from);
+      const nextTo = normalizeOffset(to);
+
+      if (nextFrom === null || nextTo === null || nextTo < nextFrom) {
+        forceFullSyncRef.current = true;
+      } else {
+        const currentFrom = pendingFromRef.current;
+        const currentTo = pendingToRef.current;
+
+        pendingFromRef.current =
+          currentFrom === null ? nextFrom : Math.min(currentFrom, nextFrom);
+        pendingToRef.current =
+          currentTo === null ? nextTo : Math.max(currentTo, nextTo);
+      }
+
       pendingUpdateRef.current = true;
       scheduleFlush();
     });
@@ -103,7 +230,24 @@ export const MarkdownStream: FC<MarkdownStreamProps> = ({
         rafRef.current = null;
       }
     };
-  }, [session, updateIntervalMs, updateStrategy, useTransitionUpdates]);
+  }, [
+    allowIncremental,
+    hasBeforeParsePlugins,
+    options,
+    session,
+    updateIntervalMs,
+    updateStrategy,
+    useTransitionUpdates,
+  ]);
 
-  return <Markdown {...props}>{text}</Markdown>;
+  return (
+    <Markdown
+      {...props}
+      options={options}
+      plugins={plugins}
+      sourceAst={hasBeforeParsePlugins ? undefined : renderState.ast}
+    >
+      {renderState.text}
+    </Markdown>
+  );
 };