react-native-nitro-markdown 0.1.1 → 0.2.1

package/lib/typescript/module/renderers/list.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list.d.ts","sourceRoot":"","sources":["../../../../src/renderers/list.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAW,KAAK,EAAE,EAAE,MAAM,OAAO,CAAC;AAIpD,UAAU,SAAS;IACjB,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,SAAS,CAAC;CACrB;AAED,eAAO,MAAM,IAAI,EAAE,EAAE,CAAC,SAAS,CAyB9B,CAAC;AAEF,UAAU,aAAa;IACrB,QAAQ,EAAE,SAAS,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;CACf;AAED,eAAO,MAAM,QAAQ,EAAE,EAAE,CAAC,aAAa,CAsCtC,CAAC;AAEF,UAAU,iBAAiB;IACzB,QAAQ,EAAE,SAAS,CAAC;IACpB,OAAO,EAAE,OAAO,CAAC;CAClB;AAED,eAAO,MAAM,YAAY,EAAE,EAAE,CAAC,iBAAiB,CAiC9C,CAAC"}

package/lib/typescript/module/renderers/math.d.ts

@@ -0,0 +1,15 @@
+import { type FC } from "react";
+interface MathInlineProps {
+    content?: string;
+}
+export declare const MathInline: FC<MathInlineProps>;
+interface MathBlockProps {
+    content?: string;
+}
+/**
+ * Block math renderer.
+ * Uses react-native-mathjax-svg if installed, otherwise shows raw LaTeX.
+ */
+export declare const MathBlock: FC<MathBlockProps>;
+export {};
+//# sourceMappingURL=math.d.ts.map

package/lib/typescript/module/renderers/math.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"math.d.ts","sourceRoot":"","sources":["../../../../src/renderers/math.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAW,KAAK,EAAE,EAAsB,MAAM,OAAO,CAAC;AA2B7D,UAAU,eAAe;IACvB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAuED,eAAO,MAAM,UAAU,EAAE,EAAE,CAAC,eAAe,CA2B1C,CAAC;AAEF,UAAU,cAAc;IACtB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;GAGG;AACH,eAAO,MAAM,SAAS,EAAE,EAAE,CAAC,cAAc,CAyBxC,CAAC"}

package/lib/typescript/module/renderers/paragraph.d.ts

@@ -0,0 +1,15 @@
+import { ReactNode, type FC } from "react";
+import { type StyleProp, type ViewStyle } from "react-native";
+interface ParagraphProps {
+    children: ReactNode;
+    inListItem?: boolean;
+    style?: StyleProp<ViewStyle>;
+}
+/**
+ * Paragraph component that supports mixed content (Text and View elements).
+ * Uses View with flexDirection: 'row' and flexWrap: 'wrap' to allow inline flow
+ * of both text and non-text elements (like inline math).
+ */
+export declare const Paragraph: FC<ParagraphProps>;
+export {};
+//# sourceMappingURL=paragraph.d.ts.map

package/lib/typescript/module/renderers/paragraph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paragraph.d.ts","sourceRoot":"","sources":["../../../../src/renderers/paragraph.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAW,KAAK,EAAE,EAAE,MAAM,OAAO,CAAC;AACpD,OAAO,EAAoB,KAAK,SAAS,EAAE,KAAK,SAAS,EAAE,MAAM,cAAc,CAAC;AAGhF,UAAU,cAAc;IACtB,QAAQ,EAAE,SAAS,CAAC;IACpB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,KAAK,CAAC,EAAE,SAAS,CAAC,SAAS,CAAC,CAAC;CAC9B;AAED;;;;GAIG;AACH,eAAO,MAAM,SAAS,EAAE,EAAE,CAAC,cAAc,CAoCxC,CAAC"}

package/lib/typescript/module/renderers/table.d.ts

@@ -0,0 +1,10 @@
+import { type FC, type ComponentType } from "react";
+import type { MarkdownNode } from "../headless";
+import { type NodeRendererProps } from "../MarkdownContext";
+interface TableRendererProps {
+    node: MarkdownNode;
+    Renderer: ComponentType<NodeRendererProps>;
+}
+export declare const TableRenderer: FC<TableRendererProps>;
+export {};
+//# sourceMappingURL=table.d.ts.map

