react-native-enriched-markdown-scaffold 1.0.2-scaffold.4 → 1.0.2-scaffold.5

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

@@ -14,9 +14,33 @@
 NS_ASSUME_NONNULL_BEGIN
 
 @protocol RCTEnrichedMarkdownViewProtocol <NSObject>
-
+- (void)clearSelection;
 @end
 
+RCT_EXTERN inline void RCTEnrichedMarkdownHandleCommand(
+  id<RCTEnrichedMarkdownViewProtocol> componentView,
+  NSString const *commandName,
+  NSArray const *args)
+{
+  if ([commandName isEqualToString:@"clearSelection"]) {
+#if RCT_DEBUG
+  if ([args count] != 0) {
+    RCTLogError(@"%@ command %@ received %d arguments, expected %d.", @"EnrichedMarkdown", commandName, (int)[args count], 0);
+    return;
+  }
+#endif
+
+  
+
+  [componentView clearSelection];
+  return;
+}
+
+#if RCT_DEBUG
+  RCTLogError(@"%@ received command %@, which is not a supported command.", @"EnrichedMarkdown", commandName);
+#endif
+}
+
 @protocol RCTEnrichedMarkdownTextInputViewProtocol <NSObject>
 - (void)focus;
 - (void)blur;
@@ -576,7 +600,31 @@ if ([commandName isEqualToString:@"requestCaretRect"]) {
 }
 
 @protocol RCTEnrichedMarkdownTextViewProtocol <NSObject>
-
+- (void)clearSelection;
 @end
 
+RCT_EXTERN inline void RCTEnrichedMarkdownTextHandleCommand(
+  id<RCTEnrichedMarkdownTextViewProtocol> componentView,
+  NSString const *commandName,
+  NSArray const *args)
+{
+  if ([commandName isEqualToString:@"clearSelection"]) {
+#if RCT_DEBUG
+  if ([args count] != 0) {
+    RCTLogError(@"%@ command %@ received %d arguments, expected %d.", @"EnrichedMarkdownText", commandName, (int)[args count], 0);
+    return;
+  }
+#endif
+
+  
+
+  [componentView clearSelection];
+  return;
+}
+
+#if RCT_DEBUG
+  RCTLogError(@"%@ received command %@, which is not a supported command.", @"EnrichedMarkdownText", commandName);
+#endif
+}
+
 NS_ASSUME_NONNULL_END

package/ios/utils/ENRMLinkChip.m

@@ -177,18 +177,18 @@ void ENRMDrawLinkChipsForGlyphRange(NSLayoutManager *layoutManager, NSTextContai
 
   // Enumerate the whole storage (like CodeBackground) so a chip that starts
   // before the dirty range still gets its full rect.
-  [storage enumerateAttribute:ENRMLinkChipAttributeName
-                      inRange:NSMakeRange(0, storage.length)
-                      options:0
-                   usingBlock:^(ENRMLinkChip *chip, NSRange range, BOOL *stop) {
-                     if (!chip.isVisible || NSIntersectionRange(range, charRange).length == 0)
-                       return;
-
-                     ENRMEnumerateLinkChipFragments(
-                         layoutManager, textContainer, range, chip, ^(CGRect rect, BOOL isFirst, BOOL isLast) {
-                           ENRMDrawChipFragment(CGRectOffset(rect, origin.x, origin.y), chip.backgroundColor,
-                                                chip.borderColor, chip.borderWidth, chip.borderRadius, isFirst, isLast,
-                                                YES);
-                         });
-                   }];
+  [storage
+      enumerateAttribute:ENRMLinkChipAttributeName
+                 inRange:NSMakeRange(0, storage.length)
+                 options:0
+              usingBlock:^(ENRMLinkChip *chip, NSRange range, BOOL *stop) {
+                if (!chip.isVisible || NSIntersectionRange(range, charRange).length == 0)
+                  return;
+
+                ENRMEnumerateLinkChipFragments(
+                    layoutManager, textContainer, range, chip, ^(CGRect rect, BOOL isFirst, BOOL isLast) {
+                      ENRMDrawChipFragment(CGRectOffset(rect, origin.x, origin.y), chip.backgroundColor,
+                                           chip.borderColor, chip.borderWidth, chip.borderRadius, isFirst, isLast, YES);
+                    });
+              }];
 }

package/ios/utils/ENRMLinkLayout.m

