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

package/ios/utils/BlockquoteBorder.m

@@ -5,6 +5,7 @@
 // Attribute constants for identifying blockquote segments in text storage
 NSString *const BlockquoteDepthAttributeName = @"BlockquoteDepth";
 NSString *const BlockquoteBackgroundColorAttributeName = @"BlockquoteBackgroundColor";
+NSString *const BlockquoteSpacerAttributeName = @"BlockquoteSpacer";
 
 @implementation BlockquoteBorder {
   StyleConfig *_config;
@@ -20,7 +21,15 @@ NSString *const BlockquoteBackgroundColorAttributeName = @"BlockquoteBackgroundC
 
 /**
  * Main drawing entry point called by the LayoutManager.
- * Iterates through line fragments to draw backgrounds and borders for nested blockquotes.
+ * Collects contiguous blockquote regions and draws each as one rounded box:
+ * background fill first, then the vertical borders clipped to the box shape.
+ * When a border radius is set, each nested quote's stripes are additionally
+ * clipped to that quote's own rounded box, mirroring per-element CSS
+ * border-radius on web.
+ * Regions are discovered by scanning only the drawn character range; regions
+ * touching its edges are extended run-by-run to their true boundaries, so the
+ * cost scales with the visible text plus the intersecting quotes rather than
+ * the whole document.
  */
 - (void)drawBordersForGlyphRange:(NSRange)glyphsToShow
                    layoutManager:(NSLayoutManager *)layoutManager
@@ -32,66 +41,254 @@ NSString *const BlockquoteBackgroundColorAttributeName = @"BlockquoteBackgroundC
     return;
   }
 
