react-native-enriched-markdown 1.0.1 → 1.0.2

package/cpp/highlight/code_highlight_podspec.rb

@@ -16,6 +16,58 @@
 
 require 'json'
 
+module EnrichedMarkdownConfig
+  @warnings_emitted = {}
+
+  def self.warn_once(key, message)
+    return if @warnings_emitted[key]
+    @warnings_emitted[key] = true
+    Pod::UI.warn message
+  end
+
+  # The consumer app's package.json "enriched-markdown" block is the build-time
+  # source of truth for feature toggles (mirrors the Android build.gradle and
+  # react-native-worklets). It is read from the Podfile's installation root --
+  # "<app>/package.json", one level above the "<app>/ios" dir CocoaPods installs
+  # into -- 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. ENV vars remain a deprecated fallback.
+  #
+  # A cheap accessor over the memoized package.json (see consumer_package_json), so both
+  # this file (code highlighting) and the main podspec (math) can read it without re-parsing.
+  def self.consumer_config
+    config = consumer_package_json['enriched-markdown']
+    config.is_a?(Hash) ? config : {}
+  end
+
+  # A filesystem-safe identifier for the app being built, derived from its package.json
+  # "name" (falling back to the app directory name). It keys the per-app generated
+  # code-highlight registry (generated-<slug>) so that, in a hoisted monorepo, two apps
+  # with different custom language sets each get their own registry instead of clobbering
+  # a single shared one.
+  def self.consumer_app_slug
+    name = consumer_package_json['name'].to_s
+    name = File.basename(File.dirname(Pod::Config.instance.installation_root.to_s)) if name.empty?
+    slug = name.gsub(%r{[^A-Za-z0-9._-]+}, '-').gsub(/\A-+|-+\z/, '')
+    slug.empty? ? 'app' : slug
+  end
+
+  def self.consumer_package_json
+    return @consumer_package_json if defined?(@consumer_package_json)
+    @consumer_package_json = load_consumer_package_json
+  end
+
+  def self.load_consumer_package_json
+    path = File.join(Pod::Config.instance.installation_root.to_s, '..', 'package.json')
+    return {} unless File.exist?(path)
+    JSON.parse(File.read(path))
+  rescue StandardError => e
+    Pod::UI.warn "[ReactNativeEnrichedMarkdown] could not read the app package.json " \
+      "(#{e.message}); using defaults."
+    {}
+  end
+end
+
 module EnrichedMarkdownCodeHighlight
   # Locate grammar-versions.json in both layouts, mirroring how gen-registry.mjs
   # is resolved below: "<podspec_dir>/../../vendor" in the monorepo, and the copy
@@ -40,29 +92,70 @@ module EnrichedMarkdownCodeHighlight
   # podspec_dir is the directory of the including podspec; cpp is reached at
   # "<podspec_dir>/cpp" (a symlink in the monorepo, real files when published).
   def self.config(podspec_dir)
-    return disabled if ENV['ENRICHED_MARKDOWN_ENABLE_CODE_HIGHLIGHT'] == '0'
+    config = EnrichedMarkdownConfig.consumer_config
+    env_enable = ENV['ENRICHED_MARKDOWN_ENABLE_CODE_HIGHLIGHT']
+
+    # Enable flag: package.json > ENV (deprecated) > default on. `explicit` tracks
+    # whether the consumer actively opted in (vs the implicit default), which decides
+    # the missing-asset behavior below.
+    if config.key?('enableCodeHighlight')
+      requested = config['enableCodeHighlight'] != false
+      explicit = requested
+      if env_enable
+        EnrichedMarkdownConfig.warn_once(:code_highlight_env, '[ReactNativeEnrichedMarkdown] DEPRECATED: ENV[\'ENRICHED_MARKDOWN_ENABLE_CODE_HIGHLIGHT\'] ' \
+          'is ignored when "enriched-markdown".enableCodeHighlight is set in your package.json.')
+      end
+    elsif env_enable
+      EnrichedMarkdownConfig.warn_once(:code_highlight_env, '[ReactNativeEnrichedMarkdown] DEPRECATED: ENV[\'ENRICHED_MARKDOWN_ENABLE_CODE_HIGHLIGHT\'] ' \
+        'will be removed in a future version. Configure via "enriched-markdown".enableCodeHighlight in your package.json instead.')
+      requested = env_enable != '0'
+      explicit = requested
+    else
+      requested = true
+      explicit = false
+    end
 
