react-native-enriched-markdown-scaffold 1.0.2-scaffold.1 → 1.0.2-scaffold.10

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/internals/MeasurementCache.h

@@ -128,6 +128,11 @@ template <typename StyleStruct> inline size_t computeStyleFingerprint(const Styl
              s.codeBlock.borderWidth);
   hashFields(s.code.fontFamily, s.code.fontSize);
   hashFields(s.link.fontFamily, s.strong.fontFamily, s.strong.fontWeight, s.em.fontFamily, s.em.fontStyle);
+  // Link chip horizontal padding reserves space in the line; variants can set their own.
+  hashFields(s.link.paddingHorizontal);
+  for (const auto &variant : s.linkVariants) {
+    hashFields(variant.pattern, variant.paddingHorizontal);
+  }
   hashFields(s.highlight.backgroundColor, s.highlight.color);
 
   // Visual/Spacing Elements
@@ -139,8 +144,9 @@ template <typename StyleStruct> inline size_t computeStyleFingerprint(const Styl
   hashTextLayout(s.table);
   hashFields(s.table.headerFontFamily, s.table.cellPaddingHorizontal, s.table.cellPaddingVertical, s.table.borderWidth,
              s.table.borderRadius, s.table.horizontalOverflow);
-  hashFields(s.math.fontSize, s.math.padding, s.math.marginTop, s.math.marginBottom, s.math.textAlign);
-  hashFields(s.inlineMath.paddingVertical);
+  hashFields(s.math.fontSize, s.math.padding, s.math.marginTop, s.math.marginBottom, s.math.textAlign,
+             s.math.glyphOverflow);
+  hashFields(s.inlineMath.paddingVertical, s.inlineMath.glyphOverflow);
   hashFields(s.taskList.checkboxSize, s.taskList.checkboxBorderRadius);
 
   return h;

package/ios/math/ENRMRaTeXBridge.swift

@@ -42,23 +42,39 @@ public final class ENRMRaTeXRenderResult: NSObject {
   /// Non-zero only in bold mode: half of it grows the glyph ink on each side.
   private let boldStrokeWidth: CGFloat
   private let boldStrokeColor: CGColor?
+  /// Headroom added above and below RaTeX's box. RaTeX sizes a formula by its TeX
+  /// metric box, which digit and capital outlines (and the bold stroke) overshoot;
+  /// every view and attachment clips to `totalHeight`, so that ink needs room inside it.
+  private let glyphOverflow: CGFloat
 
   @objc public let width: CGFloat
   @objc public let ascent: CGFloat
   @objc public let descent: CGFloat
   @objc public var totalHeight: CGFloat { ascent + descent }
 
-  init(renderer: RaTeXRenderer, boldStrokeWidth: CGFloat, boldStrokeColor: CGColor?) {
+  init(renderer: RaTeXRenderer, boldStrokeWidth: CGFloat, boldStrokeColor: CGColor?, glyphOverflow: CGFloat) {
     self.renderer = renderer
     self.boldStrokeWidth = boldStrokeWidth
     self.boldStrokeColor = boldStrokeColor
+    self.glyphOverflow = max(glyphOverflow, 0)
     self.width = renderer.width
-    self.ascent = renderer.height
-    self.descent = renderer.depth
+    self.ascent = renderer.height + self.glyphOverflow
+    self.descent = renderer.depth + self.glyphOverflow
     super.init()
   }
 
   @objc public func draw(in context: CGContext) {
+    guard glyphOverflow > 0 else {
+      drawFormula(in: context)
+      return
+    }
+    context.saveGState()
+    context.translateBy(x: 0, y: glyphOverflow)
+    drawFormula(in: context)
+    context.restoreGState()
+  }
+
+  private func drawFormula(in context: CGContext) {
     guard boldStrokeWidth > 0, let boldStrokeColor else {
       renderer.draw(in: context)
       return
@@ -90,7 +106,8 @@ public final class ENRMRaTeXBridge: NSObject {
     displayMode: Bool,
     fontSize: CGFloat,
     color: UIColor,
-    bold: Bool
+    bold: Bool,
+    glyphOverflow: CGFloat
   ) -> ENRMRaTeXRenderResult? {
     RaTeXFontLoader.ensureLoaded()
     do {
@@ -100,7 +117,8 @@ public final class ENRMRaTeXBridge: NSObject {
       return ENRMRaTeXRenderResult(
         renderer: renderer,
         boldStrokeWidth: strokeWidth,
-        boldStrokeColor: strokeWidth > 0 ? color.cgColor : nil
+        boldStrokeColor: strokeWidth > 0 ? color.cgColor : nil,
+        glyphOverflow: glyphOverflow
       )
     } catch {
       NSLog("[RaTeX] Failed to parse LaTeX: %@", error.localizedDescription)

package/ios/renderer/ENRMMathInlineRenderer.m

@@ -30,6 +30,7 @@
   attachment.mathTextColor = [_config inlineMathColor];
   attachment.containerPaddingVertical = [_config inlineMathPaddingVertical];
   attachment.bold = ENRMMathFontWeightIsBold([_config inlineMathFontWeight]);
+  attachment.glyphOverflow = [_config inlineMathGlyphOverflow];
 
 #if TARGET_OS_OSX
   // On macOS, NSLayoutManager uses self.image/self.bounds rather than calling

package/ios/renderer/LinkRenderer.m

@@ -1,4 +1,5 @@
 #import "LinkRenderer.h"
+#import "ENRMLinkChip.h"
 #import "FontUtils.h"
 #import "RenderContext.h"
 #import "RendererFactory.h"
@@ -13,31 +14,49 @@
                      into:(NSMutableAttributedString *)output
                   context:(RenderContext *)context
 {
-  NSUInteger start = output.length;
-
-  // 1. Render children first to establish base attributes
-  [_rendererFactory renderChildrenOfNode:node into:output context:context];
-
-  NSRange range = NSMakeRange(start, output.length - start);
-  if (range.length == 0)
-    return;
-
-  // 2. Extract configuration
+  // 1. Extract configuration
   NSString *url = node.attributes[@"url"] ?: @"";
   LinkVariantConfig *variant = [_config effectiveLinkVariantForURL:url];
 
   RCTUIColor *linkColor = variant.color ?: [_config linkColor];
   BOOL linkUnderline = variant ? variant.underline : [_config linkUnderline];
   NSString *linkFontFamily = [_config linkFontFamily];
-  RCTUIColor *backgroundColor = variant ? variant.backgroundColor : [_config linkBackgroundColor];
+  // Chip ("box") properties never fall back to the base link style.
+  ENRMLinkChip *chip = [[ENRMLinkChip alloc] init];
+  chip.backgroundColor = variant ? variant.backgroundColor : [_config linkBackgroundColor];
+  chip.borderColor = variant ? variant.borderColor : [_config linkBorderColor];
+  chip.borderWidth = variant ? variant.borderWidth : [_config linkBorderWidth];
+  chip.borderRadius = variant ? variant.borderRadius : [_config linkBorderRadius];
+  chip.paddingHorizontal = variant ? variant.paddingHorizontal : [_config linkPaddingHorizontal];
+  chip.paddingVertical = variant ? variant.paddingVertical : [_config linkPaddingVertical];
+  BOOL hasSpacers = chip.paddingHorizontal > 0;
 
   NSNumber *underlineStyle = @(linkUnderline ? NSUnderlineStyleSingle : NSUnderlineStyleNone);
 
+  // 2. Render children to establish base attributes. With horizontal padding, a
+  // leading spacer goes in first so ranges the children register stay valid;
+  // its attributes are fixed up once the first child glyph exists.
+  NSUInteger start = output.length;
+  if (hasSpacers) {
+    [output appendAttributedString:ENRMLinkSpacerString([context getTextAttributes], chip.paddingHorizontal)];
+  }
+  NSUInteger contentStart = output.length;
+
+  [_rendererFactory renderChildrenOfNode:node into:output context:context];
+
+  NSRange contentRange = NSMakeRange(contentStart, output.length - contentStart);
+  if (contentRange.length == 0) {
+    if (hasSpacers) {
+      [output deleteCharactersInRange:NSMakeRange(start, contentStart - start)];
+    }
+    return;
+  }
+
   // 3. Apply core link functionality (non-destructive)
-  [output addAttribute:NSLinkAttributeName value:url range:range];
+  [output addAttribute:NSLinkAttributeName value:url range:contentRange];
 
   // 4. Optimize visual attributes via enumeration to avoid redundant updates
-  [output enumerateAttributesInRange:range
+  [output enumerateAttributesInRange:contentRange
                              options:NSAttributedStringEnumerationLongestEffectiveRangeNotRequired
                           usingBlock:^(NSDictionary<NSAttributedStringKey, id> *attrs, NSRange subrange, BOOL *stop) {
                             NSMutableDictionary *newAttributes = [NSMutableDictionary dictionary];
@@ -74,10 +93,23 @@
                             }
                           }];
 
-  if (backgroundColor) {
-    [output addAttribute:NSBackgroundColorAttributeName value:backgroundColor range:range];
+  // 5. Reserve horizontal padding with a spacer at each outer edge (see
+  // ENRMLinkSpacerString). Spacers sit inside the link range, so tapping the
+  // padding hits the link.
+  NSRange range = contentRange;
+  if (hasSpacers) {
+    NSDictionary *firstAttrs = [output attributesAtIndex:contentRange.location effectiveRange:NULL];
+    NSDictionary *lastAttrs = [output attributesAtIndex:NSMaxRange(contentRange) - 1 effectiveRange:NULL];
+    NSAttributedString *leading = ENRMLinkSpacerString(firstAttrs, chip.paddingHorizontal);
+    [output setAttributes:[leading attributesAtIndex:0 effectiveRange:NULL] range:NSMakeRange(start, 1)];
+    [output appendAttributedString:ENRMLinkSpacerString(lastAttrs, chip.paddingHorizontal)];
+    range = NSMakeRange(start, output.length - start);
   }
 
+  // 6. Chip background/border is drawn by the layout manager (see ENRMLinkChip).
+  // Attached even when invisible so the chip's padding is known to link-layout reporting.
+  [output addAttribute:ENRMLinkChipAttributeName value:chip range:range];
+
   [context registerLinkRange:range url:url];
 }
 

package/ios/styles/StyleConfig.h

@@ -13,6 +13,12 @@ NS_ASSUME_NONNULL_BEGIN
 @property (nonatomic, strong) RCTUIColor *color;
 @property (nonatomic, assign) BOOL underline;
 @property (nonatomic, strong, nullable) RCTUIColor *backgroundColor;
+// Chip ("box") properties — never inherited from the base link style.
+@property (nonatomic, assign) CGFloat borderRadius;
+@property (nonatomic, assign) CGFloat paddingHorizontal;
+@property (nonatomic, assign) CGFloat paddingVertical;
+@property (nonatomic, strong, nullable) RCTUIColor *borderColor;
+@property (nonatomic, assign) CGFloat borderWidth;
 @end
 
 @interface StyleConfig : NSObject <NSCopying>
@@ -166,6 +172,16 @@ NS_ASSUME_NONNULL_BEGIN
 - (void)setLinkUnderline:(BOOL)newValue;
 - (nullable RCTUIColor *)linkBackgroundColor;
 - (void)setLinkBackgroundColor:(nullable RCTUIColor *)newValue;
+- (CGFloat)linkBorderRadius;
+- (void)setLinkBorderRadius:(CGFloat)newValue;
+- (CGFloat)linkPaddingHorizontal;
+- (void)setLinkPaddingHorizontal:(CGFloat)newValue;
+- (CGFloat)linkPaddingVertical;
+- (void)setLinkPaddingVertical:(CGFloat)newValue;
+- (nullable RCTUIColor *)linkBorderColor;
+- (void)setLinkBorderColor:(nullable RCTUIColor *)newValue;
+- (CGFloat)linkBorderWidth;
+- (void)setLinkBorderWidth:(CGFloat)newValue;
 - (NSArray<LinkVariantConfig *> *)linkVariants;
 - (void)setLinkVariants:(NSArray<LinkVariantConfig *> *)newValue;
 - (nullable LinkVariantConfig *)effectiveLinkVariantForURL:(NSString *)url;
@@ -402,6 +418,8 @@ NS_ASSUME_NONNULL_BEGIN
 - (void)setMathTextAlign:(NSString *)newValue;
 - (NSString *)mathFontWeight;
 - (void)setMathFontWeight:(NSString *)newValue;
+- (CGFloat)mathGlyphOverflow;
+- (void)setMathGlyphOverflow:(CGFloat)newValue;
 
 // Inline Math properties
 - (RCTUIColor *)inlineMathColor;
@@ -410,6 +428,8 @@ NS_ASSUME_NONNULL_BEGIN
 - (void)setInlineMathPaddingVertical:(CGFloat)newValue;
 - (NSString *)inlineMathFontWeight;
 - (void)setInlineMathFontWeight:(NSString *)newValue;
+- (CGFloat)inlineMathGlyphOverflow;
+- (void)setInlineMathGlyphOverflow:(CGFloat)newValue;
 // Spoiler properties
 - (RCTUIColor *)spoilerColor;
 - (void)setSpoilerColor:(RCTUIColor *)newValue;

package/ios/styles/StyleConfig.mm

@@ -113,6 +113,11 @@ static inline NSString *normalizedFontWeight(NSString *fontWeight)
   RCTUIColor *_linkColor;
   BOOL _linkUnderline;
   RCTUIColor *_linkBackgroundColor;
+  CGFloat _linkBorderRadius;
+  CGFloat _linkPaddingHorizontal;
+  CGFloat _linkPaddingVertical;
+  RCTUIColor *_linkBorderColor;
+  CGFloat _linkBorderWidth;
   NSArray<LinkVariantConfig *> *_linkVariants;
   NSArray<LinkVariantRegexEntry *> *_compiledVariantRegexes;
   // Strong properties
@@ -239,10 +244,12 @@ static inline NSString *normalizedFontWeight(NSString *fontWeight)
   CGFloat _mathMarginBottom;
   NSString *_mathTextAlign;
   NSString *_mathFontWeight;
+  CGFloat _mathGlyphOverflow;
   // Inline Math properties
   RCTUIColor *_inlineMathColor;
   CGFloat _inlineMathPaddingVertical;
   NSString *_inlineMathFontWeight;
+  CGFloat _inlineMathGlyphOverflow;
   // Spoiler properties
   RCTUIColor *_spoilerColor;
   CGFloat _spoilerParticleDensity;
@@ -405,6 +412,11 @@ static inline NSString *normalizedFontWeight(NSString *fontWeight)
   copy->_linkColor = [_linkColor copy];
   copy->_linkUnderline = _linkUnderline;
   copy->_linkBackgroundColor = [_linkBackgroundColor copy];
+  copy->_linkBorderRadius = _linkBorderRadius;
+  copy->_linkPaddingHorizontal = _linkPaddingHorizontal;
+  copy->_linkPaddingVertical = _linkPaddingVertical;
+  copy->_linkBorderColor = [_linkBorderColor copy];
+  copy->_linkBorderWidth = _linkBorderWidth;
   copy->_linkVariants = [_linkVariants copy];
   copy->_compiledVariantRegexes = [_compiledVariantRegexes copy];
   copy->_strongFontFamily = [_strongFontFamily copy];
@@ -512,9 +524,11 @@ static inline NSString *normalizedFontWeight(NSString *fontWeight)
   copy->_mathMarginBottom = _mathMarginBottom;
   copy->_mathTextAlign = [_mathTextAlign copy];
   copy->_mathFontWeight = [_mathFontWeight copy];
+  copy->_mathGlyphOverflow = _mathGlyphOverflow;
   copy->_inlineMathColor = [_inlineMathColor copy];
   copy->_inlineMathPaddingVertical = _inlineMathPaddingVertical;
   copy->_inlineMathFontWeight = [_inlineMathFontWeight copy];
+  copy->_inlineMathGlyphOverflow = _inlineMathGlyphOverflow;
   copy->_spoilerColor = [_spoilerColor copy];
   copy->_spoilerParticleDensity = _spoilerParticleDensity;
   copy->_spoilerParticleSpeed = _spoilerParticleSpeed;
@@ -1334,6 +1348,56 @@ static inline NSString *normalizedFontWeight(NSString *fontWeight)
   _linkBackgroundColor = newValue;
 }
 
+- (CGFloat)linkBorderRadius
+{
+  return _linkBorderRadius;
+}
+
+- (void)setLinkBorderRadius:(CGFloat)newValue
+{
+  _linkBorderRadius = newValue;
+}
+
+- (CGFloat)linkPaddingHorizontal
+{
+  return _linkPaddingHorizontal;
+}
+
+- (void)setLinkPaddingHorizontal:(CGFloat)newValue
+{
+  _linkPaddingHorizontal = newValue;
+}
+
+- (CGFloat)linkPaddingVertical
+{
+  return _linkPaddingVertical;
+}
+
+- (void)setLinkPaddingVertical:(CGFloat)newValue
+{
+  _linkPaddingVertical = newValue;
+}
+
+- (RCTUIColor *)linkBorderColor
+{
+  return _linkBorderColor;
+}
+
+- (void)setLinkBorderColor:(RCTUIColor *)newValue
+{
+  _linkBorderColor = newValue;
+}
+
+- (CGFloat)linkBorderWidth
+{
+  return _linkBorderWidth;
+}
+
+- (void)setLinkBorderWidth:(CGFloat)newValue
+{
+  _linkBorderWidth = newValue;
+}
+
 - (NSArray<LinkVariantConfig *> *)linkVariants
 {
   return _linkVariants;
@@ -2598,6 +2662,26 @@ static const CGFloat kDefaultMinGap = 4.0;
   _inlineMathPaddingVertical = newValue;
 }
 
+- (CGFloat)mathGlyphOverflow
+{
+  return _mathGlyphOverflow;
+}
+
+- (void)setMathGlyphOverflow:(CGFloat)newValue
+{
+  _mathGlyphOverflow = newValue;
+}
+
+- (CGFloat)inlineMathGlyphOverflow
+{
+  return _inlineMathGlyphOverflow;
+}
+
+- (void)setInlineMathGlyphOverflow:(CGFloat)newValue
+{
+  _inlineMathGlyphOverflow = newValue;
+}
+
 // ── Spoiler ─────────────────────────────────────────────────────────────
 
 - (RCTUIColor *)spoilerColor

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/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