+  NSRange charRange = [layoutManager characterRangeForGlyphRange:glyphsToShow actualGlyphRange:NULL];
+  if (charRange.location == NSNotFound || charRange.length == 0) {
+    return;
+  }
+
+  NSMutableArray<NSValue *> *regions = [NSMutableArray array];
+  __block NSRange currentRegion = NSMakeRange(NSNotFound, 0);
+  [textStorage enumerateAttribute:BlockquoteDepthAttributeName
+                          inRange:charRange
+                          options:0
+                       usingBlock:^(id value, NSRange range, BOOL *stop) {
+                         if (!value) {
+                           if (currentRegion.location != NSNotFound) {
+                             [regions addObject:[NSValue valueWithRange:currentRegion]];
+                             currentRegion = NSMakeRange(NSNotFound, 0);
+                           }
+                           return;
+                         }
+                         currentRegion =
+                             currentRegion.location == NSNotFound ? range : NSUnionRange(currentRegion, range);
+                       }];
+  if (currentRegion.location != NSNotFound) {
+    [regions addObject:[NSValue valueWithRange:currentRegion]];
+  }
+
+  if (regions.count == 0) {
+    return;
+  }
+
+  NSRange firstRegion = regions.firstObject.rangeValue;
+  if (firstRegion.location == charRange.location) {
+    while (firstRegion.location > 0) {
+      NSRange runRange;
+      if (![textStorage attribute:BlockquoteDepthAttributeName
+                          atIndex:firstRegion.location - 1
+                   effectiveRange:&runRange]) {
+        break;
+      }
+      firstRegion = NSUnionRange(firstRegion, runRange);
+    }
+    regions[0] = [NSValue valueWithRange:firstRegion];
+  }
+
+  NSRange lastRegion = regions.lastObject.rangeValue;
+  if (NSMaxRange(lastRegion) == NSMaxRange(charRange)) {
+    while (NSMaxRange(lastRegion) < textStorage.length) {
+      NSRange runRange;
+      if (![textStorage attribute:BlockquoteDepthAttributeName
+                          atIndex:NSMaxRange(lastRegion)
+                   effectiveRange:&runRange]) {
+        break;
+      }
+      lastRegion = NSUnionRange(lastRegion, runRange);
+    }
+    regions[regions.count - 1] = [NSValue valueWithRange:lastRegion];
+  }
+
+  for (NSValue *value in regions) {
+    [self drawBlockquoteRegion:value.rangeValue layoutManager:layoutManager textContainer:textContainer atPoint:origin];
+  }
+}
+
+/**
+ * Groups the depth runs of a region into nested quote boxes: for each level
+ * >= 1, a box is a maximal contiguous stretch where depth >= level (a nested
+ * quote's own range). Outputs parallel arrays of ranges and levels.
+ */
+static void collectNestedBoxes(NSArray<NSValue *> *runRanges, NSArray<NSNumber *> *runDepths,
+                               NSMutableArray<NSValue *> *boxRanges, NSMutableArray<NSNumber *> *boxLevels)
+{
+  NSInteger maxDepth = 0;
+  for (NSNumber *depth in runDepths) {
+    maxDepth = MAX(maxDepth, depth.integerValue);
+  }
+
+  for (NSInteger level = 1; level <= maxDepth; level++) {
+    NSRange current = NSMakeRange(NSNotFound, 0);
+    for (NSUInteger i = 0; i < runRanges.count; i++) {
+      if (runDepths[i].integerValue >= level) {
+        NSRange runRange = runRanges[i].rangeValue;
+        current = current.location == NSNotFound ? runRange : NSUnionRange(current, runRange);
+      } else if (current.location != NSNotFound) {
+        [boxRanges addObject:[NSValue valueWithRange:current]];
+        [boxLevels addObject:@(level)];
+        current = NSMakeRange(NSNotFound, 0);
+      }
+    }
+    if (current.location != NSNotFound) {
+      [boxRanges addObject:[NSValue valueWithRange:current]];
+      [boxLevels addObject:@(level)];
+    }
+  }
+}
+
+- (void)drawBlockquoteRegion:(NSRange)region
+               layoutManager:(NSLayoutManager *)layoutManager
+               textContainer:(NSTextContainer *)textContainer
+                     atPoint:(CGPoint)origin
+{
+  NSTextStorage *textStorage = layoutManager.textStorage;
+
   // Cache configuration values to minimize pointer chasing and method lookups in the loop
   StyleConfig *c = _config;
   CGFloat borderWidth = c.blockquoteBorderWidth;
   CGFloat gapWidth = c.blockquoteGapWidth;
   CGFloat levelSpacing = borderWidth + gapWidth;
+  CGFloat borderRadius = c.blockquoteBorderRadius;
   CGFloat containerWidth = textContainer.size.width;
   RCTUIColor *defaultBgColor = c.blockquoteBackgroundColor;
   RCTUIColor *borderColor = c.blockquoteBorderColor;
 
-  UIBezierPath *borderPath = [UIBezierPath bezierPath];
-
-  [layoutManager
-      enumerateLineFragmentsForGlyphRange:glyphsToShow
-                               usingBlock:^(CGRect rect, CGRect usedRect, NSTextContainer *container,
-                                            NSRange glyphRange, BOOL *stop) {
-                                 // Map the glyph range back to character indices to retrieve attributes
-                                 NSRange charRange = [layoutManager characterRangeForGlyphRange:glyphRange
-                                                                               actualGlyphRange:NULL];
-                                 if (charRange.location == NSNotFound || charRange.length == 0) {
-                                   return;
-                                 }
-
-                                 // Perform a single attribute lookup for the current line fragment
-                                 NSDictionary *attrs = [textStorage attributesAtIndex:charRange.location
-                                                                       effectiveRange:NULL];
-                                 NSNumber *depthNum = attrs[BlockquoteDepthAttributeName];
-
-                                 // If no depth is found, this fragment is not part of a blockquote
-                                 if (!depthNum) {
-                                   return;
-                                 }
-
-                                 NSInteger depth = [depthNum integerValue];
-                                 CGFloat baseY = origin.y + rect.origin.y;
-                                 BOOL isRTL = ENRMParagraphIsRTL(attrs[NSParagraphStyleAttributeName]);
-
-                                 // 1. Draw Background (Painter's algorithm: draw backgrounds before borders)
-                                 RCTUIColor *bgColor = attrs[BlockquoteBackgroundColorAttributeName] ?: defaultBgColor;
-                                 if (bgColor && bgColor != [RCTUIColor clearColor]) {
-                                   CGContextRef ctx = UIGraphicsGetCurrentContext();
-                                   [bgColor setFill];
-                                   CGContextFillRect(ctx,
-                                                     CGRectMake(origin.x, baseY, containerWidth, rect.size.height));
-                                 }
-
-                                 // 2. Aggregate vertical borders into the batch path
-                                 for (NSInteger level = 0; level <= depth; level++) {
-                                   CGFloat borderX =
-                                       isRTL ? origin.x + containerWidth - borderWidth - (levelSpacing * level)
-                                             : origin.x + (levelSpacing * level);
-                                   CGRect borderRect = CGRectMake(borderX, baseY, borderWidth, rect.size.height);
-                                   UIBezierPathAppendPath(borderPath, [UIBezierPath bezierPathWithRect:borderRect]);
-                                 }
-                               }];
-
-  // 3. Perform a single batch fill for all borders
-  if (!borderPath.isEmpty) {
-    [borderColor setFill];
-    [borderPath fill];
+  NSRange glyphRange = [layoutManager glyphRangeForCharacterRange:region actualCharacterRange:NULL];
+  CGRect blockRect = [layoutManager boundingRectForGlyphRange:glyphRange inTextContainer:textContainer];
+  if (CGRectIsEmpty(blockRect)) {
+    return;
+  }
+
+  blockRect.origin.x = origin.x;
+  blockRect.origin.y += origin.y;
+  blockRect.size.width = containerWidth;
+
+  BOOL isLastBlockquote = (NSMaxRange(region) == textStorage.length);
+  if (isLastBlockquote) {
+    blockRect.size.height += c.blockquotePadding;
+  }
+
+  NSMutableArray<NSValue *> *boxRanges = [NSMutableArray array];
+  NSMutableArray<NSNumber *> *boxLevels = [NSMutableArray array];
+  NSMutableArray<UIBezierPath *> *boxStripePaths = [NSMutableArray array];
+  if (borderRadius > 0) {
+    NSMutableArray<NSValue *> *runRanges = [NSMutableArray array];
+    NSMutableArray<NSNumber *> *runDepths = [NSMutableArray array];
+    [textStorage enumerateAttribute:BlockquoteDepthAttributeName
+                            inRange:region
+                            options:0
+                         usingBlock:^(id value, NSRange range, BOOL *stop) {
+                           if (!value) {
+                             return;
+                           }
+                           [runRanges addObject:[NSValue valueWithRange:range]];
+                           [runDepths addObject:value];
+                         }];
+    collectNestedBoxes(runRanges, runDepths, boxRanges, boxLevels);
+    for (NSUInteger i = 0; i < boxRanges.count; i++) {
+      [boxStripePaths addObject:[UIBezierPath bezierPath]];
+    }
+  }
+
+  CGContextRef ctx = UIGraphicsGetCurrentContext();
+  CGContextSaveGState(ctx);
+  {
+    UIBezierPath *boxPath = UIBezierPathWithRoundedRect(blockRect, MAX(0, borderRadius));
+    [boxPath addClip];
+
+    // 1. Draw Background (Painter's algorithm: draw backgrounds before borders)
+    RCTUIColor *bgColor = [textStorage attribute:BlockquoteBackgroundColorAttributeName
+                                         atIndex:region.location
+                                  effectiveRange:NULL]
+                              ?: defaultBgColor;
+    if (bgColor && bgColor != [RCTUIColor clearColor]) {
+      [bgColor setFill];
+      CGContextFillRect(ctx, blockRect);
+    }
+
+    // 2. Aggregate vertical borders into batch paths; level-0 stripes are
+    // rounded by the region clip, nested stripes by their own box clip below
+    UIBezierPath *borderPath = [UIBezierPath bezierPath];
+    [layoutManager
+        enumerateLineFragmentsForGlyphRange:glyphRange
+                                 usingBlock:^(CGRect rect, CGRect usedRect, NSTextContainer *container,
+                                              NSRange lineGlyphRange, BOOL *stop) {
+                                   NSRange lineCharRange = [layoutManager characterRangeForGlyphRange:lineGlyphRange
+                                                                                     actualGlyphRange:NULL];
+                                   if (lineCharRange.location == NSNotFound || lineCharRange.length == 0) {
+                                     return;
+                                   }
+
+                                   NSDictionary *attrs = [textStorage attributesAtIndex:lineCharRange.location
+                                                                         effectiveRange:NULL];
+                                   NSNumber *depthNum = attrs[BlockquoteDepthAttributeName];
+
+                                   if (!depthNum) {
+                                     return;
+                                   }
+
+                                   NSInteger depth = [depthNum integerValue];
+                                   CGFloat baseY = origin.y + rect.origin.y;
+                                   CGFloat lineHeight = rect.size.height;
+                                   BOOL isLastLine = NSMaxRange(lineGlyphRange) == NSMaxRange(glyphRange);
+                                   if (isLastBlockquote && isLastLine) {
+                                     lineHeight += c.blockquotePadding;
+                                   }
+                                   BOOL isRTL = ENRMParagraphIsRTL(attrs[NSParagraphStyleAttributeName]);
+
+                                   for (NSInteger level = 0; level <= depth; level++) {
+                                     CGFloat borderX =
+                                         isRTL ? origin.x + containerWidth - borderWidth - (levelSpacing * level)
+                                               : origin.x + (levelSpacing * level);
+                                     CGRect borderRect = CGRectMake(borderX, baseY, borderWidth, lineHeight);
+
+                                     UIBezierPath *target = borderPath;
+                                     for (NSUInteger b = 0; b < boxRanges.count; b++) {
+                                       if (boxLevels[b].integerValue == level &&
+                                           NSLocationInRange(lineCharRange.location, boxRanges[b].rangeValue)) {
+                                         target = boxStripePaths[b];
+                                         break;
+                                       }
+                                     }
+                                     UIBezierPathAppendPath(target, [UIBezierPath bezierPathWithRect:borderRect]);
+                                   }
+                                 }];
+
+    // 3. Perform a single batch fill for the root-level borders
+    if (!borderPath.isEmpty) {
+      [borderColor setFill];
+      [borderPath fill];
+    }
+
+    // 4. Nested stripes: clip each to its own quote's rounded box (the clips
+    // compose with the still-active region clip)
+    for (NSUInteger b = 0; b < boxRanges.count; b++) {
+      UIBezierPath *stripes = boxStripePaths[b];
+      if (stripes.isEmpty) {
+        continue;
+      }
+
+      NSRange boxRange = boxRanges[b].rangeValue;
+      NSRange boxGlyphRange = [layoutManager glyphRangeForCharacterRange:boxRange actualCharacterRange:NULL];
+      CGRect boxRect = [layoutManager boundingRectForGlyphRange:boxGlyphRange inTextContainer:textContainer];
+      if (CGRectIsEmpty(boxRect)) {
+        continue;
+      }
+
+      NSDictionary *boxAttrs = [textStorage attributesAtIndex:boxRange.location effectiveRange:NULL];
+      BOOL boxRTL = ENRMParagraphIsRTL(boxAttrs[NSParagraphStyleAttributeName]);
+      CGFloat leadingInset = levelSpacing * boxLevels[b].integerValue;
+      boxRect.origin.x = boxRTL ? origin.x : origin.x + leadingInset;
+      boxRect.origin.y += origin.y;
+      boxRect.size.width = containerWidth - leadingInset;
+
+      CGContextSaveGState(ctx);
+      [UIBezierPathWithRoundedRect(boxRect, borderRadius) addClip];
+      [borderColor setFill];
+      [stripes fill];
+      CGContextRestoreGState(ctx);
+    }
   }
+  CGContextRestoreGState(ctx);
 }
 
-@end
+@end

package/ios/utils/CodeBackground.m

@@ -1,4 +1,5 @@
 #import "CodeBackground.h"
+#import "ENRMChipDrawing.h"
 #import "ENRMUIKit.h"
 #import "RenderContext.h"
 
@@ -116,71 +117,8 @@ static const CGFloat kCodeBackgroundBorderWidth = 0.5;
                          isFirst:(BOOL)isFirst
                           isLast:(BOOL)isLast
 {
-  UIBezierPath *path = [self pathForRect:rect isFirst:isFirst isLast:isLast];
-  [backgroundColor setFill];
-  [path fill];
-
-  if (borderColor) {
-    [borderColor setStroke];
-    UIBezierPath *strokePath =
-        (isFirst && isLast) ? path : [self openBorderPathForRect:rect isFirst:isFirst isLast:isLast];
-    strokePath.lineWidth = kCodeBackgroundBorderWidth;
-    BezierPathSetRoundStyle(strokePath);
-    [strokePath stroke];
-  }
-}
-
-- (UIBezierPath *)pathForRect:(CGRect)rect isFirst:(BOOL)isFirst isLast:(BOOL)isLast
-{
-#if !TARGET_OS_OSX
-  UIRectCorner corners = 0;
-  if (isFirst)
-    corners |= (UIRectCornerTopLeft | UIRectCornerBottomLeft);
-  if (isLast)
-    corners |= (UIRectCornerTopRight | UIRectCornerBottomRight);
-
-  return [UIBezierPath bezierPathWithRoundedRect:rect
-                               byRoundingCorners:corners
-                                     cornerRadii:CGSizeMake(kCodeBackgroundCornerRadius, kCodeBackgroundCornerRadius)];
-#else
-  // NSBezierPath doesn't support per-corner rounding — use uniform corner radius
-  CGFloat cornerRadius = (isFirst || isLast) ? kCodeBackgroundCornerRadius : 0;
-  return UIBezierPathWithRoundedRect(rect, cornerRadius);
-#endif
-}
-
-- (UIBezierPath *)openBorderPathForRect:(CGRect)rect isFirst:(BOOL)isFirst isLast:(BOOL)isLast
-{
-  UIBezierPath *path = [UIBezierPath bezierPath];
-  CGFloat r = kCodeBackgroundCornerRadius;
-  CGFloat inset = kCodeBackgroundBorderWidth / 2.0;
-  CGRect insetRect = CGRectInset(rect, inset, inset);
-
-  if (isFirst) {
-    [path moveToPoint:CGPointMake(CGRectGetMaxX(rect), insetRect.origin.y)];
-    BezierPathAddLine(path, CGPointMake(insetRect.origin.x + r, insetRect.origin.y));
-    BezierPathAddQuadCurve(path, CGPointMake(insetRect.origin.x, insetRect.origin.y + r),
-                           CGPointMake(insetRect.origin.x, insetRect.origin.y));
-    BezierPathAddLine(path, CGPointMake(insetRect.origin.x, CGRectGetMaxY(insetRect) - r));
-    BezierPathAddQuadCurve(path, CGPointMake(insetRect.origin.x + r, CGRectGetMaxY(insetRect)),
-                           CGPointMake(insetRect.origin.x, CGRectGetMaxY(insetRect)));
-    BezierPathAddLine(path, CGPointMake(CGRectGetMaxX(rect), CGRectGetMaxY(insetRect)));
-  } else if (isLast) {
-    [path moveToPoint:CGPointMake(rect.origin.x, insetRect.origin.y)];
-    BezierPathAddLine(path, CGPointMake(CGRectGetMaxX(insetRect) - r, insetRect.origin.y));
-    BezierPathAddQuadCurve(path, CGPointMake(CGRectGetMaxX(insetRect), insetRect.origin.y + r),
-                           CGPointMake(CGRectGetMaxX(insetRect), insetRect.origin.y));
-    BezierPathAddLine(path, CGPointMake(CGRectGetMaxX(insetRect), CGRectGetMaxY(insetRect) - r));
-    BezierPathAddQuadCurve(path, CGPointMake(CGRectGetMaxX(insetRect) - r, CGRectGetMaxY(insetRect)),
-                           CGPointMake(CGRectGetMaxX(insetRect), CGRectGetMaxY(insetRect)));
-    BezierPathAddLine(path, CGPointMake(rect.origin.x, CGRectGetMaxY(insetRect)));
-  } else {
-    [path moveToPoint:CGPointMake(rect.origin.x, insetRect.origin.y)];
-    BezierPathAddLine(path, CGPointMake(CGRectGetMaxX(rect), insetRect.origin.y));
-    [path moveToPoint:CGPointMake(rect.origin.x, CGRectGetMaxY(insetRect))];
-    BezierPathAddLine(path, CGPointMake(CGRectGetMaxX(rect), CGRectGetMaxY(insetRect)));
-  }
-  return path;
+  ENRMDrawChipFragment(rect, backgroundColor, borderColor, kCodeBackgroundBorderWidth, kCodeBackgroundCornerRadius,
+                       isFirst, isLast, NO);
 }
 
 #pragma mark - Helpers

package/ios/utils/CodeBlockBackground.m

@@ -3,6 +3,11 @@
 #import "LastElementUtils.h"
 #import "StyleConfig.h"
 
+// Draws the commonmark-flavor code block box behind the text view's glyph
+// runs. The visual conventions (half-stroke border inset, corner radius
+// handling) must stay in sync with the whole-rect box the github flavor
+// draws in ENRMCodeBlockContainerView's drawRect:.
+
 @implementation CodeBlockBackground {
   StyleConfig *_config;
 }
@@ -53,9 +58,18 @@
   if (CGRectIsEmpty(blockRect))
     return;
 
-  blockRect.origin.x = origin.x;
+  NSNumber *indentAttr = [layoutManager.textStorage attribute:CodeBlockIndentAttributeName
+                                                      atIndex:range.location
+                                               effectiveRange:NULL];
+  CGFloat indent = [indentAttr doubleValue];
+
+  CGFloat availableWidth = textContainer.size.width - indent;
+  if (availableWidth <= 0)
+    return;
+
+  blockRect.origin.x = origin.x + indent;
   blockRect.origin.y += origin.y;
-  blockRect.size.width = textContainer.size.width;
+  blockRect.size.width = availableWidth;
 
   // We extend the background specifically to cover the bottom padding spacer,
   // excluding any additional marginBottom applied via measurement.

package/ios/utils/ENRMAtomicSize.h

@@ -0,0 +1,65 @@
+#pragma once
+
+#include <CoreGraphics/CGGeometry.h>
+#include <atomic>
+#include <cstdint>
+#include <cstring>
+
+/**
+ * Lock-free size mailbox (issue #550).
+ *
+ * `measureContent` may run on the JS/layout thread while React Native holds
+ * the ShadowTree revision mutex (`preventShadowTreeCommitExhaustion` re-runs
+ * the entire commit — layout included — under `revisionMutexRecursive_` after
+ * three failed optimistic commits). A main-thread committer (e.g. Reanimated)
+ * can already be blocked on that same mutex, so any `dispatch_sync` to main
+ * from the measure path can deadlock: JS waits for main, main waits for the
+ * mutex JS holds. iOS kills the frozen app ~60s later (watchdog 0x8BADF00D).
+ *
+ * Reading `view.bounds` from a background thread is not safe either, so the
+ * component view *publishes* its last committed size here (from
+ * `updateLayoutMetrics:`, always on main) and the measure path *loads* it
+ * wait-free from any thread.
+ *
+ * Both dimensions are packed as IEEE-754 floats into one `uint64_t` so a
+ * single lock-free atomic covers the pair — a reader can never observe a new
+ * width with an old height (no torn reads). Relaxed memory ordering suffices:
+ * the value is self-contained and no other memory is published through it.
+ */
+class ENRMAtomicSize {
+public:
+  void store(CGSize size)
+  {
+    bits_.store(pack(size), std::memory_order_relaxed);
+  }
+
+  CGSize load() const
+  {
+    return unpack(bits_.load(std::memory_order_relaxed));
+  }
+
+private:
+  static uint64_t pack(CGSize size)
+  {
+    float width = (float)size.width;
+    float height = (float)size.height;
+    uint32_t widthBits;
+    uint32_t heightBits;
+    memcpy(&widthBits, &width, sizeof(widthBits));
+    memcpy(&heightBits, &height, sizeof(heightBits));
+    return ((uint64_t)widthBits << 32) | heightBits;
+  }
+
+  static CGSize unpack(uint64_t bits)
+  {
+    uint32_t widthBits = (uint32_t)(bits >> 32);
+    uint32_t heightBits = (uint32_t)bits;
+    float width;
+    float height;
+    memcpy(&width, &widthBits, sizeof(width));
+    memcpy(&height, &heightBits, sizeof(height));
+    return CGSizeMake(width, height);
+  }
+
+  std::atomic<uint64_t> bits_{0};
+};

package/ios/utils/ENRMBlockMenu.h

@@ -0,0 +1,66 @@
+#pragma once
+#import "ENRMUIKit.h"
+#include <TargetConditionals.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// Selection-menu options that table, math and code block views need for their
+/// own long-press menus. Every field is phrased so that the zero value keeps the
+/// legacy behavior, so a block view that has not received options yet behaves
+/// exactly as before.
+typedef struct {
+  // `selectionMenuConfig.copy.enabled == false`.
+  BOOL copyHidden;
+  // `selectionMenuConfig.copy.format == 'markdown'`: the Copy item writes the
+  // block's Markdown instead of its raw content.
+  BOOL copyWritesMarkdown;
+  // `selectionMenuConfig.copyAsMarkdown.enabled == false`.
+  BOOL copyAsMarkdownHidden;
+  // `selectionMenuConfig.codeBlockCopyButton.enabled == false`.
+  BOOL copyButtonHidden;
+  // JS `onCopy` is set: the Copy item hands the block's content to the view's
+  // `onCopyRequest` instead of writing the pasteboard.
+  BOOL interceptCopy;
+} ENRMBlockMenuOptions;
+
+/// Receives an intercepted block Copy: the block's Markdown and its raw content.
+typedef void (^ENRMBlockCopyRequestBlock)(NSString *markdown, NSString *text);
+
+#if !TARGET_OS_OSX
+/// Builds the long-press menu shared by the table, math and code block views.
+/// Returns nil when no item is left — nil is how UIKit suppresses a context
+/// menu, whereas an empty menu would still lift the view. `requestCopy` replaces
+/// the Copy item's handler when `options.interceptCopy` is set.
+static inline UIContextMenuConfiguration *_Nullable ENRMBlockContextMenuConfiguration(
+    ENRMBlockMenuOptions options, NSString *_Nullable copyLabel, NSString *_Nullable copyAsMarkdownLabel,
+    void (^copyRaw)(void), void (^copyMarkdown)(void), void (^_Nullable requestCopy)(void))
+{
+  if (options.copyHidden && options.copyAsMarkdownHidden) {
+    return nil;
+  }
+  void (^copyHandler)(void) = (options.interceptCopy && requestCopy) ? requestCopy
+                              : options.copyWritesMarkdown           ? copyMarkdown
+                                                                     : copyRaw;
+  return [UIContextMenuConfiguration
+      configurationWithIdentifier:nil
+                  previewProvider:nil
+                   actionProvider:^UIMenu *(NSArray<UIMenuElement *> *suggestedActions) {
+                     NSMutableArray<UIMenuElement *> *children = [NSMutableArray arrayWithCapacity:2];
+                     if (!options.copyHidden) {
+                       [children addObject:[UIAction actionWithTitle:copyLabel ?: @""
+                                                               image:[RCTUIImage systemImageNamed:@"doc.on.doc"]
+                                                          identifier:nil
+                                                             handler:^(__kindof UIAction *action) { copyHandler(); }]];
+                     }
+                     if (!options.copyAsMarkdownHidden) {
+                       [children addObject:[UIAction actionWithTitle:copyAsMarkdownLabel ?: @""
+                                                               image:[RCTUIImage systemImageNamed:@"doc.text"]
+                                                          identifier:nil
+                                                             handler:^(__kindof UIAction *action) { copyMarkdown(); }]];
+                     }
+                     return [UIMenu menuWithTitle:@"" children:children];
+                   }];
+}
+#endif
+
+NS_ASSUME_NONNULL_END

package/ios/utils/ENRMChipDrawing.h

@@ -0,0 +1,24 @@
+#pragma once
+#import "ENRMUIKit.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/// Fills (and optionally strokes) one line fragment of an inline "chip" — the
+/// rounded background shared by inline code and link chips. For a chip that
+/// wraps, only the outer ends are rounded (`isFirst` / `isLast`) and the border
+/// stays open where the fragment is cut.
+///
+/// `strokeInset` keeps a closed border inside `rect` (link chips); otherwise it
+/// is centered on the edge (inline code, kept for pixel parity).
+void ENRMDrawChipFragment(CGRect rect, RCTUIColor *_Nullable backgroundColor, RCTUIColor *_Nullable borderColor,
+                          CGFloat borderWidth, CGFloat cornerRadius, BOOL isFirst, BOOL isLast, BOOL strokeInset);
+
+#ifdef __cplusplus
+}
+#endif
+
+NS_ASSUME_NONNULL_END