-    # Code highlighting compiles the vendored tree-sitter runtime + grammar sources,
-    # downloaded at postinstall. The grammars/.stamp marker is written only after every
-    # grammar source is fully vendored, so gating on it (rather than the runtime lib.c,
-    # which is fetched first) also falls back to the no-op stub on a partial/failed
-    # download -- not just a `enriched-markdown`.enableCodeHighlight = false opt-out.
-    return disabled unless File.exist?(File.join(podspec_dir, 'cpp/highlight/vendor/grammars/.stamp'))
+    return disabled unless requested
+
+    # The grammars/.stamp marker is written only after every grammar source is fully
+    # vendored at postinstall. If the consumer explicitly enabled highlighting but the
+    # grammars are absent (opted out of the download, or a partial/failed one), fail
+    # loud with the fix. If highlighting is merely on by default, degrade to the no-op
+    # stub so a missing download never breaks an otherwise-unconfigured build.
+    unless File.exist?(File.join(podspec_dir, 'cpp/highlight/vendor/grammars/.stamp'))
+      if explicit
+        raise '[ReactNativeEnrichedMarkdown] code highlighting is enabled but the tree-sitter ' \
+          'grammars are not installed. Reinstall to fetch them: `npm rebuild react-native-enriched-markdown`. ' \
+          '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'
+      end
+      return disabled
+    end
 
     defaults = default_languages(podspec_dir)
-    langs = (ENV['ENRICHED_MARKDOWN_CODE_HIGHLIGHT_LANGUAGES'] || '')
-            .split(',').map(&:strip).reject(&:empty?)
-    langs = defaults.dup if langs.empty?
+    # Languages: package.json > ENV (deprecated) > manifest defaults. An explicit empty
+    # array disables all languages (return disabled below); only the default/ENV paths
+    # fall back to the manifest set.
+    if config['codeHighlightLanguages'].is_a?(Array)
+      langs = config['codeHighlightLanguages'].map { |l| l.to_s.strip }.reject(&:empty?)
+    elsif (env_langs = ENV['ENRICHED_MARKDOWN_CODE_HIGHLIGHT_LANGUAGES']) && !env_langs.empty?
+      EnrichedMarkdownConfig.warn_once(:code_highlight_languages_env, '[ReactNativeEnrichedMarkdown] DEPRECATED: ENV[\'ENRICHED_MARKDOWN_CODE_HIGHLIGHT_LANGUAGES\'] ' \
+        'will be removed in a future version. Configure via "enriched-markdown".codeHighlightLanguages in your package.json instead.')
+      langs = env_langs.split(',').map(&:strip).reject(&:empty?)
+      langs = defaults.dup if langs.empty?
+    else
+      langs = defaults.dup
+    end
     return disabled if langs.empty?
 
     vendor = File.join(podspec_dir, 'cpp/highlight/vendor')
-    # A custom language set regenerates its registry into a SEPARATE dir so it never
-    # clobbers the committed default-set registry in vendor/generated. That committed
-    # dir is the shared source of truth other default builds -- and the Android build
-    # -- rely on staying the default set; overwriting it in place with a custom set
-    # leaves the next default build linking a mismatched grammar list.
+    # A custom language set regenerates its registry into a per-app dir
+    # (generated-<app-slug>), never the committed default-set registry in vendor/generated.
+    # Keying by app (not by "generated-custom") means two apps in a hoisted monorepo with
+    # different custom sets each get their own registry instead of clobbering a single
+    # shared one -- which would leave the other app linking a mismatched grammar list.
     custom = langs.sort != defaults.sort
-    generated_rel = custom ? 'cpp/highlight/vendor/generated-custom' : 'cpp/highlight/vendor/generated'
+    generated_rel = custom ? "cpp/highlight/vendor/generated-#{EnrichedMarkdownConfig.consumer_app_slug}" : 'cpp/highlight/vendor/generated'
     generated = File.join(podspec_dir, generated_rel)
     ensure_registry(podspec_dir, vendor, generated, langs, custom)
 

