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

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

@@ -997,6 +997,11 @@ struct EnrichedMarkdownMarkdownStyleLinkStruct {
   SharedColor color{};
   bool underline{false};
   SharedColor backgroundColor{};
+  Float borderRadius{0.0};
+  Float paddingHorizontal{0.0};
+  Float paddingVertical{0.0};
+  SharedColor borderColor{};
+  Float borderWidth{0.0};
 
 
 #ifdef RN_SERIALIZABLE_STATE
@@ -1008,6 +1013,11 @@ struct EnrichedMarkdownMarkdownStyleLinkStruct {
     result["color"] = ::facebook::react::toDynamic(color);
     result["underline"] = underline;
     result["backgroundColor"] = ::facebook::react::toDynamic(backgroundColor);
+    result["borderRadius"] = borderRadius;
+    result["paddingHorizontal"] = paddingHorizontal;
+    result["paddingVertical"] = paddingVertical;
+    result["borderColor"] = ::facebook::react::toDynamic(borderColor);
+    result["borderWidth"] = borderWidth;
     return result;
   }
 #endif
@@ -1032,6 +1042,26 @@ static inline void fromRawValue(const PropsParserContext& context, const RawValu
   if (tmp_backgroundColor != map.end()) {
     fromRawValue(context, tmp_backgroundColor->second, result.backgroundColor);
   }
+  auto tmp_borderRadius = map.find("borderRadius");
+  if (tmp_borderRadius != map.end()) {
+    fromRawValue(context, tmp_borderRadius->second, result.borderRadius);
+  }
+  auto tmp_paddingHorizontal = map.find("paddingHorizontal");
+  if (tmp_paddingHorizontal != map.end()) {
+    fromRawValue(context, tmp_paddingHorizontal->second, result.paddingHorizontal);
+  }
+  auto tmp_paddingVertical = map.find("paddingVertical");
+  if (tmp_paddingVertical != map.end()) {
+    fromRawValue(context, tmp_paddingVertical->second, result.paddingVertical);
+  }
+  auto tmp_borderColor = map.find("borderColor");
+  if (tmp_borderColor != map.end()) {
+    fromRawValue(context, tmp_borderColor->second, result.borderColor);
+  }
+  auto tmp_borderWidth = map.find("borderWidth");
+  if (tmp_borderWidth != map.end()) {
+    fromRawValue(context, tmp_borderWidth->second, result.borderWidth);
+  }
 }
 
 static inline std::string toString(const EnrichedMarkdownMarkdownStyleLinkStruct &value) {
@@ -1049,6 +1079,11 @@ struct EnrichedMarkdownMarkdownStyleLinkVariantsStruct {
   SharedColor color{};
   bool underline{false};
   SharedColor backgroundColor{};
+  Float borderRadius{0.0};
+  Float paddingHorizontal{0.0};
+  Float paddingVertical{0.0};
+  SharedColor borderColor{};
+  Float borderWidth{0.0};
 
 
 #ifdef RN_SERIALIZABLE_STATE
@@ -1060,6 +1095,11 @@ struct EnrichedMarkdownMarkdownStyleLinkVariantsStruct {
     result["color"] = ::facebook::react::toDynamic(color);
     result["underline"] = underline;
     result["backgroundColor"] = ::facebook::react::toDynamic(backgroundColor);
+    result["borderRadius"] = borderRadius;
+    result["paddingHorizontal"] = paddingHorizontal;
+    result["paddingVertical"] = paddingVertical;
+    result["borderColor"] = ::facebook::react::toDynamic(borderColor);
+    result["borderWidth"] = borderWidth;
     return result;
   }
 #endif
@@ -1084,6 +1124,26 @@ static inline void fromRawValue(const PropsParserContext& context, const RawValu
   if (tmp_backgroundColor != map.end()) {
     fromRawValue(context, tmp_backgroundColor->second, result.backgroundColor);
   }
+  auto tmp_borderRadius = map.find("borderRadius");
+  if (tmp_borderRadius != map.end()) {
+    fromRawValue(context, tmp_borderRadius->second, result.borderRadius);
+  }
+  auto tmp_paddingHorizontal = map.find("paddingHorizontal");
+  if (tmp_paddingHorizontal != map.end()) {
+    fromRawValue(context, tmp_paddingHorizontal->second, result.paddingHorizontal);
+  }
+  auto tmp_paddingVertical = map.find("paddingVertical");
+  if (tmp_paddingVertical != map.end()) {
+    fromRawValue(context, tmp_paddingVertical->second, result.paddingVertical);
+  }
+  auto tmp_borderColor = map.find("borderColor");
+  if (tmp_borderColor != map.end()) {
+    fromRawValue(context, tmp_borderColor->second, result.borderColor);
+  }
+  auto tmp_borderWidth = map.find("borderWidth");
+  if (tmp_borderWidth != map.end()) {
+    fromRawValue(context, tmp_borderWidth->second, result.borderWidth);
+  }
 }
 
 static inline std::string toString(const EnrichedMarkdownMarkdownStyleLinkVariantsStruct &value) {
@@ -2826,6 +2886,7 @@ class EnrichedMarkdownProps final : public ViewProps {
 
   std::string markdown{};
   EnrichedMarkdownMarkdownStyleStruct markdownStyle{};
+  bool emitLinkLayout{false};
   bool enableTaskListItemToggle{true};
   bool enableLinkPreview{true};
   bool selectable{false};
@@ -4980,6 +5041,11 @@ struct EnrichedMarkdownTextMarkdownStyleLinkStruct {
   SharedColor color{};
   bool underline{false};
   SharedColor backgroundColor{};
+  Float borderRadius{0.0};
+  Float paddingHorizontal{0.0};
+  Float paddingVertical{0.0};
+  SharedColor borderColor{};
+  Float borderWidth{0.0};
 
 
 #ifdef RN_SERIALIZABLE_STATE
@@ -4991,6 +5057,11 @@ struct EnrichedMarkdownTextMarkdownStyleLinkStruct {
     result["color"] = ::facebook::react::toDynamic(color);
     result["underline"] = underline;
     result["backgroundColor"] = ::facebook::react::toDynamic(backgroundColor);
+    result["borderRadius"] = borderRadius;
+    result["paddingHorizontal"] = paddingHorizontal;
+    result["paddingVertical"] = paddingVertical;
+    result["borderColor"] = ::facebook::react::toDynamic(borderColor);
+    result["borderWidth"] = borderWidth;
     return result;
   }
 #endif
@@ -5015,6 +5086,26 @@ static inline void fromRawValue(const PropsParserContext& context, const RawValu
   if (tmp_backgroundColor != map.end()) {
     fromRawValue(context, tmp_backgroundColor->second, result.backgroundColor);
   }
+  auto tmp_borderRadius = map.find("borderRadius");
+  if (tmp_borderRadius != map.end()) {
+    fromRawValue(context, tmp_borderRadius->second, result.borderRadius);
+  }
+  auto tmp_paddingHorizontal = map.find("paddingHorizontal");
+  if (tmp_paddingHorizontal != map.end()) {
+    fromRawValue(context, tmp_paddingHorizontal->second, result.paddingHorizontal);
+  }
+  auto tmp_paddingVertical = map.find("paddingVertical");
+  if (tmp_paddingVertical != map.end()) {
+    fromRawValue(context, tmp_paddingVertical->second, result.paddingVertical);
+  }
+  auto tmp_borderColor = map.find("borderColor");
+  if (tmp_borderColor != map.end()) {
+    fromRawValue(context, tmp_borderColor->second, result.borderColor);
+  }
+  auto tmp_borderWidth = map.find("borderWidth");
+  if (tmp_borderWidth != map.end()) {
+    fromRawValue(context, tmp_borderWidth->second, result.borderWidth);
+  }
 }
 
 static inline std::string toString(const EnrichedMarkdownTextMarkdownStyleLinkStruct &value) {
@@ -5032,6 +5123,11 @@ struct EnrichedMarkdownTextMarkdownStyleLinkVariantsStruct {
   SharedColor color{};
   bool underline{false};
   SharedColor backgroundColor{};
+  Float borderRadius{0.0};
+  Float paddingHorizontal{0.0};
+  Float paddingVertical{0.0};
+  SharedColor borderColor{};
+  Float borderWidth{0.0};
 
 
 #ifdef RN_SERIALIZABLE_STATE
@@ -5043,6 +5139,11 @@ struct EnrichedMarkdownTextMarkdownStyleLinkVariantsStruct {
     result["color"] = ::facebook::react::toDynamic(color);
     result["underline"] = underline;
     result["backgroundColor"] = ::facebook::react::toDynamic(backgroundColor);
+    result["borderRadius"] = borderRadius;
+    result["paddingHorizontal"] = paddingHorizontal;
+    result["paddingVertical"] = paddingVertical;
+    result["borderColor"] = ::facebook::react::toDynamic(borderColor);
+    result["borderWidth"] = borderWidth;
     return result;
   }
 #endif
@@ -5067,6 +5168,26 @@ static inline void fromRawValue(const PropsParserContext& context, const RawValu
   if (tmp_backgroundColor != map.end()) {
     fromRawValue(context, tmp_backgroundColor->second, result.backgroundColor);
   }
+  auto tmp_borderRadius = map.find("borderRadius");
+  if (tmp_borderRadius != map.end()) {
+    fromRawValue(context, tmp_borderRadius->second, result.borderRadius);
+  }
+  auto tmp_paddingHorizontal = map.find("paddingHorizontal");
+  if (tmp_paddingHorizontal != map.end()) {
+    fromRawValue(context, tmp_paddingHorizontal->second, result.paddingHorizontal);
+  }
+  auto tmp_paddingVertical = map.find("paddingVertical");
+  if (tmp_paddingVertical != map.end()) {
+    fromRawValue(context, tmp_paddingVertical->second, result.paddingVertical);
+  }
+  auto tmp_borderColor = map.find("borderColor");
+  if (tmp_borderColor != map.end()) {
+    fromRawValue(context, tmp_borderColor->second, result.borderColor);
+  }
+  auto tmp_borderWidth = map.find("borderWidth");
+  if (tmp_borderWidth != map.end()) {
+    fromRawValue(context, tmp_borderWidth->second, result.borderWidth);
+  }
 }
 
 static inline std::string toString(const EnrichedMarkdownTextMarkdownStyleLinkVariantsStruct &value) {
@@ -6809,6 +6930,7 @@ class EnrichedMarkdownTextProps final : public ViewProps {
 
   std::string markdown{};
   EnrichedMarkdownTextMarkdownStyleStruct markdownStyle{};
+  bool emitLinkLayout{false};
   bool enableTaskListItemToggle{true};
   bool enableLinkPreview{true};
   bool selectable{false};

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

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;

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
@@ -405,6 +410,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];
@@ -1334,6 +1344,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;

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

package/ios/utils/ENRMChipDrawing.m

@@ -0,0 +1,83 @@
+#import "ENRMChipDrawing.h"
+
+static UIBezierPath *chipFillPath(CGRect rect, CGFloat r, BOOL isFirst, 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(r, r)];
+#else
+  // NSBezierPath doesn't support per-corner rounding — use uniform corner radius
+  return UIBezierPathWithRoundedRect(rect, (isFirst || isLast) ? r : 0);
+#endif
+}
+
+static UIBezierPath *chipOpenBorderPath(CGRect rect, CGFloat r, CGFloat borderWidth, BOOL isFirst, BOOL isLast)
+{
+  UIBezierPath *path = [UIBezierPath bezierPath];
+  CGFloat inset = borderWidth / 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;
+}
+
+void ENRMDrawChipFragment(CGRect rect, RCTUIColor *backgroundColor, RCTUIColor *borderColor, CGFloat borderWidth,
+                          CGFloat cornerRadius, BOOL isFirst, BOOL isLast, BOOL strokeInset)
+{
+  if (CGRectIsEmpty(rect))
+    return;
+
+  CGFloat r = MIN(MAX(cornerRadius, 0), MIN(rect.size.width, rect.size.height) / 2.0);
+
+  if (backgroundColor) {
+    [backgroundColor setFill];
+    [chipFillPath(rect, r, isFirst, isLast) fill];
+  }
+
+  if (!borderColor || borderWidth <= 0)
+    return;
+
+  [borderColor setStroke];
+  UIBezierPath *strokePath;
+  if (isFirst && isLast) {
+    if (strokeInset) {
+      CGFloat inset = borderWidth / 2.0;
+      strokePath = chipFillPath(CGRectInset(rect, inset, inset), MAX(r - inset, 0), YES, YES);
+    } else {
+      strokePath = chipFillPath(rect, r, YES, YES);
+    }
+  } else {
+    strokePath = chipOpenBorderPath(rect, r, borderWidth, isFirst, isLast);
+  }
+  strokePath.lineWidth = borderWidth;
+  BezierPathSetRoundStyle(strokePath);
+  [strokePath stroke];
+}