package/lib/typescript/module/renderers/table.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"table.d.ts","sourceRoot":"","sources":["../../../../src/renderers/table.tsx"],"names":[],"mappings":"AAAA,OAAO,EAML,KAAK,EAAE,EACP,KAAK,aAAa,EACnB,MAAM,OAAO,CAAC;AAUf,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,EAAsB,KAAK,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AA6ChF,UAAU,kBAAkB;IAC1B,IAAI,EAAE,YAAY,CAAC;IACnB,QAAQ,EAAE,aAAa,CAAC,iBAAiB,CAAC,CAAC;CAC5C;AAED,eAAO,MAAM,aAAa,EAAE,EAAE,CAAC,kBAAkB,CAwKhD,CAAC"}

package/lib/typescript/module/specs/MarkdownSession.nitro.d.ts

@@ -0,0 +1,12 @@
+import type { HybridObject } from "react-native-nitro-modules";
+export interface MarkdownSession extends HybridObject<{
+    ios: "swift";
+    android: "kotlin";
+}> {
+    append(chunk: string): void;
+    clear(): void;
+    getAllText(): string;
+    highlightPosition: number;
+    addListener(listener: () => void): () => void;
+}
+//# sourceMappingURL=MarkdownSession.nitro.d.ts.map

package/lib/typescript/module/specs/MarkdownSession.nitro.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MarkdownSession.nitro.d.ts","sourceRoot":"","sources":["../../../../src/specs/MarkdownSession.nitro.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAE/D,MAAM,WAAW,eACf,SAAQ,YAAY,CAAC;IAAE,GAAG,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,QAAQ,CAAA;CAAE,CAAC;IAEzD,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,KAAK,IAAI,IAAI,CAAC;IACd,UAAU,IAAI,MAAM,CAAC;IAIrB,iBAAiB,EAAE,MAAM,CAAC;IAG1B,WAAW,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC;CAC/C"}

package/lib/typescript/module/theme.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Default theme configuration for the Markdown components.
+ * Optimized for a modern dark mode aesthetic.
+ */
+export declare const defaultMarkdownTheme: {
+    /** Colors used throughout the markdown renderer */
+    colors: {
+        text: string;
+        textMuted: string;
+        heading: string;
+        link: string;
+        code: string;
+        codeBackground: string;
+        blockquote: string;
+        border: string;
+        surface: string;
+        surfaceLight: string;
+        accent: string;
+        tableBorder: string;
+        tableHeader: string;
+        tableHeaderText: string;
+        tableRowEven: string;
+        tableRowOdd: string;
+    };
+    /** Standard spacing increments */
+    spacing: {
+        xs: number;
+        s: number;
+        m: number;
+        l: number;
+        xl: number;
+    };
+    /** Font sizes for different text elements */
+    fontSizes: {
+        xs: number;
+        s: number;
+        m: number;
+        l: number;
+        xl: number;
+        h1: number;
+        h2: number;
+        h3: number;
+        h4: number;
+        h5: number;
+        h6: number;
+    };
+};
+/**
+ * Type definition for the Markdown theme.
+ */
+export type MarkdownTheme = typeof defaultMarkdownTheme;
+//# sourceMappingURL=theme.d.ts.map

package/lib/typescript/module/theme.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"theme.d.ts","sourceRoot":"","sources":["../../../src/theme.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,eAAO,MAAM,oBAAoB;IAC/B,mDAAmD;;;;;;;;;;;;;;;;;;;IAmBnD,kCAAkC;;;;;;;;IAQlC,6CAA6C;;;;;;;;;;;;;;CAc9C,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,OAAO,oBAAoB,CAAC"}

package/lib/typescript/module/use-markdown-stream.d.ts

@@ -0,0 +1,22 @@
+import { createMarkdownSession } from "./MarkdownSession";
+export type MarkdownSession = ReturnType<typeof createMarkdownSession>;
+export declare function useMarkdownSession(): {
+    getSession: () => import("./specs/MarkdownSession.nitro").MarkdownSession;
+    isStreaming: boolean;
+    setIsStreaming: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    stop: () => void;
+    clear: () => void;
+    setHighlight: (position: number) => void;
+};
+export declare function useStream(timestamps?: Record<number, number>): {
+    isPlaying: boolean;
+    setIsPlaying: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    sync: (currentTimeMs: number) => void;
+    getSession: () => import("./specs/MarkdownSession.nitro").MarkdownSession;
+    isStreaming: boolean;
+    setIsStreaming: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    stop: () => void;
+    clear: () => void;
+    setHighlight: (position: number) => void;
+};
+//# sourceMappingURL=use-markdown-stream.d.ts.map