package/docs/BREAKING_CHANGES.md

@@ -0,0 +1,87 @@
+# Breaking changes
+
+This file tracks breaking changes and how to migrate for each. Entries are newest first. Deprecations
+(things that still work but are slated for removal) are noted alongside the change that introduces them.
+
+## Unreleased
+
+### The Expo config plugin was removed
+
+The built-in Expo config plugin (`app.plugin.js` and the `plugin/` folder) has been removed. Feature
+configuration now lives entirely in your app's `package.json`, read directly by the native build and by
+`postinstall` — the same approach `react-native-worklets` uses for its static feature flags.
+
+Why: the plugin only wrote the (now deprecated) Podfile `ENV` / `gradle.properties` channels, it could
+never influence the install-time asset download (it runs during `expo prebuild`, *after* `npm install`),
+and its option shape diverged from the `package.json` block. The `package.json` block supersedes it for
+both the download and the build, and it survives `expo prebuild`.
+
+**Migrate:** remove the plugin entry from `app.json` / `app.config.js` and move the options into the
+`enriched-markdown` block of your `package.json`.
+
+Before (`app.json`):
+
+```json
+{
+  "expo": {
+    "plugins": [
+      ["react-native-enriched-markdown", {
+        "enableMath": false,
+        "codeHighlight": { "enabled": true, "languages": ["javascript", "tsx"] }
+      }]
+    ]
+  }
+}
+```
+
+After (`package.json`):
+
+```json
+{
+  "enriched-markdown": {
+    "enableMath": false,
+    "enableCodeHighlight": true,
+    "codeHighlightLanguages": ["javascript", "tsx"]
+  }
+}
+```
+
+Note the key renames: the plugin's `codeHighlight.enabled` / `codeHighlight.languages` become
+`enableCodeHighlight` / `codeHighlightLanguages`. Then run `pod install` (iOS) or rebuild (Android).
+These are compile/link-time settings, so they apply only in builds you compile yourself (a custom dev
+client or `expo prebuild`) — they cannot be changed in Expo Go, which ships a fixed prebuilt binary.
+
+The `@expo/config-plugins` peer dependency was dropped as part of this removal.
+
+### Feature config moved to `package.json`; ENV vars and gradle properties are deprecated
+
+The `enriched-markdown` block in your app's `package.json` is now the single source of truth for
+`enableMath`, `enableCodeHighlight`, and `codeHighlightLanguages` on both platforms — the native build
+reads it directly at `pod install` / Gradle configuration time. The previous build flags still work as a
+fallback but are deprecated, print a warning, and are ignored when the matching `package.json` key is set:
+
+| Deprecated flag | Replaced by (`package.json` `enriched-markdown`) |
+|---|---|
+| Podfile `ENV['ENRICHED_MARKDOWN_ENABLE_MATH']` / gradle `enrichedMarkdown.enableMath` | `enableMath` |
+| Podfile `ENV['ENRICHED_MARKDOWN_ENABLE_CODE_HIGHLIGHT']` / gradle `enrichedMarkdown.enableCodeHighlight` | `enableCodeHighlight` |
+| Podfile `ENV['ENRICHED_MARKDOWN_CODE_HIGHLIGHT_LANGUAGES']` / gradle `enrichedMarkdown.codeHighlightLanguages` | `codeHighlightLanguages` |
+
+In a monorepo the *build* flag is read from the app's `package.json` (the one beside `ios/`/`android/`),
+so each app configures independently. The *download* opt-out is read where the install runs — usually the
+workspace root — so put it in the root `package.json` to skip a download for the whole repo. See
+[Native assets](./NATIVE_ASSETS.md).
+
+### Explicitly enabling a feature whose assets are missing now fails the build
+
+Previously, a missing native asset (the RaTeX XCFramework, or the tree-sitter grammars) always silently
+disabled the feature. Now, if you **explicitly** set `enableMath: true` or `enableCodeHighlight: true` but
+the asset was not downloaded (for example an install with `--ignore-scripts`, or a monorepo root opt-out
+that an app overrides), the build fails with an actionable error instead of degrading. Features left on by
+default still degrade to a clean build. To fix, restore the assets:
+
+```sh
+node node_modules/react-native-enriched-markdown/postinstall.mjs
+# or: npm rebuild react-native-enriched-markdown
+```
+
+then re-run `pod install` (iOS) / rebuild (Android).