@@ -24,18 +24,18 @@ NSArray<NSDictionary *> *ENRMCollectLinkLayoutFragments(ENRMPlatformTextView *te
                        NSString *text = ENRMPlainTextByRemovingLinkSpacers(storage, range);
                        NSNumber *index = @(linkIndex++);
 
-                       ENRMEnumerateLinkChipFragments(
-                           layoutManager, textContainer, range, chip, ^(CGRect rect, BOOL isFirst, BOOL isLast) {
-                             [fragments addObject:@{
-                               @"linkIndex" : index,
-                               @"url" : url ?: @"",
-                               @"text" : text,
-                               @"x" : @(rect.origin.x + offset.x),
-                               @"y" : @(rect.origin.y + offset.y),
-                               @"width" : @(rect.size.width),
-                               @"height" : @(rect.size.height),
-                             }];
-                           });
+                       ENRMEnumerateLinkChipFragments(layoutManager, textContainer, range, chip,
+                                                      ^(CGRect rect, BOOL isFirst, BOOL isLast) {
+                                                        [fragments addObject:@{
+                                                          @"linkIndex" : index,
+                                                          @"url" : url ?: @"",
+                                                          @"text" : text,
+                                                          @"x" : @(rect.origin.x + offset.x),
+                                                          @"y" : @(rect.origin.y + offset.y),
+                                                          @"width" : @(rect.size.width),
+                                                          @"height" : @(rect.size.height),
+                                                        }];
+                                                      });
                      }];
   }
 

package/ios/utils/ENRMSelectionChange.h

@@ -0,0 +1,96 @@
+#pragma once
+#import "ENRMUIKit.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// Keys of an `onSelectionChange` payload. Rects are `NSValue`-wrapped CGRects in
+/// the reporting view's coordinates, so a payload compares with `-isEqual:` for
+/// deduplication.
+extern NSString *const ENRMSelectionActiveKey;
+extern NSString *const ENRMSelectionSourceKey;
+extern NSString *const ENRMSelectionTextKey;
+extern NSString *const ENRMSelectionMarkdownKey;
+extern NSString *const ENRMSelectionWholeKey;
+extern NSString *const ENRMSelectionRectKey;
+extern NSString *const ENRMSelectionStartRectKey;
+extern NSString *const ENRMSelectionEndRectKey;
+/// Only in `ENRMTextSelectionInTextView` results: whether the range spans the
+/// whole text (same threshold `markdownForRange` uses for the cached markdown).
+extern NSString *const ENRMSelectionFullKey;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/// The payload reported once the selection is gone.
+NSDictionary *ENRMInactiveSelectionPayload(void);
+
+/// A long-pressed block (table / math / code): `whole`, every rect is `frame`.
+NSDictionary *ENRMBlockSelectionPayload(NSString *source, NSString *markdown, NSString *text, CGRect frame);
+
+#if !TARGET_OS_OSX
+/// Text, full-selection flag and rects of `textView`'s selection, converted to
+/// `targetView`'s coordinates; nil when nothing is selected. `rect` is the union
+/// of the selection rects, `startRect` / `endRect` the rects holding its start
+/// and end. The owner adds source, markdown and whole to build the payload.
+NSDictionary *_Nullable ENRMTextSelectionInTextView(UITextView *textView, UIView *targetView);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+/// Coalesces selection changes into at most one report per run loop turn. The
+/// payload is read when the turn fires, so the latest state always reaches JS;
+/// a cleared selection is reported right away and drops any pending update.
+/// Identical payloads are sent once.
+@interface ENRMSelectionChangeReporter : NSObject
+
+- (instancetype)initWithSnapshot:(NSDictionary * (^)(void))snapshot
+                            emit:(void (^)(NSDictionary *payload))emit NS_DESIGNATED_INITIALIZER;
+- (instancetype)init NS_UNAVAILABLE;
+
+/// Off by default. Toggling resets the last reported payload to inactive.
+@property (nonatomic, assign) BOOL enabled;
+
+- (void)schedule;
+- (void)selectionChanged:(BOOL)hasSelection;
+- (void)flushNow;
+- (void)cancel;
+/// Makes the next report go out even if it equals the last one — a block
+/// long-pressed again is a new request for the app's menu, not a repeat.
+- (void)forgetLastReported;
+
+@end
+
+#ifdef __cplusplus
+/// Converts a payload into a codegen `OnSelectionChange` struct. Templated
+/// because each component has its own (structurally identical) event struct.
+template <typename Event> inline Event ENRMSelectionChangeEventFromPayload(NSDictionary *payload)
+{
+  Event event;
+  event.active = [payload[ENRMSelectionActiveKey] boolValue];
+  event.source = std::string([payload[ENRMSelectionSourceKey] UTF8String] ?: "selection");
+  event.text = std::string([payload[ENRMSelectionTextKey] UTF8String] ?: "");
+  event.markdown = std::string([payload[ENRMSelectionMarkdownKey] UTF8String] ?: "");
+  event.whole = [payload[ENRMSelectionWholeKey] boolValue];
+
+  auto assign = [](auto &target, NSValue *value) {
+#if TARGET_OS_OSX
+    CGRect rect = value ? NSRectToCGRect(value.rectValue) : CGRectZero;
+#else
+    CGRect rect = value ? value.CGRectValue : CGRectZero;
+#endif
+    target.x = rect.origin.x;
+    target.y = rect.origin.y;
+    target.width = rect.size.width;
+    target.height = rect.size.height;
+  };
+  assign(event.rect, payload[ENRMSelectionRectKey]);
+  assign(event.startRect, payload[ENRMSelectionStartRectKey]);
+  assign(event.endRect, payload[ENRMSelectionEndRectKey]);
+  return event;
+}
+#endif
+
+NS_ASSUME_NONNULL_END