package/lib/typescript/module/use-markdown-stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-markdown-stream.d.ts","sourceRoot":"","sources":["../../../src/use-markdown-stream.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAE1D,MAAM,MAAM,eAAe,GAAG,UAAU,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEvE,wBAAgB,kBAAkB;;;;;;6BAyBY,MAAM;EAcnD;AAED,wBAAgB,SAAS,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;;;0BAczC,MAAM;;;;;;6BA9BoB,MAAM;EAoDnD"}

package/nitro.json

@@ -1,5 +1,5 @@
 {
-  "cxxNamespace": ["NitroMarkdown"],
+  "cxxNamespace": ["Markdown"],
   "ios": {
     "iosModuleName": "NitroMarkdown"
   },
@@ -10,7 +10,10 @@
   "autolinking": {
     "MarkdownParser": {
       "cpp": "HybridMarkdownParser"
+    },
+    "MarkdownSession": {
+      "swift": "HybridMarkdownSession",
+      "kotlin": "HybridMarkdownSession"
     }
   }
 }
-

package/nitrogen/generated/android/NitroMarkdown+autolinking.cmake

@@ -2,7 +2,7 @@
 # NitroMarkdown+autolinking.cmake
 # This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 # https://github.com/mrousavy/nitro
-# Copyright © 2025 Marc Rousavy @ Margelo
+# Copyright © Marc Rousavy @ Margelo
 #
 
 # This is a CMake file that adds all files generated by Nitrogen
@@ -34,8 +34,9 @@ target_sources(
   ../nitrogen/generated/android/NitroMarkdownOnLoad.cpp
   # Shared Nitrogen C++ sources
   ../nitrogen/generated/shared/c++/HybridMarkdownParserSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridMarkdownSessionSpec.cpp
   # Android-specific Nitrogen C++ sources
-  
+  ../nitrogen/generated/android/c++/JHybridMarkdownSessionSpec.cpp
 )
 
 # From node_modules/react-native/ReactAndroid/cmake-utils/folly-flags.cmake

package/nitrogen/generated/android/NitroMarkdown+autolinking.gradle

@@ -2,7 +2,7 @@
 /// NitroMarkdown+autolinking.gradle
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
+/// Copyright © Marc Rousavy @ Margelo
 ///
 
 /// This is a Gradle file that adds all files generated by Nitrogen

package/nitrogen/generated/android/NitroMarkdownOnLoad.cpp

@@ -2,7 +2,7 @@
 /// NitroMarkdownOnLoad.cpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
+/// Copyright © Marc Rousavy @ Margelo
 ///
 
 #ifndef BUILDING_NITROMARKDOWN_WITH_GENERATED_CMAKE_PROJECT
@@ -15,18 +15,22 @@
 #include <fbjni/fbjni.h>
 #include <NitroModules/HybridObjectRegistry.hpp>
 
+#include "JHybridMarkdownSessionSpec.hpp"
+#include "JFunc_void.hpp"
 #include "HybridMarkdownParser.hpp"
+#include <NitroModules/DefaultConstructableObject.hpp>
 
-namespace margelo::nitro::NitroMarkdown {
+namespace margelo::nitro::Markdown {
 
 int initialize(JavaVM* vm) {
   using namespace margelo::nitro;
-  using namespace margelo::nitro::NitroMarkdown;
+  using namespace margelo::nitro::Markdown;
   using namespace facebook;
 
   return facebook::jni::initialize(vm, [] {
     // Register native JNI methods
-    
+    margelo::nitro::Markdown::JHybridMarkdownSessionSpec::registerNatives();
+    margelo::nitro::Markdown::JFunc_void_cxx::registerNatives();
 
     // Register Nitro Hybrid Objects
     HybridObjectRegistry::registerHybridObjectConstructor(
@@ -38,7 +42,15 @@ int initialize(JavaVM* vm) {
         return std::make_shared<HybridMarkdownParser>();
       }
     );
+    HybridObjectRegistry::registerHybridObjectConstructor(
+      "MarkdownSession",
+      []() -> std::shared_ptr<HybridObject> {
+        static DefaultConstructableObject<JHybridMarkdownSessionSpec::javaobject> object("com/margelo/nitro/com/nitromarkdown/HybridMarkdownSession");
+        auto instance = object.create();
+        return instance->cthis()->shared();
+      }
+    );
   });
 }
 
-} // namespace margelo::nitro::NitroMarkdown
+} // namespace margelo::nitro::Markdown

package/nitrogen/generated/android/NitroMarkdownOnLoad.hpp

