react-native-enriched-markdown-scaffold 0.7.4-scaffold.8 → 1.0.2-scaffold.1

package/README.md

@@ -1,6 +1,6 @@
 # react-native-enriched-markdown-scaffold
 
-> A fork of [`react-native-enriched-markdown`](https://github.com/software-mansion/react-native-enriched-markdown). **Not official.**
+> A fork of [`react-native-enriched-markdown`](https://github.com/software-mansion/enriched-markdown). **Not official.**
 
 ## Why this exists
 
@@ -20,7 +20,49 @@ yarn add react-native-enriched-markdown-scaffold
 npm i react-native-enriched-markdown-scaffold
 ```
 
-Peer deps (same as upstream): `react`, `react-native`. Optional: `@expo/config-plugins`, `katex`.
+Peer deps (same as upstream): `react`, `react-native`, and `katex` (optional — only needed on Web).
+
+> The Expo config plugin was removed upstream, so `@expo/config-plugins` is **not** a peer dep any more.
+> Configure the native features through `package.json` instead — see below.
+
+## Native assets: read this before your first build
+
+The tarball deliberately ships **without** the two heavy native assets — the tree-sitter grammar
+sources (code highlighting, both platforms) and the RaTeX XCFramework (iOS LaTeX math). A
+`postinstall` script downloads them into `node_modules/react-native-enriched-markdown-scaffold/`
+on your machine.
+
+That script **never fails your install**: a blocked download only prints a warning and exits 0. So
+declare what you actually use in **your app's `package.json`** and the native build will fail loudly
+instead of quietly shipping without math or highlighting:
+
+```json
+{
+  "enriched-markdown": {
+    "enableMath": true,
+    "enableCodeHighlight": true
+  }
+}
+```
+
+- Both fields **default to `true`**, so leaving the block out still downloads and compiles both.
+  The difference is the failure mode: with an explicit `true`, a missing asset stops `pod install`
+  / the Gradle build with an actionable message; without it, the build stays green and the feature
+  is silently absent at runtime.
+- The key is `"enriched-markdown"` — **not** the package name. It is read under that exact name by
+  the podspec and `android/build.gradle`, so it does not change for this fork.
+- Set a field to `false` to skip both the download and the compile.
+
+**Two different `package.json` files are involved**, which matters in a monorepo: the *download*
+opt-out is read from wherever the install ran (`INIT_CWD` — the workspace root, one shared
+`node_modules`), while the *build* flag is read from the **app's** `package.json`, the one next to
+`ios/` and `android/`. In a plain app they are the same file. In a monorepo they are not, and each
+half fails in its own quiet way — a root-only block downloads assets that no app opts into, an
+app-only block opts into assets that were never downloaded. Put the block in **both** when in doubt.
+
+Full detail, including recovery commands, pnpm/Yarn PnP notes and the `pod install` + clean-build
+caveat, is in `docs/NATIVE_ASSETS.md` inside the tarball. Every command in the bundled `docs/` is
+rewritten at publish time to use this package's name, so you can copy-paste them as-is.
 
 ## Usage
 
@@ -35,18 +77,22 @@ import {
 } from 'react-native-enriched-markdown-scaffold';
 ```
 
-Full documentation lives in the upstream repo:
+Documentation ships **inside the tarball** under `docs/` — use that copy rather than the upstream
+site, because this fork adds editor-side APIs upstream does not have (the math chip:
+`onMathPress`, `insertMath`/`updateMath`/`removeMath`, and the `inlineMath` / `math` input style
+keys). Start with `docs/TEXT.md`, `docs/INPUT.md`, `docs/STYLES.md` and `docs/LATEX_MATH.md`;
+`docs/BREAKING_CHANGES.md` lists what changed between scaffold releases.
+
+Upstream's own docs, for anything this fork does not touch:
 
-- README: https://github.com/software-mansion/react-native-enriched-markdown
-- Text component: [docs/TEXT.md](https://github.com/software-mansion/react-native-enriched-markdown/blob/main/docs/TEXT.md)
-- Input component: [docs/INPUT.md](https://github.com/software-mansion/react-native-enriched-markdown/blob/main/docs/INPUT.md)
-- Style reference: [docs/STYLES.md](https://github.com/software-mansion/react-native-enriched-markdown/blob/main/docs/STYLES.md)
+- README: https://github.com/software-mansion/enriched-markdown
+- Docs site: https://enriched.swmansion.com/markdown
 
 ## Versioning
 
 `MAJOR.MINOR.PATCH-scaffold.N` — the leading `MAJOR.MINOR.PATCH` tracks the upstream version we forked from, `-scaffold.N` increments on every internal release.
 
-Example: `0.6.0-scaffold.2` = snapshot taken while upstream sat at `0.6.0`, second internal release.
+Example: `1.0.2-scaffold.1` = snapshot taken while upstream sat at `1.0.2`, first internal release.
 
 ## License
 

package/ReactNativeEnrichedMarkdown.podspec

@@ -5,6 +5,11 @@ package = JSON.parse(File.read(File.join(__dir__, "package.json")))
 monorepo = File.exist?(File.expand_path("../core/EnrichedMarkdownCore.podspec", __dir__))
 cpp_root = monorepo ? "$(PODS_TARGET_SRCROOT)/../core/cpp" : "$(PODS_TARGET_SRCROOT)/cpp"
 
+require File.join(__dir__, "cpp/highlight/code_highlight_podspec.rb")
+# In the monorepo the C++ (including tree-sitter highlighting) compiles in the
+# EnrichedMarkdownCore pod; only the published, core-less build compiles it here.
+code_highlight = monorepo ? EnrichedMarkdownCodeHighlight.disabled : EnrichedMarkdownCodeHighlight.config(__dir__)
+
 Pod::Spec.new do |s|
   s.name         = "ReactNativeEnrichedMarkdown"
   s.version      = package["version"]
@@ -14,7 +19,7 @@ Pod::Spec.new do |s|
   s.authors      = package["author"]
 
   s.platforms    = { :ios => min_ios_version_supported, :osx => '14.0' }
-  s.source       = { :git => "https://github.com/software-mansion/react-native-enriched-markdown.git", :tag => "#{s.version}" }
+  s.source       = { :git => "https://github.com/software-mansion/enriched-markdown.git", :tag => "#{s.version}" }
 
   if monorepo
     s.private_header_files = "ios/**/*.h"
@@ -22,97 +27,101 @@ Pod::Spec.new do |s|
     s.dependency "EnrichedMarkdownCore"
   else
     s.private_header_files = "ios/**/*.h", "cpp/**/*.{h,hpp}"
-    s.source_files = "ios/**/*.{h,m,mm,cpp,swift}", "cpp/md4c/*.{c,h}", "cpp/parser/*.{hpp,cpp}"
+    s.source_files = ["ios/**/*.{h,m,mm,cpp,swift}", "cpp/md4c/*.{c,h}", "cpp/parser/*.{hpp,cpp}", "cpp/highlight/*.{hpp,cpp}"] + code_highlight[:source_files]
+    s.preserve_paths = "cpp/highlight/vendor/**/*" if code_highlight[:enabled]
   end
 
-  # To disable LaTeX math rendering (RaTeX, iOS only), add ENV['ENRICHED_MARKDOWN_ENABLE_MATH'] = '0' to your Podfile.
-  # When math is enabled, consumers must use `use_frameworks! :linkage => :dynamic` (required for SPM interop).
-  enable_math = ENV['ENRICHED_MARKDOWN_ENABLE_MATH'] != '0'
+  # LaTeX math rendering (RaTeX, iOS only). RaTeX ships as a prebuilt static XCFramework
+  # vendored under ios/vendor (restored by vendor/vendor-ratex.mjs at postinstall); it
+  # links under CocoaPods default static linkage and needs neither `use_frameworks!` nor
+  # SPM interop.
+  #
+  # The app package.json "enriched-markdown" block is the source of truth; ENV is a
+  # deprecated fallback. `math_explicit` tracks an active opt-in (vs the implicit
+  # default), which decides the missing-framework behavior below.
+  config = EnrichedMarkdownConfig.consumer_config
+  ratex_present = File.directory?(File.join(__dir__, 'ios/vendor/RaTeX.xcframework'))
+  math_flag = ENV['ENRICHED_MARKDOWN_ENABLE_MATH']
 
-  # RaTeX is wired in through React Native's `spm_dependency` helper (SPM interop).
-  # On React Native versions that don't provide it, disable math entirely so the
-  # RaTeX-importing sources under ios/math are excluded from the build. Otherwise
-  # the failure would just move from `pod install` to a build-time
-  # "missing module 'RaTeX'" error.
-  if enable_math && !defined?(spm_dependency)
-    Pod::UI.warn '[ReactNativeEnrichedMarkdown] `spm_dependency` is unavailable in this ' \
-      'React Native version; disabling LaTeX math (RaTeX). Upgrade React Native to enable it.'
-    enable_math = false
+  if config.key?('enableMath')
+    math_requested = config['enableMath'] != false
+    math_explicit = math_requested
+    if math_flag
+      EnrichedMarkdownConfig.warn_once(:math_env, '[ReactNativeEnrichedMarkdown] DEPRECATED: ENV[\'ENRICHED_MARKDOWN_ENABLE_MATH\'] ' \
+        'is ignored when "enriched-markdown".enableMath is set in your package.json.')
+    end
+  elsif math_flag
+    EnrichedMarkdownConfig.warn_once(:math_env, '[ReactNativeEnrichedMarkdown] DEPRECATED: ENV[\'ENRICHED_MARKDOWN_ENABLE_MATH\'] ' \
+      'will be removed in a future version. Configure via "enriched-markdown".enableMath in your package.json instead.')
+    math_requested = math_flag == '1'
+    math_explicit = math_requested
+  else
+    math_requested = true
+    math_explicit = false
   end
 
-  unless enable_math
-    s.exclude_files = "ios/math/**/*.swift"
+  # RaTeX is downloaded at postinstall and kept out of the tarball. Reconcile the
+  # request with the vendored framework: an explicit opt-in with the framework missing
+  # fails loud; on by default but missing (a partial/failed download, or a monorepo root
+  # opt-out) falls back to a clean build without math.
+  enable_math = math_requested && ratex_present
+  if !math_requested
+    EnrichedMarkdownConfig.warn_once(:math_disabled, '[ReactNativeEnrichedMarkdown] LaTeX math disabled via ' \
+      '"enriched-markdown".enableMath = false in your app package.json.')
+  elsif !ratex_present
+    if math_explicit
+      raise '[ReactNativeEnrichedMarkdown] LaTeX math is enabled but the vendored RaTeX ' \
+        'XCFramework is missing at ios/vendor/RaTeX.xcframework. Reinstall to fetch it: ' \
+        '`npm rebuild react-native-enriched-markdown-scaffold`. ' \
+        'To disable math, set "enriched-markdown".enableMath = false in your app package.json. ' \
+        'Troubleshooting: https://github.com/software-mansion/enriched-markdown/blob/main/docs/NATIVE_ASSETS.md'
+    end
+    EnrichedMarkdownConfig.warn_once(:math_disabled, '[ReactNativeEnrichedMarkdown] LaTeX math disabled: the vendored RaTeX ' \
+      'XCFramework was not found at ios/vendor/RaTeX.xcframework. If this is unintended, re-run ' \
+      '`node node_modules/react-native-enriched-markdown-scaffold/postinstall.mjs`.')
   end
 
-  preprocessor_defs = '$(inherited) MD4C_USE_UTF8=1'
+  # The RaTeX XCFramework bundles its own module.modulemap and headers; never let the
+  # broad ios/**/*.h and ios/**/*.swift globs treat its internals as pod sources.
+  exclude = ["ios/vendor/RaTeX.xcframework/**/*"]
+  # ios/math holds the RaTeX bridge; ios/vendor/*.swift are RaTeX's vendored core Swift
+  # sources. Both compile into this pod's module only when math is enabled.
+  exclude += ["ios/math/**/*.swift", "ios/vendor/*.swift"] unless enable_math
+  s.exclude_files = exclude
+
+  preprocessor_defs = "$(inherited) MD4C_USE_UTF8=1#{code_highlight[:defines]}"
   if enable_math
     preprocessor_defs += ' ENRICHED_MARKDOWN_MATH=1'
-    spm_dependency(s,
-      url: 'https://github.com/erweixin/RaTeX.git',
-      requirement: {kind: 'upToNextMajorVersion', minimumVersion: '0.1.12'},
-      products: ['RaTeX']
-    )
+    # enable_math already implies ratex_present (the reconciliation above raises on an
+    # explicit opt-in with a missing framework and disables the default-on path), so the
+    # vendored references below always resolve.
+    # Prebuilt static XCFramework (device + simulator[arm64,x86_64] + macOS). Vendored
+    # rather than pulled via spm_dependency, which compiled RaTeX's Swift wrapper per
+    # requested arch (breaking universal simulator builds, #527) and double-collected
+    # its XCFramework signature during archive assembly (#491).
+    s.vendored_frameworks = 'ios/vendor/RaTeX.xcframework'
+    # RaTeXFontLoader.loadFromCocoaPodsBundle() resolves "RaTeXCoreFonts.bundle" by name,
+    # so this resource-bundle name is load-bearing -- keep it exactly RaTeXCoreFonts.
+    s.resource_bundles = { 'RaTeXCoreFonts' => ['ios/vendor/Fonts/*.ttf'] }
   end
 
   pod_xcconfig = {
-    'HEADER_SEARCH_PATHS' => "\"#{cpp_root}/md4c\" \"#{cpp_root}/parser\" \"$(PODS_TARGET_SRCROOT)/ios/internals\" \"$(PODS_TARGET_SRCROOT)/ios/input/internals\"",
+    'HEADER_SEARCH_PATHS' => ([
+      "\"#{cpp_root}/md4c\"", "\"#{cpp_root}/parser\"", "\"#{cpp_root}/highlight\"",
+      "\"$(PODS_TARGET_SRCROOT)/ios/internals\"", "\"$(PODS_TARGET_SRCROOT)/ios/input/internals\""
+    ] + code_highlight[:header_paths].map { |p| "\"$(PODS_TARGET_SRCROOT)/#{p}\"" }).join(" "),
     'GCC_PREPROCESSOR_DEFINITIONS' => preprocessor_defs,
     'CLANG_CXX_LANGUAGE_STANDARD' => 'c++17',
     'DEFINES_MODULE' => 'YES'
   }
 
-  # Detect Apple Silicon on the host running `pod install`. `sysctl hw.optional.arm64`
-  # reports the real hardware even under a Rosetta-translated Ruby, unlike `uname -m`.
-  apple_silicon = `sysctl -n hw.optional.arm64 2>/dev/null`.strip == '1'
-
-  if enable_math && apple_silicon
-    # RaTeX's Swift wrapper is compiled from SPM source, so its RaTeX.swiftmodule
-    # is emitted only for the arch(es) the build requests. Under ONLY_ACTIVE_ARCH
-    # on Apple Silicon that is arm64 only, but universal simulator builds (archive,
-    # "Any iOS Simulator Device", Release) also compile this pod for x86_64 and then
-    # fail with "could not find module 'RaTeX' for target 'x86_64-apple-ios-simulator'".
-    # Excluding x86_64 for the simulator keeps the pod and the app target arch sets in
-    # sync. Guarded to Apple Silicon so Intel Macs (which build x86_64 simulator slices)
-    # are unaffected; `$(inherited)` preserves exclusions from the user project / other pods.
-    pod_xcconfig['EXCLUDED_ARCHS[sdk=iphonesimulator*]'] = '$(inherited) x86_64'
-    s.user_target_xcconfig = { 'EXCLUDED_ARCHS[sdk=iphonesimulator*]' => '$(inherited) x86_64' }
-  end
-
+  # No EXCLUDED_ARCHS dance: the vendored simulator slice (ios-arm64_x86_64-simulator)
+  # already contains x86_64, so universal simulator builds resolve on both arches.
   s.pod_target_xcconfig = pod_xcconfig
 
-  if enable_math
-    # React Native's spm_dependency generates a module.modulemap at
-    # ${BUILT_PRODUCTS_DIR}/include/ that re-declares RaTeXFFI, but the RaTeX
-    # XCFramework already ships its own definition. Strip the duplicate to
-    # prevent "redefinition of module 'RaTeXFFI'" during compilation.
-    s.script_phases = [
-      {
-        name: 'Fix RaTeXFFI Module Redefinition',
-        script: <<~'SCRIPT',
-          # The shared module.modulemap lives in the platform build-products dir,
-          # one level above the per-target BUILT_PRODUCTS_DIR that CocoaPods sets.
-          MODULEMAP="${BUILT_PRODUCTS_DIR}/../include/module.modulemap"
-          [ -f "$MODULEMAP" ] || exit 0
-          sed -i '' -E '/^(framework )?module RaTeXFFI /,/^\}/d' "$MODULEMAP"
-        SCRIPT
-        execution_position: :before_compile
-      },
-      {
-        name: 'Dedupe RaTeX XCFramework Signature',
-        script: <<~'SCRIPT',
-          # Xcode 26 generates a .signature file for each signed XCFramework.
-          # When the RaTeX XCFramework is consumed via spm_dependency inside a
-          # CocoaPods target, both the SPM product and the pod target produce a
-          # copy. During archive assembly Xcode copies all signatures into a flat
-          # Signatures/ directory, and the second copy collides with the first.
-          # Removing the pod-target copy prevents the collision. This is a no-op
-          # on older Xcode versions or simulator builds where the file is absent.
-          rm -f "${CONFIGURATION_BUILD_DIR}/RaTeX.xcframework-ios.signature"
-        SCRIPT
-        execution_position: :after_compile
-      }
-    ]
-  end
+  # No script phases: vendoring a single prebuilt XCFramework means there is no
+  # spm_dependency-generated duplicate RaTeXFFI modulemap to strip, and only one
+  # signature is collected during archive assembly, so nothing collides.
 
   install_modules_dependencies(s)
 end

package/android/build.gradle

@@ -23,7 +23,128 @@ def getExtOrIntegerDefault(name) {
   return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["EnrichedMarkdown_" + name]).toInteger()
 }
 
-def enableMath = (rootProject.findProperty("enrichedMarkdown.enableMath") ?: findProperty("enrichedMarkdown.enableMath") ?: "true").toString().toBoolean()
+// The consumer app's package.json "enriched-markdown" block is the build-time source of
+// truth for feature toggles (mirrors the iOS podspecs and react-native-worklets). It is
+// read from the Gradle build root -- "<app>/package.json", one level above the "<app>/android"
+// dir -- so in a monorepo it resolves to the app being built, not the workspace root.
+// Per-app config therefore works; the download side (postinstall) is a separate,
+// install-time decision. Gradle properties remain a deprecated fallback.
+def consumerConfig = [:]
+def consumerAppName = null
+def consumerPackageJson = new File(rootProject.projectDir, "../package.json")
+if (consumerPackageJson.exists()) {
+    def parsed = new groovy.json.JsonSlurper().parse(consumerPackageJson)
+    if (parsed instanceof Map) {
+        if (parsed["enriched-markdown"] instanceof Map) {
+            consumerConfig = parsed["enriched-markdown"]
+        }
+        consumerAppName = parsed["name"]
+    }
+}
+
+// Filesystem-safe per-app slug: package.json "name", else the app directory name -- the
+// same source and fallback the iOS podspec uses (installation root's parent), so both
+// platforms derive an identical slug for the same app. It keys the per-app generated
+// code-highlight registry (generated-<slug>) below so the artifact layout matches iOS and
+// two monorepo apps with different custom language sets never share one dir.
+def consumerAppSlug = (consumerAppName ?: rootProject.projectDir.parentFile?.name ?: "app").toString()
+    .replaceAll('[^A-Za-z0-9._-]+', '-').replaceAll('^-+|-+$', '')
+if (!consumerAppSlug) consumerAppSlug = "app"
+
+// Math: package.json > gradle property (deprecated) > default true. Android math is a
+// Maven dependency (no downloaded asset), so the flag simply includes or excludes it --
+// there is nothing to be missing, hence no throw as on iOS.
+def mathProp = rootProject.findProperty("enrichedMarkdown.enableMath") ?: findProperty("enrichedMarkdown.enableMath")
+def enableMath
+if (consumerConfig.containsKey("enableMath")) {
+    enableMath = consumerConfig.enableMath != false
+    if (mathProp != null) {
+        logger.warn("[ReactNativeEnrichedMarkdown] DEPRECATED: enrichedMarkdown.enableMath gradle property " +
+            "is ignored when \"enriched-markdown\".enableMath is set in your package.json.")
+    }
+} else if (mathProp != null) {
+    logger.warn("[ReactNativeEnrichedMarkdown] DEPRECATED: enrichedMarkdown.enableMath gradle property " +
+        "will be removed in a future version. Configure via \"enriched-markdown\".enableMath in your package.json instead.")
+    enableMath = mathProp.toString().toBoolean()
+} else {
+    enableMath = true
+}
+
+// Default grammar set derived from the single source of truth,
+// vendor/grammar-versions.json (every grammar with default:true), so the compiled
+// grammars always match the registry gen-registry generates from the same
+// manifest. Resolved in both layouts like gen-registry.mjs below:
+// "../../../vendor" in the monorepo, "../cpp/highlight" when published.
+def grammarManifest = [
+  new File(projectDir, "../../../vendor/grammar-versions.json"),
+  new File(projectDir, "../cpp/highlight/grammar-versions.json"),
+].find { it.exists() }
+if (grammarManifest == null) {
+  throw new GradleException("[code-highlight] grammar-versions.json not found; cannot resolve the default language set. Build from the monorepo or a published tarball.")
+}
+def defaultCodeHighlightLanguages = new groovy.json.JsonSlurper().parse(grammarManifest)
+  .grammars.findAll { id, spec -> spec['default'] }.collect { id, spec -> id }
+// Code highlight enable: package.json > gradle property (deprecated) > default on.
+// `codeHighlightExplicit` tracks an active opt-in (vs the implicit default), which
+// decides the missing-grammars behavior below.
+def codeHighlightProp = rootProject.findProperty("enrichedMarkdown.enableCodeHighlight") ?: findProperty("enrichedMarkdown.enableCodeHighlight")
+def codeHighlightStamp = new File(projectDir, "../cpp/highlight/vendor/grammars/.stamp")
+def codeHighlightRequested
+def codeHighlightExplicit
+if (consumerConfig.containsKey("enableCodeHighlight")) {
+    codeHighlightRequested = consumerConfig.enableCodeHighlight != false
+    codeHighlightExplicit = codeHighlightRequested
+    if (codeHighlightProp != null) {
+        logger.warn("[ReactNativeEnrichedMarkdown] DEPRECATED: enrichedMarkdown.enableCodeHighlight gradle property " +
+            "is ignored when \"enriched-markdown\".enableCodeHighlight is set in your package.json.")
+    }
+} else if (codeHighlightProp != null) {
+    logger.warn("[ReactNativeEnrichedMarkdown] DEPRECATED: enrichedMarkdown.enableCodeHighlight gradle property " +
+        "will be removed in a future version. Configure via \"enriched-markdown\".enableCodeHighlight in your package.json instead.")
+    codeHighlightRequested = codeHighlightProp.toString().toBoolean()
+    codeHighlightExplicit = codeHighlightRequested
+} else {
+    codeHighlightRequested = true
+    codeHighlightExplicit = false
+}
+
+// The grammars/.stamp marker is written only after every grammar source is fully vendored
+// at postinstall. An explicit opt-in with the grammars missing fails loud with the fix; on
+// by default but missing (a partial/failed download, or a monorepo root opt-out) falls back
+// to a clean no-op build. Gating on the stamp also keeps CMake from being fed missing sources.
+def enableCodeHighlight
+if (!codeHighlightRequested) {
+    enableCodeHighlight = false
+} else if (codeHighlightStamp.exists()) {
+    enableCodeHighlight = true
+} else if (codeHighlightExplicit) {
+    throw new GradleException("[ReactNativeEnrichedMarkdown] code highlighting is enabled but the tree-sitter " +
+        "grammars are not installed. Reinstall to fetch them: `npm rebuild react-native-enriched-markdown-scaffold`. " +
+        "To disable, set \"enriched-markdown\".enableCodeHighlight = false in your app package.json. " +
+        "Troubleshooting: https://github.com/software-mansion/enriched-markdown/blob/main/docs/NATIVE_ASSETS.md")
+} else {
+    enableCodeHighlight = false
+}
+
+// Languages: package.json > gradle property (deprecated) > manifest defaults. An explicit
+// empty array disables all languages (codeHighlightActive below); only the default/property
+// paths fall back to the manifest set.
+def codeHighlightLanguagesProp = rootProject.findProperty("enrichedMarkdown.codeHighlightLanguages") ?: findProperty("enrichedMarkdown.codeHighlightLanguages")
+def codeHighlightLanguages
+if (consumerConfig.get("codeHighlightLanguages") instanceof List) {
+    codeHighlightLanguages = consumerConfig.codeHighlightLanguages.collect { it.toString().trim() }.findAll { it }
+    if (codeHighlightLanguagesProp != null) {
+        logger.warn("[ReactNativeEnrichedMarkdown] DEPRECATED: enrichedMarkdown.codeHighlightLanguages gradle property " +
+            "is ignored when \"enriched-markdown\".codeHighlightLanguages is set in your package.json.")
+    }
+} else if (codeHighlightLanguagesProp) {
+    logger.warn("[ReactNativeEnrichedMarkdown] DEPRECATED: enrichedMarkdown.codeHighlightLanguages gradle property " +
+        "will be removed in a future version. Configure via \"enriched-markdown\".codeHighlightLanguages in your package.json instead.")
+    codeHighlightLanguages = codeHighlightLanguagesProp.toString().split(",").collect { it.trim() }.findAll { it }
+} else {
+    codeHighlightLanguages = defaultCodeHighlightLanguages
+}
+def codeHighlightActive = enableCodeHighlight && !codeHighlightLanguages.isEmpty()
 
 android {
   namespace "com.swmansion.enriched.markdown"
@@ -35,6 +156,7 @@ android {
     targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
     consumerProguardFiles "consumer-rules.pro"
     buildConfigField "boolean", "ENABLE_MATH", "${enableMath}"
+    buildConfigField "boolean", "ENABLE_CODE_HIGHLIGHT", "${codeHighlightActive}"
   }
 
   buildFeatures {
@@ -56,6 +178,17 @@ android {
     targetCompatibility JavaVersion.VERSION_1_8
   }
 
+  // JVM unit tests for the pure-Kotlin editor logic (serialization, range math).
+  // returnDefaultValues makes the android.jar stubs no-ops instead of throwing, so a
+  // class that only logs (MarkdownSerializer -> android.util.Log) is testable without
+  // pulling in Robolectric. Anything needing real Android behaviour belongs in the
+  // instrumented/Robolectric suite in packages/android-enriched-markdown/ui instead.
+  testOptions {
+    unitTests {
+      returnDefaultValues = true
+    }
+  }
+
   sourceSets {
     main {
       java.srcDirs += [
@@ -67,6 +200,62 @@ android {
       }
     }
   }
+
+  testOptions {
+    unitTests.includeAndroidResources = true
+  }
+}
+
+// Code-block syntax highlighting (tree-sitter) native wiring. This module owns
+// no externalNativeBuild block: RN autolinking compiles src/main/jni/CMakeLists.txt
+// as part of the consumer app's native build, so the app -- not this library --
+// owns the CMake arguments. The enable flag + selected grammars therefore reach
+// CMake through a config file written here during configuration (before any
+// native build task runs) and include()d by CMakeLists.txt.
+def highlightConfigDir = new File(projectDir, "build/generated/highlight")
+highlightConfigDir.mkdirs()
+def highlightConfigFile = new File(highlightConfigDir, "highlight-config.cmake")
+if (codeHighlightActive) {
+  def vendorDir = new File(projectDir, "../cpp/highlight/vendor").canonicalPath
+  def committedGenerated = new File(vendorDir, "generated")
+  def generatedDir
+  if (codeHighlightLanguages.toSorted() == defaultCodeHighlightLanguages.toSorted() && committedGenerated.exists()) {
+    // Common case: the committed default-set registry ships in-tree, no codegen.
+    generatedDir = committedGenerated
+  } else {
+    // Custom language set: regenerate the registry from the vendored .scm files into a
+    // per-app dir (generated-<slug>), mirroring iOS. Android rewrites this on every
+    // gradle configure so it never had iOS's persistent clash, but keying per app keeps
+    // the two platforms' artifact layout identical. (highlight-config.cmake itself stays
+    // at the CMakeLists-fixed shared path and is rewritten each configure.)
+    generatedDir = new File(highlightConfigDir, "generated-${consumerAppSlug}")
+    generatedDir.mkdirs()
+    def genScript = [
+      new File(projectDir, "../../../vendor/gen-registry.mjs"),
+      new File(projectDir, "../cpp/highlight/gen-registry.mjs"),
+    ].find { it.exists() }
+    if (genScript == null) {
+      throw new GradleException("enrichedMarkdown.codeHighlightLanguages is customized but vendor/gen-registry.mjs was not found. Use the default language set or build from the monorepo.")
+    }
+    // Run node directly via ProcessBuilder rather than Project.exec {}, which was
+    // removed in Gradle 9. Runs at configuration time (before the native build),
+    // and surfaces gen-registry's own stderr on failure.
+    def genCmd = ["node", genScript.canonicalPath, "--vendor-dir", vendorDir,
+                  "--languages", codeHighlightLanguages.join(","), "--out", generatedDir.canonicalPath]
+    def genProc = new ProcessBuilder(genCmd).redirectErrorStream(true).start()
+    def genOut = genProc.inputStream.text
+    def genExit = genProc.waitFor()
+    if (genExit != 0) {
+      throw new GradleException("[code-highlight] gen-registry.mjs failed (exit ${genExit}):\n${genOut}")
+    }
+  }
+  highlightConfigFile.text = """\
+set(ENRICHED_MARKDOWN_CODE_HIGHLIGHT ON)
+set(ENRICHED_MARKDOWN_HIGHLIGHT_LANGUAGES "${codeHighlightLanguages.join(';')}")
+set(ENRICHED_MARKDOWN_HIGHLIGHT_GENERATED_DIR "${generatedDir.canonicalPath.replace('\\', '/')}")
+"""
+} else {
+  highlightConfigFile.text = "set(ENRICHED_MARKDOWN_CODE_HIGHLIGHT OFF)\n"
 }
 
 repositories {
@@ -85,6 +274,7 @@ dependencies {
   if (enableMath) {
     implementation("io.github.erweixin:ratex-android:0.1.10")
   }
+  testImplementation "junit:junit:4.13.2"
 }
 
 react {

package/android/consumer-rules.pro

@@ -1,4 +1,4 @@
-# ProGuard/R8 consumer rules for react-native-enriched-markdown
+# ProGuard/R8 consumer rules for react-native-enriched-markdown-scaffold
 #
 # JNI: Classes accessed from C++ (jni-adapter.cpp) via FindClass/GetFieldID.
 # R8 cannot trace hardcoded string lookups in native code.

package/android/generated/java/com/facebook/react/viewmanagers/EnrichedMarkdownManagerDelegate.java

@@ -32,6 +32,9 @@ public class EnrichedMarkdownManagerDelegate<T extends View, U extends BaseViewM
       case "markdownStyle":
         mViewManager.setMarkdownStyle(view, (ReadableMap) value);
         break;
+      case "enableTaskListItemToggle":
+        mViewManager.setEnableTaskListItemToggle(view, value == null ? true : (boolean) value);
+        break;
       case "enableLinkPreview":
         mViewManager.setEnableLinkPreview(view, value == null ? true : (boolean) value);
         break;
@@ -65,9 +68,15 @@ public class EnrichedMarkdownManagerDelegate<T extends View, U extends BaseViewM
       case "spoilerOverlay":
         mViewManager.setSpoilerOverlay(view, value == null ? "particles" : (String) value);
         break;
+      case "contextMenuHidden":
+        mViewManager.setContextMenuHidden(view, value == null ? false : (boolean) value);
+        break;
       case "contextMenuItems":
         mViewManager.setContextMenuItems(view, (ReadableArray) value);
         break;
+      case "imageRequestHeaders":
+        mViewManager.setImageRequestHeaders(view, (ReadableArray) value);
+        break;
       case "selectionMenuConfig":
         mViewManager.setSelectionMenuConfig(view, (ReadableMap) value);
         break;

package/android/generated/java/com/facebook/react/viewmanagers/EnrichedMarkdownManagerInterface.java

@@ -18,6 +18,7 @@ import com.facebook.react.uimanager.ViewManagerWithGeneratedInterface;
 public interface EnrichedMarkdownManagerInterface<T extends View> extends ViewManagerWithGeneratedInterface {
   void setMarkdown(T view, @Nullable String value);
   void setMarkdownStyle(T view, @Nullable ReadableMap value);
+  void setEnableTaskListItemToggle(T view, boolean value);
   void setEnableLinkPreview(T view, boolean value);
   void setSelectable(T view, boolean value);
   void setSelectionColor(T view, @Nullable Integer value);
@@ -29,7 +30,9 @@ public interface EnrichedMarkdownManagerInterface<T extends View> extends ViewMa
   void setStreamingAnimation(T view, boolean value);
   void setStreamingConfig(T view, @Nullable ReadableMap value);
   void setSpoilerOverlay(T view, @Nullable String value);
+  void setContextMenuHidden(T view, boolean value);
   void setContextMenuItems(T view, @Nullable ReadableArray value);
+  void setImageRequestHeaders(T view, @Nullable ReadableArray value);
   void setSelectionMenuConfig(T view, @Nullable ReadableMap value);
   void setAccessibilityLabels(T view, @Nullable ReadableMap value);
   void setTextBreakStrategy(T view, @Nullable String value);

package/android/generated/java/com/facebook/react/viewmanagers/EnrichedMarkdownTextInputManagerDelegate.java

@@ -44,9 +44,15 @@ public class EnrichedMarkdownTextInputManagerDelegate<T extends View, U extends
       case "scrollEnabled":
         mViewManager.setScrollEnabled(view, value == null ? false : (boolean) value);
         break;
+      case "blockSyntax":
+        mViewManager.setBlockSyntax(view, value == null ? false : (boolean) value);
+        break;
       case "autoCapitalize":
         mViewManager.setAutoCapitalize(view, value == null ? null : (String) value);
         break;
+      case "interceptPaste":
+        mViewManager.setInterceptPaste(view, value == null ? false : (boolean) value);
+        break;
       case "multiline":
         mViewManager.setMultiline(view, value == null ? false : (boolean) value);
         break;
@@ -130,12 +136,30 @@ public class EnrichedMarkdownTextInputManagerDelegate<T extends View, U extends
       case "toggleSpoiler":
         mViewManager.toggleSpoiler(view);
         break;
+      case "toggleHeading":
+        mViewManager.toggleHeading(view, args.getInt(0));
+        break;
+      case "toggleUnorderedList":
+        mViewManager.toggleUnorderedList(view);
+        break;
+      case "toggleOrderedList":
+        mViewManager.toggleOrderedList(view);
+        break;
+      case "indentList":
+        mViewManager.indentList(view);
+        break;
+      case "outdentList":
+        mViewManager.outdentList(view);
+        break;
       case "setLink":
         mViewManager.setLink(view, args.getString(0));
         break;
       case "insertLink":
         mViewManager.insertLink(view, args.getString(0), args.getString(1));
         break;
+      case "insertText":
+        mViewManager.insertText(view, args.getString(0));
+        break;
       case "insertMention":
         mViewManager.insertMention(view, args.getString(0), args.getString(1));
         break;
@@ -157,6 +181,9 @@ public class EnrichedMarkdownTextInputManagerDelegate<T extends View, U extends
       case "copyToClipboard":
         mViewManager.copyToClipboard(view);
         break;
+      case "resolvePaste":
+        mViewManager.resolvePaste(view, args.getString(0), args.getString(1));
+        break;
       case "requestMarkdown":
         mViewManager.requestMarkdown(view, args.getInt(0));
         break;

package/android/generated/java/com/facebook/react/viewmanagers/EnrichedMarkdownTextInputManagerInterface.java

@@ -22,7 +22,9 @@ public interface EnrichedMarkdownTextInputManagerInterface<T extends View> exten
   void setEditable(T view, boolean value);
   void setAutoFocus(T view, boolean value);
   void setScrollEnabled(T view, boolean value);
+  void setBlockSyntax(T view, boolean value);
   void setAutoCapitalize(T view, @Nullable String value);
+  void setInterceptPaste(T view, boolean value);
   void setMultiline(T view, boolean value);
   void setCursorColor(T view, @Nullable Integer value);
   void setSelectionColor(T view, @Nullable Integer value);
@@ -48,8 +50,14 @@ public interface EnrichedMarkdownTextInputManagerInterface<T extends View> exten
   void toggleUnderline(T view);
   void toggleStrikethrough(T view);
   void toggleSpoiler(T view);
+  void toggleHeading(T view, int level);
+  void toggleUnorderedList(T view);
+  void toggleOrderedList(T view);
+  void indentList(T view);
+  void outdentList(T view);
   void setLink(T view, String url);
   void insertLink(T view, String text, String url);
+  void insertText(T view, String text);
   void insertMention(T view, String displayText, String url);
   void startMention(T view, String indicator);
   void removeLink(T view);
@@ -57,6 +65,7 @@ public interface EnrichedMarkdownTextInputManagerInterface<T extends View> exten
   void updateMath(T view, int start, String latex, boolean displayMode);
   void removeMath(T view, int start);
   void copyToClipboard(T view);
+  void resolvePaste(T view, String text, String markdown);
   void requestMarkdown(T view, int requestId);
   void requestCaretRect(T view, int requestId);
 }