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

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

@@ -22,8 +22,10 @@ EnrichedMarkdownProps::EnrichedMarkdownProps(
     markdown(convertRawProp(context, rawProps, "markdown", sourceProps.markdown, {})),
     markdownStyle(convertRawProp(context, rawProps, "markdownStyle", sourceProps.markdownStyle, {})),
     emitLinkLayout(convertRawProp(context, rawProps, "emitLinkLayout", sourceProps.emitLinkLayout, {false})),
+    emitSelectionChange(convertRawProp(context, rawProps, "emitSelectionChange", sourceProps.emitSelectionChange, {false})),
     enableTaskListItemToggle(convertRawProp(context, rawProps, "enableTaskListItemToggle", sourceProps.enableTaskListItemToggle, {true})),
     enableLinkPreview(convertRawProp(context, rawProps, "enableLinkPreview", sourceProps.enableLinkPreview, {true})),
+    linkLongPressSelects(convertRawProp(context, rawProps, "linkLongPressSelects", sourceProps.linkLongPressSelects, {false})),
     selectable(convertRawProp(context, rawProps, "selectable", sourceProps.selectable, {false})),
     selectionColor(convertRawProp(context, rawProps, "selectionColor", sourceProps.selectionColor, {})),
     selectionHandleColor(convertRawProp(context, rawProps, "selectionHandleColor", sourceProps.selectionHandleColor, {})),
@@ -71,6 +73,10 @@ folly::dynamic EnrichedMarkdownProps::getDiffProps(
     result["emitLinkLayout"] = emitLinkLayout;
   }
     
+  if (emitSelectionChange != oldProps->emitSelectionChange) {
+    result["emitSelectionChange"] = emitSelectionChange;
+  }
+    
   if (enableTaskListItemToggle != oldProps->enableTaskListItemToggle) {
     result["enableTaskListItemToggle"] = enableTaskListItemToggle;
   }
@@ -79,6 +85,10 @@ folly::dynamic EnrichedMarkdownProps::getDiffProps(
     result["enableLinkPreview"] = enableLinkPreview;
   }
     
+  if (linkLongPressSelects != oldProps->linkLongPressSelects) {
+    result["linkLongPressSelects"] = linkLongPressSelects;
+  }
+    
   if (selectable != oldProps->selectable) {
     result["selectable"] = selectable;
   }
@@ -310,8 +320,10 @@ EnrichedMarkdownTextProps::EnrichedMarkdownTextProps(
     markdown(convertRawProp(context, rawProps, "markdown", sourceProps.markdown, {})),
     markdownStyle(convertRawProp(context, rawProps, "markdownStyle", sourceProps.markdownStyle, {})),
     emitLinkLayout(convertRawProp(context, rawProps, "emitLinkLayout", sourceProps.emitLinkLayout, {false})),
+    emitSelectionChange(convertRawProp(context, rawProps, "emitSelectionChange", sourceProps.emitSelectionChange, {false})),
     enableTaskListItemToggle(convertRawProp(context, rawProps, "enableTaskListItemToggle", sourceProps.enableTaskListItemToggle, {true})),
     enableLinkPreview(convertRawProp(context, rawProps, "enableLinkPreview", sourceProps.enableLinkPreview, {true})),
+    linkLongPressSelects(convertRawProp(context, rawProps, "linkLongPressSelects", sourceProps.linkLongPressSelects, {false})),
     selectable(convertRawProp(context, rawProps, "selectable", sourceProps.selectable, {false})),
     selectionColor(convertRawProp(context, rawProps, "selectionColor", sourceProps.selectionColor, {})),
     selectionHandleColor(convertRawProp(context, rawProps, "selectionHandleColor", sourceProps.selectionHandleColor, {})),
@@ -359,6 +371,10 @@ folly::dynamic EnrichedMarkdownTextProps::getDiffProps(
     result["emitLinkLayout"] = emitLinkLayout;
   }
     
+  if (emitSelectionChange != oldProps->emitSelectionChange) {
+    result["emitSelectionChange"] = emitSelectionChange;
+  }
+    
   if (enableTaskListItemToggle != oldProps->enableTaskListItemToggle) {
     result["enableTaskListItemToggle"] = enableTaskListItemToggle;
   }
@@ -367,6 +383,10 @@ folly::dynamic EnrichedMarkdownTextProps::getDiffProps(
     result["enableLinkPreview"] = enableLinkPreview;
   }
     
+  if (linkLongPressSelects != oldProps->linkLongPressSelects) {
+    result["linkLongPressSelects"] = linkLongPressSelects;
+  }
+    
   if (selectable != oldProps->selectable) {
     result["selectable"] = selectable;
   }

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

@@ -2887,8 +2887,10 @@ class EnrichedMarkdownProps final : public ViewProps {
   std::string markdown{};
   EnrichedMarkdownMarkdownStyleStruct markdownStyle{};
   bool emitLinkLayout{false};
+  bool emitSelectionChange{false};
   bool enableTaskListItemToggle{true};
   bool enableLinkPreview{true};
+  bool linkLongPressSelects{false};
   bool selectable{false};
   SharedColor selectionColor{};
   SharedColor selectionHandleColor{};
@@ -6931,8 +6933,10 @@ class EnrichedMarkdownTextProps final : public ViewProps {
   std::string markdown{};
   EnrichedMarkdownTextMarkdownStyleStruct markdownStyle{};
   bool emitLinkLayout{false};
+  bool emitSelectionChange{false};
   bool enableTaskListItemToggle{true};
   bool enableLinkPreview{true};
+  bool linkLongPressSelects{false};
   bool selectable{false};
   SharedColor selectionColor{};
   SharedColor selectionHandleColor{};

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

@@ -134,11 +134,31 @@ void ENRMEnumerateLinkChipFragments(NSLayoutManager *layoutManager, NSTextContai
 
                                  CGRect textRect = [layoutManager boundingRectForGlyphRange:intersect
                                                                             inTextContainer:textContainer];
-                                 CGFloat left = CGRectGetMinX(textRect);
-                                 CGFloat right = CGRectGetMaxX(textRect);
+                                 NSRange fragmentChars = [layoutManager characterRangeForGlyphRange:intersect
+                                                                                   actualGlyphRange:NULL];
+                                 NSUInteger lineEnd = NSMaxRange(lineRange);
+                                 CGFloat left =
+                                     lineRect.origin.x + [layoutManager locationForGlyphAtIndex:intersect.location].x;
+
+                                 NSUInteger visibleCharEnd = NSMaxRange(fragmentChars);
+                                 NSString *chars = storage.string;
+                                 NSCharacterSet *breakable = [NSCharacterSet whitespaceAndNewlineCharacterSet];
+                                 while (visibleCharEnd > fragmentChars.location &&
+                                        [chars characterAtIndex:visibleCharEnd - 1] != kSpacerChar &&
+                                        [breakable characterIsMember:[chars characterAtIndex:visibleCharEnd - 1]]) {
+                                   visibleCharEnd--;
+                                 }
+                                 NSUInteger visibleGlyphEnd = NSMaxRange(intersect);
+                                 if (visibleCharEnd < NSMaxRange(fragmentChars)) {
+                                   visibleGlyphEnd = [layoutManager glyphIndexForCharacterAtIndex:visibleCharEnd];
+                                 }
 
-                                 // The trailing spacer's kern is its advance; don't rely on the
-                                 // glyph bounds including it.
+                                 CGFloat right;
+                                 if (visibleGlyphEnd < lineEnd) {
+                                   right = lineRect.origin.x + [layoutManager locationForGlyphAtIndex:visibleGlyphEnd].x;
+                                 } else {
+                                   right = CGRectGetMaxX(usedRect);
+                                 }
                                  if (isLast && paddingHorizontal > 0) {
                                    NSUInteger lastGlyph = NSMaxRange(intersect) - 1;
                                    CGFloat spacerX =
@@ -146,8 +166,6 @@ void ENRMEnumerateLinkChipFragments(NSLayoutManager *layoutManager, NSTextContai
                                    right = MAX(right, spacerX + paddingHorizontal);
                                  }
 
-                                 NSRange fragmentChars = [layoutManager characterRangeForGlyphRange:intersect
-                                                                                   actualGlyphRange:NULL];
                                  UIFont *font = chipFontInRange(storage, fragmentChars);
                                  CGFloat top = CGRectGetMinY(textRect);
                                  CGFloat bottom = CGRectGetMaxY(textRect);
@@ -177,18 +195,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/EditMenuUtils.h

@@ -117,6 +117,9 @@ UIMenu *buildEditMenuForSelection(NSAttributedString *attributedText, NSRange ra
                                   NSArray<UIAction *> *_Nullable customActions,
                                   ENRMSelectionMenuConfig selectionMenuConfig,
                                   ENRMCopyRequestHandler _Nullable onCopyRequest) API_AVAILABLE(ios(16.0));
+
+void ENRMSelectRangeAndPresentEditMenu(UITextView *textView, NSRange range);
+void ENRMDismissSelectionEditMenuIfMoved(UITextView *textView);
 #else
 NSMenu *_Nullable buildEditMenuForSelection(NSAttributedString *attributedText, NSRange range,
                                             NSString *_Nullable cachedMarkdown, StyleConfig *styleConfig,