@@ -2,13 +2,13 @@
 /// NitroMarkdownOnLoad.hpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
+/// Copyright © Marc Rousavy @ Margelo
 ///
 
 #include <jni.h>
 #include <NitroModules/NitroDefines.hpp>
 
-namespace margelo::nitro::NitroMarkdown {
+namespace margelo::nitro::Markdown {
 
   /**
    * Initializes the native (C++) part of NitroMarkdown, and autolinks all Hybrid Objects.
@@ -16,10 +16,10 @@ namespace margelo::nitro::NitroMarkdown {
    * Example:
    * ```cpp (cpp-adapter.cpp)
    * JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
-   *   return margelo::nitro::NitroMarkdown::initialize(vm);
+   *   return margelo::nitro::Markdown::initialize(vm);
    * }
    * ```
    */
   int initialize(JavaVM* vm);
 
-} // namespace margelo::nitro::NitroMarkdown
+} // namespace margelo::nitro::Markdown

package/nitrogen/generated/android/c++/JFunc_void.hpp

@@ -0,0 +1,75 @@
+///
+/// JFunc_void.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+
+namespace margelo::nitro::Markdown {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `() -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void: public jni::JavaClass<JFunc_void> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/com/nitromarkdown/Func_void;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void` instance holds through JNI.
+     */
+    void invoke() const {
+      static const auto method = javaClassStatic()->getMethod<void()>("invoke");
+      method(self());
+    }
+  };
+
+  /**
+   * An implementation of Func_void that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_cxx final: public jni::HybridClass<JFunc_void_cxx, JFunc_void> {
+  public:
+    static jni::local_ref<JFunc_void::javaobject> fromCpp(const std::function<void()>& func) {
+      return JFunc_void_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_cxx` instance holds.
+     */
+    void invoke_cxx() {
+      _func();
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void()>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/com/nitromarkdown/Func_void_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_cxx(const std::function<void()>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void()> _func;
+  };
+
+} // namespace margelo::nitro::Markdown

package/nitrogen/generated/android/c++/JHybridMarkdownSessionSpec.cpp

@@ -0,0 +1,91 @@
+///
+/// JHybridMarkdownSessionSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "JHybridMarkdownSessionSpec.hpp"
+
+
+
+#include <string>
+#include <functional>
+#include "JFunc_void.hpp"
+#include <NitroModules/JNICallable.hpp>
+
+namespace margelo::nitro::Markdown {
+
+  jni::local_ref<JHybridMarkdownSessionSpec::jhybriddata> JHybridMarkdownSessionSpec::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
+  }
+
+  void JHybridMarkdownSessionSpec::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", JHybridMarkdownSessionSpec::initHybrid),
+    });
+  }
+
+  size_t JHybridMarkdownSessionSpec::getExternalMemorySize() noexcept {
+    static const auto method = javaClassStatic()->getMethod<jlong()>("getMemorySize");
+    return method(_javaPart);
+  }
+
+  bool JHybridMarkdownSessionSpec::equals(const std::shared_ptr<HybridObject>& other) {
+    if (auto otherCast = std::dynamic_pointer_cast<JHybridMarkdownSessionSpec>(other)) {
+      return _javaPart == otherCast->_javaPart;
+    }
+    return false;
+  }
+
+  void JHybridMarkdownSessionSpec::dispose() noexcept {
+    static const auto method = javaClassStatic()->getMethod<void()>("dispose");
+    method(_javaPart);
+  }
+
+  std::string JHybridMarkdownSessionSpec::toString() {
+    static const auto method = javaClassStatic()->getMethod<jni::JString()>("toString");
+    auto javaString = method(_javaPart);
+    return javaString->toStdString();
+  }
+
+  // Properties
+  double JHybridMarkdownSessionSpec::getHighlightPosition() {
+    static const auto method = javaClassStatic()->getMethod<double()>("getHighlightPosition");
+    auto __result = method(_javaPart);
+    return __result;
+  }
+  void JHybridMarkdownSessionSpec::setHighlightPosition(double highlightPosition) {
+    static const auto method = javaClassStatic()->getMethod<void(double /* highlightPosition */)>("setHighlightPosition");
+    method(_javaPart, highlightPosition);
+  }
+
+  // Methods
+  void JHybridMarkdownSessionSpec::append(const std::string& chunk) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* chunk */)>("append");
+    method(_javaPart, jni::make_jstring(chunk));
+  }
+  void JHybridMarkdownSessionSpec::clear() {
+    static const auto method = javaClassStatic()->getMethod<void()>("clear");
+    method(_javaPart);
+  }
+  std::string JHybridMarkdownSessionSpec::getAllText() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getAllText");
+    auto __result = method(_javaPart);
+    return __result->toStdString();
+  }
+  std::function<void()> JHybridMarkdownSessionSpec::addListener(const std::function<void()>& listener) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JFunc_void::javaobject>(jni::alias_ref<JFunc_void::javaobject> /* listener */)>("addListener_cxx");
+    auto __result = method(_javaPart, JFunc_void_cxx::fromCpp(listener));
+    return [&]() -> std::function<void()> {
+      if (__result->isInstanceOf(JFunc_void_cxx::javaClassStatic())) [[likely]] {
+        auto downcast = jni::static_ref_cast<JFunc_void_cxx::javaobject>(__result);
+        return downcast->cthis()->getFunction();
+      } else {
+        auto __resultRef = jni::make_global(__result);
+        return JNICallable<JFunc_void, void()>(std::move(__resultRef));
+      }
+    }();
+  }
+
+} // namespace margelo::nitro::Markdown