package/ios/utils/ENRMSelectionChange.m

@@ -0,0 +1,204 @@
+#import "ENRMSelectionChange.h"
+#import "ENRMLinkChip.h"
+
+NSString *const ENRMSelectionActiveKey = @"active";
+NSString *const ENRMSelectionSourceKey = @"source";
+NSString *const ENRMSelectionTextKey = @"text";
+NSString *const ENRMSelectionMarkdownKey = @"markdown";
+NSString *const ENRMSelectionWholeKey = @"whole";
+NSString *const ENRMSelectionRectKey = @"rect";
+NSString *const ENRMSelectionStartRectKey = @"startRect";
+NSString *const ENRMSelectionEndRectKey = @"endRect";
+NSString *const ENRMSelectionFullKey = @"full";
+
+static NSValue *ENRMRectValue(CGRect rect)
+{
+#if TARGET_OS_OSX
+  return [NSValue valueWithRect:NSRectFromCGRect(rect)];
+#else
+  return [NSValue valueWithCGRect:rect];
+#endif
+}
+
+NSDictionary *ENRMInactiveSelectionPayload(void)
+{
+  static NSDictionary *payload;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    NSValue *zero = ENRMRectValue(CGRectZero);
+    payload = @{
+      ENRMSelectionActiveKey : @NO,
+      ENRMSelectionSourceKey : @"selection",
+      ENRMSelectionTextKey : @"",
+      ENRMSelectionMarkdownKey : @"",
+      ENRMSelectionWholeKey : @NO,
+      ENRMSelectionRectKey : zero,
+      ENRMSelectionStartRectKey : zero,
+      ENRMSelectionEndRectKey : zero,
+    };
+  });
+  return payload;
+}
+
+NSDictionary *ENRMBlockSelectionPayload(NSString *source, NSString *markdown, NSString *text, CGRect frame)
+{
+  NSValue *rect = ENRMRectValue(frame);
+  return @{
+    ENRMSelectionActiveKey : @YES,
+    ENRMSelectionSourceKey : source,
+    ENRMSelectionTextKey : text ?: @"",
+    ENRMSelectionMarkdownKey : markdown ?: @"",
+    ENRMSelectionWholeKey : @YES,
+    ENRMSelectionRectKey : rect,
+    ENRMSelectionStartRectKey : rect,
+    ENRMSelectionEndRectKey : rect,
+  };
+}
+
+#if !TARGET_OS_OSX
+NSDictionary *ENRMTextSelectionInTextView(UITextView *textView, UIView *targetView)
+{
+  NSRange range = textView.selectedRange;
+  UITextRange *textRange = textView.selectedTextRange;
+  if (range.location == NSNotFound || range.length == 0 || textRange == nil || textRange.isEmpty) {
+    return nil;
+  }
+
+  NSAttributedString *attributedText = textView.attributedText;
+  if (NSMaxRange(range) > attributedText.length) {
+    return nil;
+  }
+
+  CGRect unionRect = CGRectNull;
+  CGRect startRect = CGRectNull;
+  CGRect endRect = CGRectNull;
+  CGRect firstRect = CGRectNull;
+  CGRect lastRect = CGRectNull;
+  for (UITextSelectionRect *selectionRect in [textView selectionRectsForRange:textRange]) {
+    CGRect rect = selectionRect.rect;
+    if (CGRectIsNull(rect) || CGRectIsInfinite(rect) || CGRectIsEmpty(rect)) {
+      continue;
+    }
+    unionRect = CGRectUnion(unionRect, rect);
+    if (CGRectIsNull(firstRect)) {
+      firstRect = rect;
+    }
+    lastRect = rect;
+    if (selectionRect.containsStart && CGRectIsNull(startRect)) {
+      startRect = rect;
+    }
+    if (selectionRect.containsEnd) {
+      endRect = rect;
+    }
+  }
+  // Not laid out yet: report once layout gives the range a position.
+  if (CGRectIsNull(unionRect)) {
+    return nil;
+  }
+  if (CGRectIsNull(startRect)) {
+    startRect = firstRect;
+  }
+  if (CGRectIsNull(endRect)) {
+    endRect = lastRect;
+  }
+
+  return @{
+    ENRMSelectionTextKey : ENRMPlainTextByRemovingLinkSpacers(attributedText, range),
+    ENRMSelectionFullKey : @(range.location == 0 && range.length >= attributedText.length - 1),
+    ENRMSelectionRectKey : ENRMRectValue([textView convertRect:unionRect toView:targetView]),
+    ENRMSelectionStartRectKey : ENRMRectValue([textView convertRect:startRect toView:targetView]),
+    ENRMSelectionEndRectKey : ENRMRectValue([textView convertRect:endRect toView:targetView]),
+  };
+}
+#endif
+
+@implementation ENRMSelectionChangeReporter {
+  NSDictionary * (^_snapshot)(void);
+  void (^_emit)(NSDictionary *);
+  NSDictionary *_lastReported;
+  BOOL _pending;
+  // Bumped on cancel so a scheduled block that already left the queue is a no-op.
+  NSUInteger _generation;
+}
+
+- (instancetype)initWithSnapshot:(NSDictionary * (^)(void))snapshot emit:(void (^)(NSDictionary *))emit
+{
+  if (self = [super init]) {
+    _snapshot = [snapshot copy];
+    _emit = [emit copy];
+    _lastReported = ENRMInactiveSelectionPayload();
+  }
+  return self;
+}
+
+- (void)setEnabled:(BOOL)enabled
+{
+  if (_enabled == enabled) {
+    return;
+  }
+  _enabled = enabled;
+  [self cancel];
+  _lastReported = ENRMInactiveSelectionPayload();
+  if (enabled) {
+    [self schedule];
+  }
+}
+
+- (void)schedule
+{
+  if (!_enabled || _pending) {
+    return;
+  }
+  _pending = YES;
+  NSUInteger generation = _generation;
+  __weak ENRMSelectionChangeReporter *weakSelf = self;
+  dispatch_async(dispatch_get_main_queue(), ^{
+    ENRMSelectionChangeReporter *strongSelf = weakSelf;
+    if (!strongSelf || !strongSelf->_pending || strongSelf->_generation != generation) {
+      return;
+    }
+    strongSelf->_pending = NO;
+    [strongSelf report];
+  });
+}
+
+- (void)selectionChanged:(BOOL)hasSelection
+{
+  if (hasSelection) {
+    [self schedule];
+  } else {
+    [self flushNow];
+  }
+}
+
+- (void)flushNow
+{
+  [self cancel];
+  [self report];
+}
+
+- (void)forgetLastReported
+{
+  _lastReported = ENRMInactiveSelectionPayload();
+}
+
+- (void)cancel
+{
+  _pending = NO;
+  _generation++;
+}
+
+- (void)report
+{
+  if (!_enabled) {
+    return;
+  }
+  NSDictionary *current = _snapshot();
+  if ([current isEqualToDictionary:_lastReported]) {
+    return;
+  }
+  _lastReported = current;
+  _emit(current);
+}
+
+@end

