react-native-enriched-markdown-scaffold 0.7.4-scaffold.9 → 1.0.2-scaffold.10

package/ios/utils/ENRMSelectionChange.m

@@ -0,0 +1,282 @@
+#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 ENRMSelectionAdjustingKey = @"adjusting";
+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
+
+#if !TARGET_OS_OSX
+static void ENRMCollectGestures(UIView *view, NSMutableArray<UIGestureRecognizer *> *into)
+{
+  for (UIGestureRecognizer *recognizer in view.gestureRecognizers) {
+    [into addObject:recognizer];
+  }
+  for (UIView *subview in view.subviews) {
+    ENRMCollectGestures(subview, into);
+  }
+}
+
+@implementation ENRMSelectionGestureTracker {
+  void (^_change)(void);
+  NSHashTable<UIGestureRecognizer *> *_gestures;
+}
+
+- (instancetype)initWithChange:(void (^)(void))change
+{
+  if (self = [super init]) {
+    _change = [change copy];
+    _gestures = [NSHashTable weakObjectsHashTable];
+  }
+  return self;
+}
+
+- (void)dealloc
+{
+  // Recognizers don't retain their targets.
+  for (UIGestureRecognizer *recognizer in _gestures) {
+    [recognizer removeTarget:self action:@selector(gestureChanged:)];
+  }
+}
+
+- (void)trackTextView:(UITextView *)textView
+{
+  NSMutableArray<UIGestureRecognizer *> *all = [NSMutableArray array];
+  ENRMCollectGestures(textView, all);
+  for (UIGestureRecognizer *recognizer in all) {
+    if ([_gestures containsObject:recognizer]) {
+      continue;
+    }
+    if (recognizer == textView.panGestureRecognizer || recognizer == textView.pinchGestureRecognizer) {
+      continue;
+    }
+    if ([recognizer isKindOfClass:[UITapGestureRecognizer class]]) {
+      continue;
+    }
+    [_gestures addObject:recognizer];
+    [recognizer addTarget:self action:@selector(gestureChanged:)];
+  }
+}
+
+- (void)reset
+{
+  _adjusting = NO;
+}
+
+- (void)gestureChanged:(UIGestureRecognizer *)recognizer
+{
+  BOOL adjusting = NO;
+  for (UIGestureRecognizer *tracked in _gestures) {
+    UIGestureRecognizerState state = tracked.state;
+    if (state == UIGestureRecognizerStateBegan || state == UIGestureRecognizerStateChanged) {
+      adjusting = YES;
+      break;
+    }
+  }
+  if (adjusting == _adjusting) {
+    return;
+  }
+  _adjusting = adjusting;
+  _change();
+}
+
+@end
+#endif

package/ios/utils/ENRMTextViewSetup.h

@@ -30,26 +30,32 @@ static inline void ENRMDetachLayoutManager(ENRMPlatformTextView *textView)
   }
 }
 