package/nitrogen/generated/android/c++/JHybridMarkdownSessionSpec.hpp

@@ -0,0 +1,70 @@
+///
+/// HybridMarkdownSessionSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <NitroModules/JHybridObject.hpp>
+#include <fbjni/fbjni.h>
+#include "HybridMarkdownSessionSpec.hpp"
+
+
+
+
+namespace margelo::nitro::Markdown {
+
+  using namespace facebook;
+
+  class JHybridMarkdownSessionSpec: public jni::HybridClass<JHybridMarkdownSessionSpec, JHybridObject>,
+                                    public virtual HybridMarkdownSessionSpec {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/com/nitromarkdown/HybridMarkdownSessionSpec;";
+    static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
+    static void registerNatives();
+
+  protected:
+    // C++ constructor (called from Java via `initHybrid()`)
+    explicit JHybridMarkdownSessionSpec(jni::alias_ref<jhybridobject> jThis) :
+      HybridObject(HybridMarkdownSessionSpec::TAG),
+      HybridBase(jThis),
+      _javaPart(jni::make_global(jThis)) {}
+
+  public:
+    ~JHybridMarkdownSessionSpec() override {
+      // Hermes GC can destroy JS objects on a non-JNI Thread.
+      jni::ThreadScope::WithClassLoader([&] { _javaPart.reset(); });
+    }
+
+  public:
+    size_t getExternalMemorySize() noexcept override;
+    bool equals(const std::shared_ptr<HybridObject>& other) override;
+    void dispose() noexcept override;
+    std::string toString() override;
+
+  public:
+    inline const jni::global_ref<JHybridMarkdownSessionSpec::javaobject>& getJavaPart() const noexcept {
+      return _javaPart;
+    }
+
+  public:
+    // Properties
+    double getHighlightPosition() override;
+    void setHighlightPosition(double highlightPosition) override;
+
+  public:
+    // Methods
+    void append(const std::string& chunk) override;
+    void clear() override;
+    std::string getAllText() override;
+    std::function<void()> addListener(const std::function<void()>& listener) override;
+
+  private:
+    friend HybridBase;
+    using HybridBase::HybridBase;
+    jni::global_ref<JHybridMarkdownSessionSpec::javaobject> _javaPart;
+  };
+
+} // namespace margelo::nitro::Markdown

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

@@ -0,0 +1,80 @@
+///
+/// Func_void.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 `() => 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: () -> 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(): Unit
+}
+
+/**
+ * Represents the JavaScript callback `() => 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_cxx: Func_void {
+  @DoNotStrip
+  @Keep
+  private val mHybridData: HybridData
+
+  @DoNotStrip
+  @Keep
+  private constructor(hybridData: HybridData) {
+    mHybridData = hybridData
+  }
+
+  @DoNotStrip
+  @Keep
+  override fun invoke(): Unit
+    = invoke_cxx()
+
+  @FastNative
+  private external fun invoke_cxx(): Unit
+}
+
+/**
+ * Represents the JavaScript callback `() => void`.
+ * This is implemented in Java/Kotlin, via a `() -> Unit`.
+ * The callback is always coming from native.
+ */
+@DoNotStrip
+@Keep
+@Suppress("ClassName", "RedundantUnitReturnType", "unused")
+class Func_void_java(private val function: () -> Unit): Func_void {
+  @DoNotStrip
+  @Keep
+  override fun invoke(): Unit {
+    return this.function()
+  }
+}