package/ios/utils/EditMenuUtils+macOS.m

@@ -1,7 +1,7 @@
 #import "ContextMenuUtils.h"
+#import "ENRMLinkChip.h"
 #import "ENRMMenuAction.h"
 #import "EditMenuUtils.h"
-#import "ENRMLinkChip.h"
 #import "PasteboardUtils.h"
 #import "StyleConfig.h"
 #include <TargetConditionals.h>

package/ios/utils/MarkdownAccessibilityElementBuilder.m

@@ -115,8 +115,7 @@ static const CGFloat kFocusRectPadding = 2.0;
 
     BOOL isImg = item[@"altText"] != nil;
     // Link chips pad their text with spacer characters; keep them out of the spoken label.
-    NSString *label = isImg ? item[@"altText"]
-                            : ENRMPlainTextByRemovingLinkSpacers(textView.attributedText, itemRange);
+    NSString *label = isImg ? item[@"altText"] : ENRMPlainTextByRemovingLinkSpacers(textView.attributedText, itemRange);
     [elements addObject:[self createElementForRange:itemRange
                                                type:isImg ? ElementTypeImage : ElementTypeLink
                                                text:label

package/ios/views/ENRMCodeBlockContainerView.h

@@ -45,6 +45,9 @@ typedef void (^ENRMCodeBlockCopyBlock)(NSString *code, NSString *language);
 /// Set by the host; receives the Copy item's content when
 /// `menuOptions.interceptCopy` is set.
 @property (nonatomic, copy, nullable) ENRMBlockCopyRequestBlock onCopyRequest;
+/// Called instead of the menu on long press while `contextMenuHidden` is on, so
+/// the owner can report the block (`onSelectionChange`) and show its own UI.
+@property (nonatomic, copy, nullable) ENRMBlockCopyRequestBlock onMenuSuppressed;
 
 // Fired when the code is copied (header button, context-menu Copy, or the
 // VoiceOver copy action); set by the host to bridge up to the JS onCopyPress

package/ios/views/ENRMCodeBlockContainerView.m

@@ -495,6 +495,9 @@ static BOOL ENRMColorIsDark(RCTUIColor *color)
 {
   // Returning nil is the UIKit-sanctioned way to suppress a context menu.
   if (_pending || self.contextMenuHidden) {
+    if (!_pending && self.onMenuSuppressed) {
+      self.onMenuSuppressed([self fencedMarkdown], _cachedCode ?: @"");
+    }
     return nil;
   }
   __weak __typeof(self) weakSelf = self;

package/ios/views/ENRMMathContainerView.h

@@ -42,6 +42,9 @@ NS_ASSUME_NONNULL_BEGIN
 /// Set by the host; receives the Copy item's content when
 /// `menuOptions.interceptCopy` is set.
 @property (nonatomic, copy, nullable) ENRMBlockCopyRequestBlock onCopyRequest;
+/// Called instead of the menu on long press while `contextMenuHidden` is on, so
+/// the owner can report the block (`onSelectionChange`) and show its own UI.
+@property (nonatomic, copy, nullable) ENRMBlockCopyRequestBlock onMenuSuppressed;
 
 @end
 

package/ios/views/ENRMMathContainerView.m

@@ -128,6 +128,9 @@
 {
   // Returning nil is the UIKit-sanctioned way to suppress a context menu.
   if (self.contextMenuHidden) {
+    if (self.onMenuSuppressed) {
+      self.onMenuSuppressed([NSString stringWithFormat:@"$$\n%@\n$$", _cachedLatex ?: @""], _cachedLatex ?: @"");
+    }
     return nil;
   }
   __weak __typeof(self) weakSelf = self;

package/ios/views/TableContainerView.h

@@ -63,6 +63,9 @@ typedef void (^TableLinkPressBlock)(NSString *url);
 /// Set by the host; receives the Copy item's content when
 /// `menuOptions.interceptCopy` is set.
 @property (nonatomic, copy, nullable) ENRMBlockCopyRequestBlock onCopyRequest;
+/// Called instead of the menu on long press while `contextMenuHidden` is on, so
+/// the owner can report the block (`onSelectionChange`) and show its own UI.
+@property (nonatomic, copy, nullable) ENRMBlockCopyRequestBlock onMenuSuppressed;
 
 @property (nonatomic, readonly) NSUInteger rowCount;
 /// Number of links across all cells. Tables are not reported by `onLinkLayout`,

package/ios/views/TableContainerView.m

@@ -1,7 +1,7 @@
 #import "TableContainerView.h"
-#import "ENRMLinkChip.h"
 #import "AttributedRenderer.h"
 #import "ENRMAccessibilityLabels.h"
+#import "ENRMLinkChip.h"
 #import "HTMLGenerator.h"
 #import "LinkTapUtils.h"
 #import "MarkdownASTNode.h"
@@ -486,6 +486,9 @@ static void ENRMTableComputeLayout(NSArray<NSArray<TableCellData *> *> *rows, NS
 {
   // Returning nil is the UIKit-sanctioned way to suppress a context menu.
   if (self.contextMenuHidden) {
+    if (self.onMenuSuppressed) {
+      self.onMenuSuppressed(_cachedMarkdown ?: @"", [self buildPlainTextFromRows] ?: @"");
+    }
     return nil;
   }
   __weak __typeof(self) weakSelf = self;

package/lib/module/EnrichedMarkdownNativeComponent.ts

@@ -1,9 +1,12 @@
 import {
   codegenNativeComponent,
+  codegenNativeCommands,
   type ViewProps,
   type CodegenTypes,
   type ColorValue,
+  type HostComponent,
 } from 'react-native';
+import type React from 'react';
 
 // All block styles extend this interface
 interface BaseBlockStyleInternal {
@@ -274,6 +277,39 @@ export interface LinkLayoutEvent {
   }[];
 }
 
+/**
+ * Current text selection, or a long-pressed table / math / code block while
+ * `contextMenuHidden` is on. `active: false` means the selection was cleared
+ * (every other field is then empty / zero). Rects are in dp / pt, relative to
+ * the native view's origin; rect objects are written inline because codegen
+ * only accepts inline object literals in event payloads.
+ */
+export interface SelectionChangeEvent {
+  active: boolean;
+  source: string;
+  text: string;
+  markdown: string;
+  whole: boolean;
+  rect: {
+    x: CodegenTypes.Double;
+    y: CodegenTypes.Double;
+    width: CodegenTypes.Double;
+    height: CodegenTypes.Double;
+  };
+  startRect: {
+    x: CodegenTypes.Double;
+    y: CodegenTypes.Double;
+    width: CodegenTypes.Double;
+    height: CodegenTypes.Double;
+  };
+  endRect: {
+    x: CodegenTypes.Double;
+    y: CodegenTypes.Double;
+    width: CodegenTypes.Double;
+    height: CodegenTypes.Double;
+  };
+}
+
 export interface TaskListItemPressEvent {
   index: CodegenTypes.Int32;
   checked: boolean;
@@ -441,6 +477,18 @@ export interface NativeProps extends ViewProps {
    * Deduplicated: not re-fired when the payload is unchanged.
    */
   onLinkLayout?: CodegenTypes.DirectEventHandler<LinkLayoutEvent>;
+  /**
+   * When true, the view reports selection changes (and, with
+   * `contextMenuHidden`, block long-presses) through `onSelectionChange`.
+   * Set by the JS wrapper only when `onSelectionChange` is provided.
+   * @default false
+   */
+  emitSelectionChange?: CodegenTypes.WithDefault<boolean, false>;
+  /**
+   * Fired while `emitSelectionChange` is on: coalesced to one event per frame,
+   * deduplicated, and `active: false` once the selection is gone.
+   */
+  onSelectionChange?: CodegenTypes.DirectEventHandler<SelectionChangeEvent>;
   /**
    * Callback fired when a task list checkbox is tapped.
    * Receives the 0-based task index, current checked state, and the item's plain text.
@@ -594,6 +642,17 @@ export interface NativeProps extends ViewProps {
   writingDirection?: CodegenTypes.WithDefault<string, 'first-strong'>;
 }
 
+type ComponentType = HostComponent<NativeProps>;
+
+interface NativeCommands {
+  /** Clears the text selection (and any active block) and fires `onSelectionChange` with `active: false`. */
+  clearSelection: (viewRef: React.ElementRef<ComponentType>) => void;
+}
+
+export const Commands: NativeCommands = codegenNativeCommands<NativeCommands>({
+  supportedCommands: ['clearSelection'],
+});
+
 export default codegenNativeComponent<NativeProps>('EnrichedMarkdown', {
   interfaceOnly: true,
-});
+}) as HostComponent<NativeProps>;