-static inline CGSize ENRMMeasureMarkdownText(ENRMPlatformTextView *textView, CGFloat maxWidth, StyleConfig *config,
-                                             BOOL allowTrailingMargin, CGFloat lastElementMarginBottom)
+/// Turns a raw TextKit layout pass into the final measured size. Shared by
+/// the view-backed path (`ENRMMeasureMarkdownText`) and the view-free path
+/// (`ENRMMeasureMarkdownViewFree`) so both measure with one algorithm.
+///
+/// Steps, in order:
+/// - Multiline pin: if the first line fragment doesn't span all glyphs the
+///   text wrapped, and returning the tight usedRect width would let flexShrink
+///   narrow the view below maxWidth, re-wrapping at the narrower width and
+///   mismatching the measured height — so multiline content reports maxWidth,
+///   while single-line content keeps its tight width for shrink-to-fit.
+/// - Subtract the extra line fragment (iOS counts a trailing newline's empty
+///   line fragment into usedRect).
+/// - Add code-block padding when the last element is a code block, and the
+///   trailing margin when enabled.
+/// - Round up to the pixel grid of `scale` (pass `RCTScreenScale()` on main;
+///   off-main callers must pass `LayoutContext::pointScaleFactor` instead —
+///   `RCTScreenScale()` dispatch_syncs to main on first use, which the
+///   measure path must never do, see issue #550).
+static inline CGSize ENRMFinalizeMeasuredTextSize(ENRMTextLayoutResult layout, NSLayoutManager *layoutManager,
+                                                  NSAttributedString *text, CGFloat maxWidth, StyleConfig *config,
+                                                  BOOL allowTrailingMargin, CGFloat lastElementMarginBottom,
+                                                  CGFloat scale)
 {
-  NSAttributedString *text = ENRMGetAttributedText(textView);
-  if (text.length == 0) {
-    return CGSizeZero;
-  }
-
-  ENRMTextLayoutResult layout = ENRMMeasureTextLayout(textView, maxWidth);
-
   CGFloat measuredWidth = layout.usedRect.size.width;
   CGFloat measuredHeight = layout.usedRect.size.height;
 
-  // Detect multiline content by checking if the layout produced more than one
-  // line fragment. When text wraps, returning the tight usedRect width lets
-  // flexShrink narrow the view below maxWidth, causing re-wrap at the narrower
-  // width and a height mismatch. Pin to maxWidth for multiline content so Yoga
-  // assigns the width the text was actually measured at. Single-line content
-  // keeps its tight width for shrink-to-fit behavior.
-  NSLayoutManager *layoutManager = textView.layoutManager;
   NSUInteger glyphCount = [layoutManager numberOfGlyphs];
   if (glyphCount > 0) {
     NSRange firstLineRange;
@@ -71,8 +77,20 @@ static inline CGSize ENRMMeasureMarkdownText(ENRMPlatformTextView *textView, CGF
     measuredHeight += lastElementMarginBottom;
   }
 
-  CGFloat scale = RCTScreenScale();
   return CGSizeMake(ceil(measuredWidth * scale) / scale, ceil(measuredHeight * scale) / scale);
 }
 
+static inline CGSize ENRMMeasureMarkdownText(ENRMPlatformTextView *textView, CGFloat maxWidth, StyleConfig *config,
+                                             BOOL allowTrailingMargin, CGFloat lastElementMarginBottom)
+{
+  NSAttributedString *text = ENRMGetAttributedText(textView);
+  if (text.length == 0) {
+    return CGSizeZero;
+  }
+
+  ENRMTextLayoutResult layout = ENRMMeasureTextLayout(textView, maxWidth);
+  return ENRMFinalizeMeasuredTextSize(layout, textView.layoutManager, text, maxWidth, config, allowTrailingMargin,
+                                      lastElementMarginBottom, RCTScreenScale());
+}
+
 NS_ASSUME_NONNULL_END

package/ios/utils/EditMenuUtils+macOS.m

@@ -1,4 +1,5 @@
 #import "ContextMenuUtils.h"
+#import "ENRMLinkChip.h"
 #import "ENRMMenuAction.h"
 #import "EditMenuUtils.h"
 #import "PasteboardUtils.h"
@@ -19,7 +20,9 @@ NSMenu *_Nullable buildEditMenuForSelection(NSAttributedString *attributedText,
     return menu;
   }
 
-  NSAttributedString *selectedText = [attributedText attributedSubstringFromRange:range];
+  // Link spacers only reserve layout space; keep them out of every copied flavor.
+  NSAttributedString *selectedText =
+      ENRMAttributedStringByRemovingLinkSpacers([attributedText attributedSubstringFromRange:range]);
   NSString *markdown = markdownForRange(attributedText, range, cachedMarkdown);
   NSArray<NSString *> *imageURLs = imageURLsInRange(attributedText, range);
 

package/ios/utils/EditMenuUtils.h

@@ -9,6 +9,15 @@ NS_ASSUME_NONNULL_BEGIN
 typedef struct {
   BOOL copyAsMarkdown;
   BOOL copyImageURL;
+  BOOL copyEnabled;
+  // Copy writes Markdown as plain text instead of rich text.
+  BOOL copyFormatMarkdown;
+  // Drop every system-provided item from the text selection menu.
+  BOOL systemItemsNone;
+  BOOL codeBlockCopyButton;
+  // Copy hands the selection to the owner (JS `onCopy`) instead of writing the
+  // pasteboard.
+  BOOL interceptCopy;
   // The owner must keep these strings alive for the duration of the call (the
   // view holds them in strong ivars).
   __unsafe_unretained NSString *_Nullable copyLabel;
@@ -18,6 +27,10 @@ typedef struct {
   __unsafe_unretained NSArray<NSString *> *_Nullable copyImageUrlPluralTemplates;
 } ENRMSelectionMenuConfig;
 
+/// Receives an intercepted Copy. `fullSelection` is whether the range spans the
+/// whole attributed text, in which case `markdown` is the cached markdown.
+typedef void (^ENRMCopyRequestHandler)(NSString *markdown, NSString *text, BOOL fullSelection);
+
 /// Resolves the "Copy Image URL(s)" menu title for a given image count.
 /// Uses the precomputed plural templates (indexed by count, 0..100) when present;
 /// counts > 100 use the "other" form (copyImageUrlsLabel). Otherwise the
@@ -36,6 +49,13 @@ static inline NSString *ENRMResolveImageURLsTitle(ENRMSelectionMenuConfig config
   return [titleTemplate stringByReplacingOccurrencesOfString:@"{count}" withString:[@(count) stringValue]];
 }
 
+/// Defaults matching the JS-side defaults, used until the first props update.
+static inline ENRMSelectionMenuConfig ENRMDefaultSelectionMenuConfig(void)
+{
+  return (ENRMSelectionMenuConfig){
+      .copyAsMarkdown = YES, .copyImageURL = YES, .copyEnabled = YES, .codeBlockCopyButton = YES};
+}
+
 #ifdef __cplusplus
 
 /// Strong owners for the label strings in ENRMSelectionMenuConfig.
@@ -63,13 +83,18 @@ template <typename T> static inline ENRMSelectionMenuLabels ENRMParseSelectionMe
   };
 }
 