package/docs/CODE_HIGHLIGHT.md

@@ -51,7 +51,7 @@ The copy label shown to assistive technologies is configurable via
 
 ## Supported languages
 
-Fence info strings map to a grammar (for example `js`, `jsx` -> JavaScript). The **curated default
+Fence info strings map to a grammar (for example `js` and `jsx` both select JavaScript). The **curated default
 set** is compiled in unless you override it. It is defined by `default:true` in
 `vendor/grammar-versions.json` (the single source of truth the iOS podspec and Android build both
 derive from), so the table below tracks that manifest:
@@ -69,62 +69,38 @@ A block whose language is not compiled in simply renders as plain (uncolored) co
 Only the grammars you compile end up in your binary, so trimming the list is the main size lever.
 The seam degrades to plain code whenever a grammar is absent, so nothing breaks when you remove one.
 
-> [!TIP]
-> To also skip the install-time grammar download (not just the build-time linking), set
-> `"enriched-markdown": { "enableCodeHighlight": false }` in your app's `package.json`. This
-> auto-disables highlighting at build time too, so it's an alternative to the build flags below.
-> See [Skipping the download](./NATIVE_ASSETS.md#skipping-the-download-opt-out).
-
-### iOS
-
-Add to your `Podfile` and re-run `pod install`:
-
-```ruby
-# Compile a custom set (comma-separated; adds tsx to the trimmed set below):
-ENV['ENRICHED_MARKDOWN_CODE_HIGHLIGHT_LANGUAGES'] = 'javascript,tsx,json,bash'
-
-# ...or disable highlighting entirely (no tree-sitter code linked):
-ENV['ENRICHED_MARKDOWN_ENABLE_CODE_HIGHLIGHT'] = '0'
-```
-
-### Android
-
-Add to your project's `gradle.properties`:
-
-```properties
-# Compile a custom set:
-enrichedMarkdown.codeHighlightLanguages=javascript,tsx,json,bash
-
-# ...or disable highlighting entirely:
-enrichedMarkdown.enableCodeHighlight=false
-```
-
-Rebuild the app after changing either value.
-
-### Expo config plugin
-
-Configure both platforms at once in `app.json` / `app.config.js`:
+Configure everything through the `enriched-markdown` block of your app's `package.json` — it is the
+single source of truth for both platforms and both the install-time download and the build:
 
 ```json
 {
-  "expo": {
-    "plugins": [
-      [
-        "react-native-enriched-markdown",
-        {
-          "codeHighlight": {
-            "enabled": true,
-            "languages": ["javascript", "tsx", "json", "bash"]
-          }
-        }
-      ]
-    ]
+  "enriched-markdown": {
+    "enableCodeHighlight": true,
+    "codeHighlightLanguages": ["javascript", "tsx", "json", "bash"]
   }
 }
 ```
 
-Set `"enabled": false` to disable it. Changes are applied during `npx expo prebuild`; if you change
-the set later, run `npx expo prebuild --clean` and rebuild.
+How the two keys interact:
+
+- **`enableCodeHighlight`** (default `true`) is the master switch. When `false`, the grammar download is
+  skipped **and** the tree-sitter runtime is excluded from the native build. In that state
+  **`codeHighlightLanguages` is ignored — it is a no-op**, because there is no highlighter compiled in for
+  languages to feed.
+- **`codeHighlightLanguages`** selects which grammars to compile *when highlighting is enabled*. Omit it
+  for the curated default set, or pass a subset to shrink the binary. An empty array (`[]`) compiles no
+  grammars, which disables highlighting entirely — equivalent to `enableCodeHighlight: false`.
+
+Re-run `pod install` (iOS) / rebuild (Android) after changing these. The same block works with Expo —
+`node_modules` survives `npx expo prebuild`, so no config plugin is needed (highlighting is compiled in,
+so it can't be changed in **Expo Go**; use a dev client or `expo prebuild`). See
+[Skipping the download](./NATIVE_ASSETS.md#skipping-the-download-opt-out).
+
+> [!NOTE]
+> **Deprecated:** the `ENV['ENRICHED_MARKDOWN_*']` Podfile variables and the `enrichedMarkdown.*` gradle
+> properties still work as a fallback but are deprecated and print a warning; they are ignored when the
+> corresponding `package.json` key is set. The Expo config plugin was removed — see
+> [Breaking changes](./BREAKING_CHANGES.md). Prefer the `package.json` block above.
 
 ## How it works
 

package/docs/LATEX_MATH.md

@@ -80,21 +80,27 @@ Set `latexMath: false` in `md4cFlags` so the parser treats `$` as plain text:
 
 This alone prevents math rendering without any native changes. The steps below go further by removing the native math libraries from your binary entirely.
 
-### 2. Remove the native iOS dependency
+### 2. Remove the native dependency
 
-Add the following to your Podfile and re-run `pod install`:
+Set `enableMath` to `false` in the `enriched-markdown` block of your app's `package.json`:
 
-```ruby
-ENV['ENRICHED_MARKDOWN_ENABLE_MATH'] = '0'
+```json
+{
+  "enriched-markdown": {
+    "enableMath": false
+  }
+}
 ```
 
-This excludes **RaTeX** from the build. Rebuild the app after running `pod install`.
+This is the single source of truth for both platforms: `postinstall` skips the install-time RaTeX
+download, and the native build reads the same block directly to exclude **RaTeX** from the binary — no
+Podfile or `gradle.properties` edit needed. Re-run `pod install` (iOS) / rebuild (Android) after
+changing it. See [Skipping the download](./NATIVE_ASSETS.md#skipping-the-download-opt-out).
 
-> [!TIP]
-> To also skip the install-time RaTeX download (not just the build-time linking), set
-> `"enriched-markdown": { "enableMath": false }` in your app's `package.json`. Because the iOS build
-> auto-disables math when the framework is absent, this opt-out needs no Podfile edit. See
-> [Skipping the download](./NATIVE_ASSETS.md#skipping-the-download-opt-out).
+> [!NOTE]
+> **Deprecated:** the `ENV['ENRICHED_MARKDOWN_ENABLE_MATH']` Podfile variable and the
+> `enrichedMarkdown.enableMath` gradle property still work as a fallback but are deprecated and print a
+> warning; they are ignored when the `package.json` block sets `enableMath`.
 
 > [!NOTE]
 > When math is **enabled** (the default), no special Podfile configuration is required.
@@ -106,16 +112,15 @@ This excludes **RaTeX** from the build. Rebuild the app after running `pod insta
 > [!NOTE]
 > The RaTeX XCFramework is **not** bundled in the npm tarball — it is downloaded at install time by
 > a `postinstall` script (see [Native assets](./NATIVE_ASSETS.md)). If `ios/vendor/RaTeX.xcframework`
-> is missing (offline install, `--ignore-scripts`, pnpm, or a `package.json` opt-out), `pod install`
-> auto-disables math and prints a warning instead of failing. To restore math, run
-> `node node_modules/react-native-enriched-markdown/postinstall.mjs` and re-run `pod install`, or
-> force it with `ENV['ENRICHED_MARKDOWN_ENABLE_MATH'] = '1'` (which turns the missing framework back
-> into a hard error).
+> is missing (offline install, `--ignore-scripts`, pnpm, or a `package.json` opt-out) and math is only
+> on by default, `pod install` auto-disables math and prints a warning instead of failing. If you
+> **explicitly** set `"enableMath": true`, a missing framework is a hard error instead. Either way, run
+> `node node_modules/react-native-enriched-markdown/postinstall.mjs` and re-run `pod install` to restore it.
 
 > [!IMPORTANT]
 > **Upgrading from a version that used `use_frameworks! :linkage => :dynamic` for math?**
 > The pod changed from a dynamic framework to a static library. After `pod install`,
-> do a one-time clean build (Xcode: Product → Clean Build Folder, or delete the app's
+> do a one-time clean build (Xcode: Product > Clean Build Folder, or delete the app's
 > DerivedData) — a stale build folder otherwise fails with
 > `ReactNativeEnrichedMarkdown.framework/Modules/module.modulemap not found`. Fresh
 > installs are unaffected.
@@ -126,37 +131,14 @@ This excludes **RaTeX** from the build. Rebuild the app after running `pod insta
 > no longer applies now that RaTeX is a vendored XCFramework with a macOS slice, so macOS
 > support is a possible future follow-up.
 
-### 3. Remove the native Android dependency
-
-Add the following to your project's `gradle.properties`:
-
-```properties
-enrichedMarkdown.enableMath=false
-```
-
-This excludes **RaTeX** from the Android build. Rebuild the app after changing this property.
-
-### 4. Expo config plugin
+### 3. Expo
 
-If you are using Expo, you can use the built-in config plugin to disable LaTeX math rendering on both platforms at once.
+The `package.json` block above works with Expo too — `node_modules` (and the resolved config) survive
+`npx expo prebuild`, so no config plugin is needed. Set `"enriched-markdown": { "enableMath": false }` in
+your app's `package.json` and rebuild.
 
-Add the following to your `app.json` or `app.config.js`:
-
-```json
-{
-  "expo": {
-    "plugins": [
-      [
-        "react-native-enriched-markdown",
-        {
-          "enableMath": false
-        }
-      ]
-    ]
-  }
-}
-```
-
-This will automatically apply both the [iOS](#2-remove-the-native-ios-dependency) and [Android](#3-remove-the-native-android-dependency) native changes listed above during `npx expo prebuild`.
-
-If you later re-enable math (e.g. remove the plugin or set `enableMath: true`), run `npx expo prebuild --clean` so native projects are regenerated without the disable flags, then rebuild.
+> [!NOTE]
+> Because `enableMath` is a compile/link-time decision, it only applies in builds you compile yourself
+> (a custom dev client or `expo prebuild`). It **cannot** be changed in **Expo Go**, which ships a fixed
+> prebuilt binary. A dedicated config plugin was removed in favor of the `package.json` block — see
+> [Breaking changes](./BREAKING_CHANGES.md).

package/docs/NATIVE_ASSETS.md

@@ -34,16 +34,29 @@ them.
   Windows, but RaTeX is iOS-only so this only affects Windows dev machines and is non-fatal.
 
 The postinstall step **never fails the install**: if a download does not complete it prints a warning
-and exits successfully. When an asset is missing the native build treats the corresponding feature as
-disabled (code highlighting compiles a no-op stub; iOS math is skipped with a CocoaPods warning), so
-the build stays green. To turn a feature back on after fixing the download, re-run the recovery command
-below, or force it via its build flag (`ENV['ENRICHED_MARKDOWN_ENABLE_MATH'] = '1'` /
-`enrichedMarkdown.enableCodeHighlight=true`), which restores the actionable missing-asset error.
+and exits successfully. What the native build does when an asset is missing depends on whether you
+**explicitly enabled** the feature in your app `package.json`:
+
+- **On by default** (no `enriched-markdown` entry for it): the build treats the feature as disabled —
+  code highlighting compiles a no-op stub, iOS math is skipped with a CocoaPods warning — so the build
+  stays green.
+- **Explicitly enabled** (`"enableMath": true` / `"enableCodeHighlight": true`): the build **fails with
+  an actionable error** telling you to re-run postinstall, because you asked for a feature whose assets
+  are not present.
+
+To fix a missing download, re-run the recovery command below.
 
 ## Re-running or recovering
 
-If installs happened offline, behind a firewall, or with scripts disabled, restore the assets by
-re-running the script from your project root:
+If a download didn't complete (offline, behind a firewall, or with scripts disabled), reinstall the
+package to re-fetch the assets:
+
+```sh
+npm rebuild react-native-enriched-markdown
+```
+
+If your package manager blocks or skips that (pnpm, Yarn PnP, `--ignore-scripts`), run the vendor script
+directly from your project root as a fallback:
 
 ```sh
 node node_modules/react-native-enriched-markdown/postinstall.mjs
@@ -85,12 +98,25 @@ downloads its assets. Add an `enriched-markdown` block (both fields default to `
 
 `enableCodeHighlight: false` skips the tree-sitter runtime + grammar download (iOS and Android);
 `enableMath: false` skips the RaTeX download (iOS; Android math uses a Maven dependency and is
-unaffected). Because the native build keys off whether the assets are present on disk, a
-`package.json` opt-out **also disables the feature at build time** — no Podfile or `gradle.properties`
-edit needed. Re-run the install (or the recovery command above) after changing these values.
-
-This is read from the consumer project only (via `INIT_CWD`); it has no effect inside this repo's own
-monorepo development.
+unaffected). The native build reads the same `enriched-markdown` block directly (iOS podspec /
+Android `build.gradle`), so a `package.json` opt-out **also disables the feature at build time** — no
+Podfile or `gradle.properties` edit needed. Disabling takes effect on the next `pod install` / native
+rebuild; re-enabling also needs a reinstall so the assets download again.
+
+> [!IMPORTANT]
+> **Applying a change on iOS.** The podspec reads `package.json` at `pod install` time, not at build
+> time, so a plain rebuild (`run-ios` / Xcode build) reuses the previously resolved pod — you must run
+> `pod install` after editing the `enriched-markdown` block. And when you **change a feature that was
+> already compiled in** (disabling it, or narrowing `codeHighlightLanguages`), also do a **clean build**
+> (`Product > Clean Build Folder`, or delete the app's DerivedData): Xcode's incremental build does not
+> reliably rebuild the pod's static library when only its source list changes, so it can otherwise link a
+> stale copy that still contains the old code. Android reconfigures on every build and needs neither step.
+
+**Which `package.json`?** The *download* opt-out is read from wherever the install runs (via `INIT_CWD`)
+— in a monorepo that is the workspace root, and there is one shared `node_modules`, so the download
+opt-out is global. The *build* flag is read from the **app's** `package.json` (the one beside `ios/` /
+`android/`), so each app in a monorepo enables or disables features independently. Neither has any
+effect inside this repo's own monorepo development.
 
 ## Disabling the features at build time
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "react-native-enriched-markdown",
-  "version": "1.0.1",
-  "description": "Markdown Text component for React Native",
+  "version": "1.0.2",
+  "description": "Markdown-based Rich Text solution for React Native",
   "main": "./lib/module/index",
   "module": "./lib/module/index",
   "source": "./src/index.tsx",
@@ -31,8 +31,6 @@
     "!**/__fixtures__",
     "!**/__mocks__",
     "!**/.*",
-    "app.plugin.js",
-    "plugin",
     "docs"
   ],
   "scripts": {
@@ -46,14 +44,13 @@
     "lint-clang:android:fix": "find android/ \\( -iname \"*.h\" -o -iname \"*.cpp\" \\) | grep -v -e build | xargs npx clang-format -i",
     "lint-clang": "yarn lint-clang:ios && yarn lint-clang:android",
     "lint-clang:fix": "yarn lint-clang:ios:fix && yarn lint-clang:android:fix",
-    "clean": "del-cli android/build lib plugin/build",
+    "clean": "del-cli android/build lib",
     "sync-md4c": "bash ../../scripts/fetch-md4c.sh",
     "vendor-grammars": "node ../../vendor/vendor-grammars.mjs",
     "vendor-ratex": "node ../../vendor/vendor-ratex.mjs",
     "prepack": "bash ../../scripts/prepare-npm-publish.sh prepack",
     "postpack": "bash ../../scripts/prepare-npm-publish.sh postpack",
-    "build:plugin": "tsc -p plugin/tsconfig.build.json",
-    "prepare": "yarn vendor-grammars && yarn vendor-ratex && bob build && yarn build:plugin"
+    "prepare": "yarn vendor-grammars && yarn vendor-ratex && bob build"
   },
   "keywords": [
     "react-native",
@@ -67,35 +64,30 @@
   ],
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/software-mansion/react-native-enriched-markdown.git",
+    "url": "git+https://github.com/software-mansion/enriched-markdown.git",
     "directory": "packages/react-native-enriched-markdown"
   },
   "author": "Gregory Moskaliuk <mosckalyuck@gmail.com> (https://github.com/hryhoriiK97)",
   "license": "MIT",
   "bugs": {
-    "url": "https://github.com/software-mansion/react-native-enriched-markdown/issues"
+    "url": "https://github.com/software-mansion/enriched-markdown/issues"
   },
   "homepage": "https://enriched.swmansion.com/markdown",
   "publishConfig": {
     "registry": "https://registry.npmjs.org/"
   },
   "peerDependencies": {
-    "@expo/config-plugins": ">=50.0.0",
     "katex": ">=0.16.0",
     "react": "*",
     "react-native": "*"
   },
   "peerDependenciesMeta": {
-    "@expo/config-plugins": {
-      "optional": true
-    },
     "katex": {
       "optional": true
     }
   },
   "devDependencies": {
     "@babel/core": "^7.25.0",
-    "@expo/config-plugins": "^55.0.6",
     "@react-native/babel-preset": "0.85.0",
     "@react-native/jest-preset": "0.85.0",
     "@tree-sitter-grammars/tree-sitter-markdown": "0.3.2",

package/postinstall.mjs

@@ -30,9 +30,14 @@ if (!fs.existsSync(grammarManifest)) {
 // Both features default to enabled (opt-out, not opt-in). Any resolution failure
 // (INIT_CWD unset, unreadable/malformed JSON, absent key) falls back to downloading
 // everything -- a skipped download is far cheaper to recover from than a silently
-// missing feature. The native build mirrors this by keying off asset presence on
-// disk (see the podspecs and android/build.gradle), so a package.json opt-out alone
-// yields a clean build with no Podfile/gradle edits.
+// missing feature. In a monorepo INIT_CWD is the workspace root where the install
+// ran, so the download opt-out lives in the root package.json (one shared node_modules).
+//
+// The native build reads the *app* package.json directly (via the podspec's
+// installation root / gradle's build root -- see the podspecs and android/build.gradle),
+// which is a separate per-app decision. It reconciles that flag with asset presence on
+// disk: an explicit opt-in with the asset missing fails loud, a default-on with it
+// missing degrades to a clean build.
 function resolveConsumerConfig() {
   const initCwd = process.env.INIT_CWD;
   if (!initCwd) {
@@ -48,8 +53,27 @@ function resolveConsumerConfig() {
 }
 
 const consumerConfig = resolveConsumerConfig();
-const enableCodeHighlight = consumerConfig.enableCodeHighlight !== false;
-const enableMath = consumerConfig.enableMath !== false;
+
+// This script only decides what to DOWNLOAD into node_modules. The native build
+// (podspec + build.gradle) reads the app package.json directly to decide what to
+// compile/link, so nothing is written here for it to consume. The `codeHighlightLanguages`
+// subset is a build-time concern (a language subset is selected from the full downloaded
+// grammar set), so it is intentionally not read here. ENV vars are a deprecated fallback,
+// honored only when package.json has no explicit value.
+let enableCodeHighlight = consumerConfig.enableCodeHighlight;
+let enableMath = consumerConfig.enableMath;
+
+if (enableCodeHighlight === undefined && process.env.ENRICHED_MARKDOWN_ENABLE_CODE_HIGHLIGHT) {
+  console.warn(`${LOG} DEPRECATED: ENRICHED_MARKDOWN_ENABLE_CODE_HIGHLIGHT env var will be removed in a future version. Configure via "enriched-markdown".enableCodeHighlight in your package.json instead.`);
+  enableCodeHighlight = process.env.ENRICHED_MARKDOWN_ENABLE_CODE_HIGHLIGHT !== '0';
+}
+if (enableMath === undefined && process.env.ENRICHED_MARKDOWN_ENABLE_MATH) {
+  console.warn(`${LOG} DEPRECATED: ENRICHED_MARKDOWN_ENABLE_MATH env var will be removed in a future version. Configure via "enriched-markdown".enableMath in your package.json instead.`);
+  enableMath = process.env.ENRICHED_MARKDOWN_ENABLE_MATH !== '0';
+}
+
+enableCodeHighlight = enableCodeHighlight !== false;
+enableMath = enableMath !== false;
 
 if (!enableCodeHighlight && !enableMath) {
   console.log(`${LOG} both code highlighting and math are disabled via package.json ("enriched-markdown"); skipping postinstall.`);

package/app.plugin.js

@@ -1,2 +0,0 @@
-module.exports =
-  require('./plugin/build/withReactNativeEnrichedMarkdown').default;