react-native-enriched-markdown-scaffold 0.7.4-scaffold.10 → 0.7.4-scaffold.11

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

@@ -50,6 +50,9 @@ public class EnrichedMarkdownTextInputManagerDelegate<T extends View, U extends
       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;
@@ -160,6 +163,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

@@ -24,6 +24,7 @@ public interface EnrichedMarkdownTextInputManagerInterface<T extends View> exten
   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);
@@ -58,6 +59,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);
 }

package/android/generated/jni/react/renderer/components/EnrichedMarkdownTextSpec/EventEmitters.cpp

@@ -247,6 +247,16 @@ payload.setProperty(runtime, "height", event.height);
 }
 
 
+void EnrichedMarkdownTextInputEventEmitter::onPaste(OnPaste event) const {
+  dispatchEvent("paste", [event=std::move(event)](jsi::Runtime &runtime) {
+    auto payload = jsi::Object(runtime);
+    payload.setProperty(runtime, "text", event.text);
+payload.setProperty(runtime, "markdown", event.markdown);
+    return payload;
+  });
+}
+
+
 void EnrichedMarkdownTextInputEventEmitter::onStartMention(OnStartMention event) const {
   dispatchEvent("startMention", [event=std::move(event)](jsi::Runtime &runtime) {
     auto payload = jsi::Object(runtime);

package/android/generated/jni/react/renderer/components/EnrichedMarkdownTextSpec/EventEmitters.h

@@ -182,6 +182,11 @@ class EnrichedMarkdownTextInputEventEmitter : public ViewEventEmitter {
     double height;
     };
 
+  struct OnPaste {
+      std::string text;
+    std::string markdown;
+    };
+
   struct OnStartMention {
       std::string indicator;
     };
@@ -218,6 +223,8 @@ class EnrichedMarkdownTextInputEventEmitter : public ViewEventEmitter {
 
   void onMathPress(OnMathPress value) const;
 
+  void onPaste(OnPaste value) const;
+
   void onStartMention(OnStartMention value) const;
 
   void onChangeMention(OnChangeMention value) const;

package/android/generated/jni/react/renderer/components/EnrichedMarkdownTextSpec/Props.cpp

@@ -146,6 +146,7 @@ EnrichedMarkdownTextInputProps::EnrichedMarkdownTextInputProps(
     scrollEnabled(convertRawProp(context, rawProps, "scrollEnabled", sourceProps.scrollEnabled, {false})),
     blockSyntax(convertRawProp(context, rawProps, "blockSyntax", sourceProps.blockSyntax, {false})),
     autoCapitalize(convertRawProp(context, rawProps, "autoCapitalize", sourceProps.autoCapitalize, {})),
+    interceptPaste(convertRawProp(context, rawProps, "interceptPaste", sourceProps.interceptPaste, {false})),
     multiline(convertRawProp(context, rawProps, "multiline", sourceProps.multiline, {false})),
     cursorColor(convertRawProp(context, rawProps, "cursorColor", sourceProps.cursorColor, {})),
     selectionColor(convertRawProp(context, rawProps, "selectionColor", sourceProps.selectionColor, {})),
@@ -211,6 +212,10 @@ folly::dynamic EnrichedMarkdownTextInputProps::getDiffProps(
     result["autoCapitalize"] = autoCapitalize;
   }
     
+  if (interceptPaste != oldProps->interceptPaste) {
+    result["interceptPaste"] = interceptPaste;
+  }
+    
   if (multiline != oldProps->multiline) {
     result["multiline"] = multiline;
   }

package/android/generated/jni/react/renderer/components/EnrichedMarkdownTextSpec/Props.h

@@ -3361,6 +3361,7 @@ class EnrichedMarkdownTextInputProps final : public ViewProps {
   bool scrollEnabled{false};
   bool blockSyntax{false};
   std::string autoCapitalize{};
+  bool interceptPaste{false};
   bool multiline{false};
   SharedColor cursorColor{};
   SharedColor selectionColor{};

package/android/src/main/java/com/swmansion/enriched/markdown/input/EnrichedMarkdownTextInputManager.kt

@@ -27,6 +27,7 @@ import com.swmansion.enriched.markdown.input.events.OnInputBlurEvent
 import com.swmansion.enriched.markdown.input.events.OnInputFocusEvent
 import com.swmansion.enriched.markdown.input.events.OnLinkDetectedEvent
 import com.swmansion.enriched.markdown.input.events.OnMathPressEvent
+import com.swmansion.enriched.markdown.input.events.OnPasteEvent
 import com.swmansion.enriched.markdown.input.events.OnRequestCaretRectResultEvent
 import com.swmansion.enriched.markdown.input.events.OnRequestMarkdownResultEvent
 import com.swmansion.enriched.markdown.input.events.OnStartMentionEvent
@@ -112,6 +113,7 @@ class EnrichedMarkdownTextInputManager :
       OnContextMenuItemPressEvent.EVENT_NAME,
       OnLinkDetectedEvent.EVENT_NAME,
       OnMathPressEvent.EVENT_NAME,
+      OnPasteEvent.EVENT_NAME,
       OnStartMentionEvent.EVENT_NAME,
       OnChangeMentionEvent.EVENT_NAME,
       OnEndMentionEvent.EVENT_NAME,
@@ -186,6 +188,14 @@ class EnrichedMarkdownTextInputManager :
     view?.setAutoCapitalize(value)
   }
 
+  @ReactProp(name = "interceptPaste", defaultBoolean = false)
+  override fun setInterceptPaste(
+    view: EnrichedMarkdownTextInputView?,
+    value: Boolean,
+  ) {
+    view?.interceptPaste = value
+  }
+
   @ReactProp(name = "multiline", defaultBoolean = true)
   override fun setMultiline(
     view: EnrichedMarkdownTextInputView?,
@@ -517,6 +527,14 @@ class EnrichedMarkdownTextInputManager :
     view?.copyToClipboard()
   }
 
+  override fun resolvePaste(
+    view: EnrichedMarkdownTextInputView?,
+    text: String?,
+    markdown: String?,
+  ) {
+    view?.resolvePaste(text ?: "", markdown ?: "")
+  }
+
   override fun requestMarkdown(
     view: EnrichedMarkdownTextInputView?,
     requestId: Int,

package/android/src/main/java/com/swmansion/enriched/markdown/input/EnrichedMarkdownTextInputView.kt

@@ -20,6 +20,9 @@ import android.view.inputmethod.EditorInfo
 import android.view.inputmethod.InputConnection
 import android.view.inputmethod.InputMethodManager
 import androidx.appcompat.widget.AppCompatEditText
+import androidx.core.view.ContentInfoCompat
+import androidx.core.view.OnReceiveContentListener
+import androidx.core.view.ViewCompat
 import com.facebook.react.common.ReactConstants
 import com.facebook.react.uimanager.BackgroundStyleApplicator
 import com.facebook.react.uimanager.PixelUtil
@@ -44,6 +47,7 @@ import com.swmansion.enriched.markdown.input.model.MathChipStyle
 import com.swmansion.enriched.markdown.input.model.StyleType
 import com.swmansion.enriched.markdown.input.toolbar.InputContextMenu
 import com.swmansion.enriched.markdown.utils.input.AutoCapitalizeUtils
+import com.swmansion.enriched.markdown.utils.input.PasteTextUtils
 import kotlin.math.ceil
 
 private fun Char.isLineBreak(): Boolean = this == '\n' || this == '\r' || this == '\u0085' || this == '\u2028' || this == '\u2029'
@@ -97,6 +101,25 @@ class EnrichedMarkdownTextInputView(
   private var detectScrollMovement = false
   var scrollEnabled: Boolean = true
 
+  // When on, a paste is reported to JS instead of inserted. Native never touches
+  // the buffer here (see resolvePaste): if JS dies mid-handler the paste is a
+  // visible no-op rather than a selection that silently vanished.
+  //
+  // The listener is installed only while the prop is on. Registering it
+  // unconditionally would route every consumer's paste through AppCompat's
+  // receive-content path even with the feature off, which is a behavior change
+  // nobody asked for.
+  var interceptPaste: Boolean = false
+    set(value) {
+      if (field == value) return
+      field = value
+      ViewCompat.setOnReceiveContentListener(
+        this,
+        if (value) PASTE_MIME_TYPES else null,
+        if (value) receiveContentListener else null,
+      )
+    }
+
   // The markdown last handed over by JS, kept so `blockSyntax` can re-parse it. @ReactProp
   // setters fire in undefined order, so `defaultValue` regularly lands before the flag does.
   private var lastMarkdownFromJS: String? = null
@@ -488,6 +511,98 @@ class EnrichedMarkdownTextInputView(
     clipboard.setPrimaryClip(ClipData.newPlainText(null, content))
   }
 
+  // Paste arrives by two different routes and only the first one is a menu.
+  // `onTextContextMenuItem` covers the context menu and the hardware Ctrl+V /
+  // KEYCODE_PASTE shortcuts; drag-and-drop, autofill and IME `commitContent`
+  // reach the view through `onReceiveContent` instead. Hooking only one of them
+  // leaves the other pasting straight into the buffer with nobody intercepting.
+  override fun onTextContextMenuItem(id: Int): Boolean {
+    val isPaste = id == android.R.id.paste || id == android.R.id.pasteAsPlainText
+    if (isPaste && interceptPaste) {
+      val text = readClipboardText()
+      if (text.isNotEmpty()) {
+        eventEmitter.emitPaste(text, "")
+        // Stops super, which is what keeps this single-emit: AppCompat routes
+        // its own paste handling through the receive-content listener below.
+        return true
+      }
+      // Nothing textual in the clip: hand it to the platform, matching what the
+      // listener does with the items it does not claim. Both routes then decide
+      // from the same rule, so a clip never behaves differently depending on
+      // whether it came from the menu or from Ctrl+V.
+    }
+    return super.onTextContextMenuItem(id)
+  }
+
+  private val receiveContentListener =
+    OnReceiveContentListener { _, payload ->
+      // The listener also sees autofill, drag-and-drop, IME commitContent and
+      // PROCESS_TEXT. Without this filter an autofill would turn into a paste
+      // event — and a consumer would turn that into an attachment chip.
+      if (!interceptPaste || payload.source != ContentInfoCompat.SOURCE_CLIPBOARD) {
+        return@OnReceiveContentListener payload
+      }
+      val parts = payload.partition { it.text != null }
+      parts.first?.let { accepted ->
+        val clip = accepted.clip
+        val text = PasteTextUtils.joinClipTexts((0 until clip.itemCount).map { clip.getItemAt(it).text })
+        if (text.isNotEmpty()) {
+          eventEmitter.emitPaste(text, "")
+        }
+      }
+      // Hand back only what we did not claim, so the buffer stays untouched.
+      parts.second
+    }
+
+  private fun readClipboardText(): String {
+    val clipboard = context.getSystemService(Context.CLIPBOARD_SERVICE) as? ClipboardManager ?: return ""
+    val clip = clipboard.primaryClip ?: return ""
+    // `text`, not `coerceToText`: the listener can only claim items that already
+    // carry text, and the two routes have to agree on what counts as a paste.
+    return PasteTextUtils.joinClipTexts((0 until clip.itemCount).map { clip.getItemAt(it).text })
+  }
+
+  /**
+   * Completes a paste reported through `onPaste`. `markdown` is accepted for
+   * parity with iOS but ignored here: Android's clipboard is plain text only
+   * (see `copyToClipboard`), so there is no flavor to restore.
+   *
+   * Resolving with an empty string and an empty selection is a zero-length edit
+   * — it still emits, which keeps the JS contract identical on both platforms.
+   */
+  fun resolvePaste(
+    pastedText: String,
+    @Suppress("UNUSED_PARAMETER") markdown: String,
+  ) {
+    val editable = text ?: return
+    val selStart = selectionStart.coerceAtLeast(0)
+    val selEnd = selectionEnd.coerceAtLeast(selStart)
+    val safeStart = selStart.coerceAtMost(editable.length)
+    val safeEnd = selEnd.coerceAtMost(editable.length)
+
+    isProcessingTextChange = true
+    try {
+      editable.replace(safeStart, safeEnd, pastedText)
+      formattingStore.adjustForEdit(safeStart, safeEnd - safeStart, pastedText.length)
+      lastProcessedText = editable.toString()
+      setSelection(safeStart + pastedText.length)
+    } finally {
+      isProcessingTextChange = false
+    }
+
+    applyFormatting()
+    // Parity with the un-intercepted paste, which reached the detectors through
+    // the text watcher: a pasted URL still autolinks.
+    detectorPipeline.processTextChange(editable, editable.toString(), safeStart, pastedText.length)
+    invalidate()
+    requestLayout()
+    eventEmitter.emitChangeText()
+    if (emitMarkdown) eventEmitter.emitChangeMarkdown()
+    eventEmitter.emitSelection(selectionStart, selectionEnd)
+    eventEmitter.emitState()
+    eventEmitter.emitCaretRectChangeIfNeeded()
+  }
+
   fun setLinkForSelection(url: String) {
     val selStart = selectionStart
     val selEnd = selectionEnd
@@ -1155,6 +1270,10 @@ class EnrichedMarkdownTextInputView(
       .replace("(", "%28")
       .replace(")", "%29")
 
+  private companion object {
+    private val PASTE_MIME_TYPES = arrayOf("text/*")
+  }
+
   private data class MentionCandidate(
     val indicator: String,
     val start: Int,

package/android/src/main/java/com/swmansion/enriched/markdown/input/events/OnPasteEvent.kt

@@ -0,0 +1,24 @@
+package com.swmansion.enriched.markdown.input.events
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.events.Event
+
+class OnPasteEvent(
+  surfaceId: Int,
+  viewId: Int,
+  private val text: String,
+  private val markdown: String,
+) : Event<OnPasteEvent>(surfaceId, viewId) {
+  override fun getEventName(): String = EVENT_NAME
+
+  override fun getEventData(): WritableMap =
+    Arguments.createMap().apply {
+      putString("text", text)
+      putString("markdown", markdown)
+    }
+
+  companion object {
+    const val EVENT_NAME = "onPaste"
+  }
+}

package/android/src/main/java/com/swmansion/enriched/markdown/input/layout/InputEventEmitter.kt

@@ -16,6 +16,7 @@ import com.swmansion.enriched.markdown.input.events.OnInputBlurEvent
 import com.swmansion.enriched.markdown.input.events.OnInputFocusEvent
 import com.swmansion.enriched.markdown.input.events.OnLinkDetectedEvent
 import com.swmansion.enriched.markdown.input.events.OnMathPressEvent
+import com.swmansion.enriched.markdown.input.events.OnPasteEvent
 import com.swmansion.enriched.markdown.input.events.OnRequestCaretRectResultEvent
 import com.swmansion.enriched.markdown.input.events.OnRequestMarkdownResultEvent
 import com.swmansion.enriched.markdown.input.events.OnStartMentionEvent
@@ -99,6 +100,13 @@ class InputEventEmitter(
     dispatch(OnMathPressEvent(surfaceId(), view.id, latex, start, end, displayMode, x, y, width, height))
   }
 
+  fun emitPaste(
+    text: String,
+    markdown: String,
+  ) {
+    dispatch(OnPasteEvent(surfaceId(), view.id, text, markdown))
+  }
+
   fun emitStartMention(indicator: String) {
     dispatch(OnStartMentionEvent(surfaceId(), view.id, indicator))
   }

package/android/src/main/java/com/swmansion/enriched/markdown/utils/input/PasteTextUtils.kt

@@ -0,0 +1,20 @@
+package com.swmansion.enriched.markdown.utils.input
+
+/**
+ * The pure half of the paste interception path. A `ClipData` cannot be built on
+ * the JVM, so the joining rule lives here where a unit test can reach it; the
+ * two call sites (context menu and `onReceiveContent`) only extract the items.
+ */
+object PasteTextUtils {
+  /**
+   * Flattens a clip's items into one string. A clip regularly carries more than
+   * one item — reading only `getItemAt(0)` silently drops items 2..n. Items
+   * without text (a URI or intent) are skipped, and the rest join on newlines,
+   * which is what the platform's own paste does.
+   */
+  fun joinClipTexts(texts: List<CharSequence?>): String =
+    texts
+      .mapNotNull { it?.toString() }
+      .filter { it.isNotEmpty() }
+      .joinToString("\n")
+}

package/docs/API_REFERENCE.md

@@ -532,6 +532,18 @@ Auto-capitalization behavior.
 | -------- | -------------- | -------- |
 | `string` | `'sentences'`  | Both     |
 
+### `interceptPaste`
+
+Reports pastes through [`onPaste`](#onpaste) instead of inserting them. Only takes effect when `onPaste` is also set — otherwise native would swallow every paste with nobody left to resolve it, so the library keeps the prop off.
+
+See [Intercepting paste](./INPUT.md#intercepting-paste).
+
+| Type      | Default Value | Platform      |
+| --------- | ------------- | ------------- |
+| `boolean` | `false`       | iOS, Android  |
+
+macOS ignores this prop and always pastes inline.
+
 ### `multiline`
 
 Whether the input supports multiple lines.
@@ -710,6 +722,18 @@ Fires when the active mention flow ends.
 | ---- | ------------- | -------- |
 | `(event: { indicator: string }) => void` | - | Both |
 
+### `onPaste`
+
+Fires instead of the insert when [`interceptPaste`](#interceptpaste) is on. Native reads the clipboard and leaves the buffer untouched, so the handler owns the paste from that point: it must call [`resolvePaste`](#resolvepastetext-string-markdown-string) exactly once, on every path including failures, or the paste is silently dropped.
+
+| Type | Default Value | Platform |
+| ---- | ------------- | -------- |
+| `(event: { text: string; markdown: string }) => void` | - | iOS, Android |
+
+`markdown` is non-empty only when the copy source was an `EnrichedMarkdownTextInput`, which the system clipboard can only carry on iOS; Android always reports `''`.
+
+See [Intercepting paste](./INPUT.md#intercepting-paste).
+
 ### `writingDirection`
 
 Paragraph writing direction in the input. iOS only — Android's `EditText` already resolves direction per paragraph via `TEXT_DIRECTION_FIRST_STRONG` and is unaffected by this prop.
@@ -942,6 +966,16 @@ Copies the input's full content to the system clipboard, matching the result of
 
 On iOS and macOS the clipboard receives both plain text and a private Markdown pasteboard type, so pasting back into an `EnrichedMarkdownTextInput` restores the formatting; external apps receive plain text only. On Android the clipboard receives plain text only — inline styles are not preserved for any paste target.
 
+### `resolvePaste(text: string, markdown?: string)`
+
+Completes a paste reported through [`onPaste`](#onpaste). Call it exactly once per event:
+
+- `resolvePaste(text, markdown)` — inserts, restoring the copied formatting when `markdown` is non-empty.
+- `resolvePaste(text)` — inserts `text` verbatim.
+- `resolvePaste('', '')` — drops the clipboard content, replacing the current selection. With an empty selection this is a no-op that still emits `onChangeText` with unchanged content.
+
+Anything that replaces a selection replaces it here too, so a paste over selected text behaves the same on every branch.
+
 ### `startMention(indicator: string)`
 
 Programmatically triggers a mention flow by inserting the indicator character at the current cursor position. The indicator must be listed in the `mentionIndicators` prop. Useful for toolbar buttons.

package/docs/INPUT.md

@@ -205,6 +205,45 @@ The input's content can be copied to the system clipboard from a ref, without re
 
 On iOS and macOS the clipboard receives both plain text and a private Markdown pasteboard type, so pasting back into an `EnrichedMarkdownTextInput` restores the formatting; external apps receive plain text only. On Android the clipboard receives plain text only — inline styles are not preserved for any paste target.
 
+## Intercepting paste
+
+By default a paste goes straight into the buffer. Set [`interceptPaste`](API_REFERENCE.md#interceptpaste) together with [`onPaste`](API_REFERENCE.md#onpaste) to decide what a paste means before any text lands — turning a long paste into an attachment chip, stripping it, or inserting it unchanged.
+
+```tsx
+const inputRef = useRef<EnrichedMarkdownTextInputInstance>(null);
+
+<EnrichedMarkdownTextInput
+  ref={inputRef}
+  interceptPaste
+  onPaste={({ text, markdown }) => {
+    if (text.length > 2000) {
+      attachAsFile(text);
+      inputRef.current?.resolvePaste('', ''); // drops it, and replaces the selection
+      return;
+    }
+    inputRef.current?.resolvePaste(text, markdown);
+  }}
+/>
+```
+
+Native reads the clipboard and **does not touch the buffer**. That makes the handler the only thing that can complete the paste, so the contract is strict:
+
+- Call [`resolvePaste`](API_REFERENCE.md#resolvepastetext-string-markdown-string) **exactly once per event, on every path including failures**. A handler that throws before resolving leaves the paste dropped — the user sees nothing happen.
+- Pass `markdown` back through when inserting. It is the copied formatting; dropping it turns a copy-then-paste inside your app into flat text.
+- `interceptPaste` is ignored unless `onPaste` is set, so switching the prop on alone cannot make the input swallow pastes.
+
+Because nothing is written until you resolve, an async decision is safe: the selection is still there, and the user sees an unchanged input rather than text that vanished.
+
+### Platform behavior
+
+| | Behavior |
+| --- | --- |
+| **iOS** | Context menu and hardware ⌘V. `markdown` is set when the copy source was an `EnrichedMarkdownTextInput`. |
+| **Android** | Context menu, hardware Ctrl+V and `KEYCODE_PASTE`. `markdown` is always `''` — the Android clipboard carries plain text only. |
+| **macOS** | `interceptPaste` is ignored, `onPaste` never fires, and pastes insert inline as usual. |
+
+Only clipboard content is intercepted. Drag-and-drop, autofill and IME content insertion bypass `onPaste` on both platforms and insert normally — on Android they are filtered out explicitly, so an autofill never arrives looking like a paste.
+
 ## Style Detection
 
 All of the above styles can be detected with the use of [onChangeState](API_REFERENCE.md#onchangestate) callback payload.

package/ios/generated/ReactCodegen/EnrichedMarkdownTextSpec/EventEmitters.cpp

@@ -247,6 +247,16 @@ payload.setProperty(runtime, "height", event.height);
 }
 
 
+void EnrichedMarkdownTextInputEventEmitter::onPaste(OnPaste event) const {
+  dispatchEvent("paste", [event=std::move(event)](jsi::Runtime &runtime) {
+    auto payload = jsi::Object(runtime);
+    payload.setProperty(runtime, "text", event.text);
+payload.setProperty(runtime, "markdown", event.markdown);
+    return payload;
+  });
+}
+
+
 void EnrichedMarkdownTextInputEventEmitter::onStartMention(OnStartMention event) const {
   dispatchEvent("startMention", [event=std::move(event)](jsi::Runtime &runtime) {
     auto payload = jsi::Object(runtime);

package/ios/generated/ReactCodegen/EnrichedMarkdownTextSpec/EventEmitters.h

@@ -182,6 +182,11 @@ class EnrichedMarkdownTextInputEventEmitter : public ViewEventEmitter {
     double height;
     };
 
+  struct OnPaste {
+      std::string text;
+    std::string markdown;
+    };
+
   struct OnStartMention {
       std::string indicator;
     };
@@ -218,6 +223,8 @@ class EnrichedMarkdownTextInputEventEmitter : public ViewEventEmitter {
 
   void onMathPress(OnMathPress value) const;
 
+  void onPaste(OnPaste value) const;
+
   void onStartMention(OnStartMention value) const;
 
   void onChangeMention(OnChangeMention value) const;

package/ios/generated/ReactCodegen/EnrichedMarkdownTextSpec/Props.cpp

@@ -146,6 +146,7 @@ EnrichedMarkdownTextInputProps::EnrichedMarkdownTextInputProps(
     scrollEnabled(convertRawProp(context, rawProps, "scrollEnabled", sourceProps.scrollEnabled, {false})),
     blockSyntax(convertRawProp(context, rawProps, "blockSyntax", sourceProps.blockSyntax, {false})),
     autoCapitalize(convertRawProp(context, rawProps, "autoCapitalize", sourceProps.autoCapitalize, {})),
+    interceptPaste(convertRawProp(context, rawProps, "interceptPaste", sourceProps.interceptPaste, {false})),
     multiline(convertRawProp(context, rawProps, "multiline", sourceProps.multiline, {false})),
     cursorColor(convertRawProp(context, rawProps, "cursorColor", sourceProps.cursorColor, {})),
     selectionColor(convertRawProp(context, rawProps, "selectionColor", sourceProps.selectionColor, {})),
@@ -211,6 +212,10 @@ folly::dynamic EnrichedMarkdownTextInputProps::getDiffProps(
     result["autoCapitalize"] = autoCapitalize;
   }
     
+  if (interceptPaste != oldProps->interceptPaste) {
+    result["interceptPaste"] = interceptPaste;
+  }
+    
   if (multiline != oldProps->multiline) {
     result["multiline"] = multiline;
   }

package/ios/generated/ReactCodegen/EnrichedMarkdownTextSpec/Props.h

@@ -3361,6 +3361,7 @@ class EnrichedMarkdownTextInputProps final : public ViewProps {
   bool scrollEnabled{false};
   bool blockSyntax{false};
   std::string autoCapitalize{};
+  bool interceptPaste{false};
   bool multiline{false};
   SharedColor cursorColor{};
   SharedColor selectionColor{};

package/ios/generated/ReactCodegen/EnrichedMarkdownTextSpec/RCTComponentViewHelpers.h

@@ -36,6 +36,7 @@ NS_ASSUME_NONNULL_BEGIN
 - (void)updateMath:(NSInteger)start latex:(NSString *)latex displayMode:(BOOL)displayMode;
 - (void)removeMath:(NSInteger)start;
 - (void)copyToClipboard;
+- (void)resolvePaste:(NSString *)text markdown:(NSString *)markdown;
 - (void)requestMarkdown:(NSInteger)requestId;
 - (void)requestCaretRect:(NSInteger)requestId;
 @end
@@ -399,6 +400,34 @@ if ([commandName isEqualToString:@"copyToClipboard"]) {
   return;
 }
 
+if ([commandName isEqualToString:@"resolvePaste"]) {
+#if RCT_DEBUG
+  if ([args count] != 2) {
+    RCTLogError(@"%@ command %@ received %d arguments, expected %d.", @"EnrichedMarkdownTextInput", commandName, (int)[args count], 2);
+    return;
+  }
+#endif
+
+  NSObject *arg0 = args[0];
+#if RCT_DEBUG
+  if (!RCTValidateTypeOfViewCommandArgument(arg0, [NSString class], @"string", @"EnrichedMarkdownTextInput", commandName, @"1st")) {
+    return;
+  }
+#endif
+  NSString * text = (NSString *)arg0;
+
+NSObject *arg1 = args[1];
+#if RCT_DEBUG
+  if (!RCTValidateTypeOfViewCommandArgument(arg1, [NSString class], @"string", @"EnrichedMarkdownTextInput", commandName, @"2nd")) {
+    return;
+  }
+#endif
+  NSString * markdown = (NSString *)arg1;
+
+  [componentView resolvePaste:text markdown:markdown];
+  return;
+}
+
 if ([commandName isEqualToString:@"requestMarkdown"]) {
 #if RCT_DEBUG
   if ([args count] != 1) {

package/ios/input/ENRMInputTextView.mm

@@ -46,12 +46,22 @@ NSString *const kENRMMarkdownPasteboardType = @"com.swmansion.enriched-markdown.
     markdown = [[NSString alloc] initWithData:markdownValue encoding:NSUTF8StringEncoding];
   }
 
+  NSString *plainText = pasteboard.string;
+
+  // Both flavors are read before anything is decided, then nothing is written:
+  // JS owns the paste from here and must call resolvePaste. Mutating the buffer
+  // first would mean a handler that dies mid-flight leaves the selection gone
+  // with no text to show for it — a no-op paste is the visible failure.
+  if (self.markdownTextInput.interceptPaste && (plainText.length > 0 || markdown.length > 0)) {
+    [self.markdownTextInput emitOnPasteWithText:(plainText ?: @"") markdown:(markdown ?: @"")];
+    return;
+  }
+
   if (markdown.length > 0 && self.markdownTextInput != nil) {
     [self.markdownTextInput pasteMarkdown:markdown];
     return;
   }
 
-  NSString *plainText = pasteboard.string;
   if (plainText.length > 0) {
     [self replaceRange:self.selectedTextRange withText:plainText];
   }

package/ios/input/EnrichedMarkdownTextInput.h

@@ -8,12 +8,17 @@ NS_ASSUME_NONNULL_BEGIN
 
 @interface EnrichedMarkdownTextInput : RCTViewComponentView
 @property (nonatomic, assign) BOOL blockEmitting;
+@property (nonatomic, assign) BOOL interceptPaste;
 - (CGSize)measureSize:(CGFloat)maxWidth;
 - (nullable NSString *)markdownForSelectedRange;
 - (void)copyToClipboard;
 - (void)pasteMarkdown:(NSString *)markdown;
 - (void)replaceSelectedTextWith:(NSString *)text formattingRanges:(NSArray *)ranges;
 - (void)scheduleRelayoutIfNeeded;
+// Paste interception. Declared here rather than in +Internal.h because
+// ENRMInputTextView.mm only imports that header on macOS.
+- (void)emitOnPasteWithText:(NSString *)text markdown:(NSString *)markdown;
+- (void)resolvePaste:(NSString *)text markdown:(NSString *)markdown;
 @end
 
 NS_ASSUME_NONNULL_END