-/// Builds an ENRMSelectionMenuConfig from pre-parsed labels and boolean flags.
-static inline ENRMSelectionMenuConfig ENRMBuildSelectionMenuConfig(const ENRMSelectionMenuLabels &labels,
-                                                                   bool copyAsMarkdown, bool copyImageUrl)
+/// Builds an ENRMSelectionMenuConfig from pre-parsed labels and the codegen struct's flags.
+template <typename T>
+static inline ENRMSelectionMenuConfig ENRMBuildSelectionMenuConfig(const ENRMSelectionMenuLabels &labels, const T &src)
 {
   return (ENRMSelectionMenuConfig){
-      .copyAsMarkdown = copyAsMarkdown,
-      .copyImageURL = copyImageUrl,
+      .copyAsMarkdown = src.copyAsMarkdown,
+      .copyImageURL = src.copyImageUrl,
+      .copyEnabled = src.copyEnabled,
+      .copyFormatMarkdown = src.copyFormatMarkdown,
+      .systemItemsNone = src.systemItemsNone,
+      .codeBlockCopyButton = src.codeBlockCopyButton,
+      .interceptCopy = src.interceptCopy,
       .copyLabel = labels.copyLabel,
       .copyAsMarkdownLabel = labels.copyAsMarkdownLabel,
       .copyImageUrlLabel = labels.copyImageUrlLabel,
@@ -90,7 +115,11 @@ extern "C" {
 UIMenu *buildEditMenuForSelection(NSAttributedString *attributedText, NSRange range, NSString *_Nullable cachedMarkdown,
                                   StyleConfig *styleConfig, NSArray<UIMenuElement *> *suggestedActions,
                                   NSArray<UIAction *> *_Nullable customActions,
-                                  ENRMSelectionMenuConfig selectionMenuConfig) API_AVAILABLE(ios(16.0));
+                                  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,