react-native-enriched-markdown-scaffold 0.6.0-scaffold.4

package/ios/attachments/ENRMImageAttachment.h

@@ -0,0 +1,27 @@
+#pragma once
+#import "ENRMUIKit.h"
+
+@class StyleConfig;
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ * Custom NSTextAttachment for rendering markdown images.
+ * Images are loaded asynchronously and scaled dynamically based on text container width.
+ * Supports inline and block images with custom height and border radius from config.
+ */
+@interface ENRMImageAttachment : NSTextAttachment
+
+@property (nonatomic, readonly) NSString *imageURL;
+@property (nonatomic, readonly) BOOL isInline;
+
++ (instancetype)attachmentForURL:(NSString *)imageURL config:(StyleConfig *)config isInline:(BOOL)isInline;
+
++ (void)clearAttachmentRegistry;
+
++ (NSCache<NSString *, RCTUIImage *> *)originalImageCache;
++ (NSCache<NSString *, RCTUIImage *> *)processedImageCache;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/attachments/ENRMImageAttachment.m

@@ -0,0 +1,305 @@
+#import "ENRMImageAttachment.h"
+#import "ENRMImageDownloader.h"
+#import "ENRMUIKit.h"
+#import "RuntimeKeys.h"
+#import "StyleConfig.h"
+#import <objc/runtime.h>
+
+#define CACHE_KEY_PROCESSED(url, w, h, r) [NSString stringWithFormat:@"%@_w%.1f_h%.1f_r%.1f", url, w, h, r]
+
+static inline NSUInteger ENRMImageByteCost(RCTUIImage *image)
+{
+  CGImageRef cgImage = image.CGImage;
+  if (!cgImage)
+    return 0;
+  return CGImageGetBytesPerRow(cgImage) * CGImageGetHeight(cgImage);
+}
+
+static NSCache<NSString *, RCTUIImage *> *_originalImageCache;
+static NSCache<NSString *, RCTUIImage *> *_processedImageCache;
+static NSMapTable<NSString *, ENRMImageAttachment *> *_attachmentRegistry;
+
+@interface ENRMImageAttachment ()
+
+@property (nonatomic, copy) NSString *imageURL;
+@property (nonatomic, assign) BOOL isInline;
+@property (nonatomic, assign) CGFloat cachedHeight;
+@property (nonatomic, assign) CGFloat cachedBorderRadius;
+@property (nonatomic, weak) NSTextContainer *textContainer;
+@property (nonatomic, weak) ENRMPlatformTextView *textView;
+@property (nonatomic, strong) RCTUIImage *originalImage;
+@property (nonatomic, strong) RCTUIImage *loadedImage;
+@property (nonatomic, copy) NSString *lastProcessedKey;
+
+@end
+
+@implementation ENRMImageAttachment
+
++ (NSCache<NSString *, RCTUIImage *> *)originalImageCache
+{
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    _originalImageCache = [[NSCache alloc] init];
+    _originalImageCache.countLimit = 50;
+    _originalImageCache.totalCostLimit = 1024 * 1024 * 20; // 20 MB
+  });
+  return _originalImageCache;
+}
+
++ (NSCache<NSString *, RCTUIImage *> *)processedImageCache
+{
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    _processedImageCache = [[NSCache alloc] init];
+    _processedImageCache.countLimit = 100;
+    _processedImageCache.totalCostLimit = 1024 * 1024 * 30; // 30 MB
+  });
+  return _processedImageCache;
+}
+
++ (NSMapTable<NSString *, ENRMImageAttachment *> *)attachmentRegistry
+{
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{ _attachmentRegistry = [NSMapTable strongToWeakObjectsMapTable]; });
+  return _attachmentRegistry;
+}
+
++ (instancetype)attachmentForURL:(NSString *)imageURL config:(StyleConfig *)config isInline:(BOOL)isInline
+{
+  NSString *key = [NSString stringWithFormat:@"%@_%d", imageURL, isInline];
+  ENRMImageAttachment *existing = [[self attachmentRegistry] objectForKey:key];
+  if (existing && existing.loadedImage) {
+    return existing;
+  }
+  ENRMImageAttachment *attachment = [[self alloc] initWithImageURL:imageURL config:config isInline:isInline];
+  [[self attachmentRegistry] setObject:attachment forKey:key];
+  return attachment;
+}
+
++ (void)clearAttachmentRegistry
+{
+  [[self attachmentRegistry] removeAllObjects];
+}
+
+- (instancetype)initWithImageURL:(NSString *)imageURL config:(StyleConfig *)config isInline:(BOOL)isInline
+{
+  self = [super init];
+  if (self) {
+    _imageURL = imageURL;
+    _isInline = isInline;
+
+    _cachedHeight = isInline ? [config inlineImageSize] : [config imageHeight];
+    _cachedBorderRadius = [config imageBorderRadius];
+
+    [self setupPlaceholder];
+    [self startDownloadingImage];
+  }
+  return self;
+}
+
+- (CGRect)attachmentBoundsForTextContainer:(NSTextContainer *)textContainer
+                      proposedLineFragment:(CGRect)lineFragment
+                             glyphPosition:(CGPoint)position
+                            characterIndex:(NSUInteger)characterIndex
+{
+  CGFloat height = self.cachedHeight;
+  CGFloat width = self.isInline ? height : (lineFragment.size.width > 0 ? lineFragment.size.width : height);
+
+  if (self.isInline) {
+    UIFont *appliedFont = nil;
+    NSLayoutManager *layoutManager = textContainer.layoutManager;
+    NSTextStorage *textStorage = layoutManager.textStorage;
+
+    if (textStorage && characterIndex < textStorage.length) {
+      appliedFont = [textStorage attribute:NSFontAttributeName atIndex:characterIndex effectiveRange:NULL];
+    }
+
+    CGFloat verticalOffset;
+    if (appliedFont) {
+      verticalOffset = (appliedFont.capHeight - height) / 2.0;
+    } else {
+      verticalOffset = (lineFragment.size.height - height) / 2.0;
+    }
+
+    return CGRectMake(0, verticalOffset, width, height);
+  }
+
+  return CGRectMake(0, 0, width, height);
+}
+
+- (RCTUIImage *)imageForBounds:(CGRect)imageBounds
+                 textContainer:(NSTextContainer *)textContainer
+                characterIndex:(NSUInteger)characterIndex
+{
+  self.textContainer = textContainer;
+
+  if (self.originalImage && imageBounds.size.width > 0) {
+    self.bounds = imageBounds;
+    [self processAndApplyImage:self.originalImage withTargetWidth:imageBounds.size.width];
+  }
+
+  return self.loadedImage ?: self.image;
+}
+
+- (void)handleLoadedImage:(RCTUIImage *)image
+{
+  if (!image)
+    return;
+
+  self.originalImage = image;
+  CGFloat targetWidth = self.isInline ? self.cachedHeight : self.bounds.size.width;
+
+  // Defer processing if we don't have valid bounds yet (common for non-inline block images)
+  if (!self.isInline && targetWidth <= 0) {
+    return;
+  }
+
+  [self processAndApplyImage:image withTargetWidth:targetWidth];
+}
+
+- (void)processAndApplyImage:(RCTUIImage *)image withTargetWidth:(CGFloat)targetWidth
+{
+  if (targetWidth <= 0)
+    return;
+
+  NSString *processedKey = CACHE_KEY_PROCESSED(self.imageURL, targetWidth, self.cachedHeight, self.cachedBorderRadius);
+
+  if ([processedKey isEqualToString:self.lastProcessedKey])
+    return;
+  self.lastProcessedKey = processedKey;
+
+  RCTUIImage *cachedProcessed = [[ENRMImageAttachment processedImageCache] objectForKey:processedKey];
+
+  if (cachedProcessed) {
+    self.loadedImage = cachedProcessed;
+    if (self.isInline)
+      self.image = cachedProcessed;
+    [self refreshDisplay];
+    return;
+  }
+
+  __weak typeof(self) weakSelf = self;
+  dispatch_async(dispatch_get_global_queue(QOS_CLASS_USER_INITIATED, 0), ^{
+    __strong typeof(weakSelf) strongSelf = weakSelf;
+    if (!strongSelf)
+      return;
+
+    RCTUIImage *processedImage = [strongSelf createScaledImage:image
+                                                       toWidth:targetWidth
+                                                        height:strongSelf.cachedHeight
+                                                  borderRadius:strongSelf.cachedBorderRadius];
+
+    if (processedImage) {
+      [[ENRMImageAttachment processedImageCache] setObject:processedImage
+                                                    forKey:processedKey
+                                                      cost:ENRMImageByteCost(processedImage)];
+    }
+
+    dispatch_async(dispatch_get_main_queue(), ^{
+      strongSelf.loadedImage = processedImage;
+      if (strongSelf.isInline) {
+        strongSelf.image = processedImage;
+        strongSelf.bounds = CGRectMake(0, 0, strongSelf.cachedHeight, strongSelf.cachedHeight);
+      } else {
+        strongSelf.image = image; // Keep original for layout references
+      }
+      [strongSelf refreshDisplay];
+    });
+  });
+}
+
+- (RCTUIImage *)createScaledImage:(RCTUIImage *)image
+                          toWidth:(CGFloat)targetWidth
+                           height:(CGFloat)targetHeight
+                     borderRadius:(CGFloat)radius
+{
+  CGFloat sourceWidth = image.size.width;
+  CGFloat sourceHeight = image.size.height;
+  if (sourceWidth <= 0 || sourceHeight <= 0)
+    return nil;
+
+  CGFloat drawingWidth, drawingHeight;
+
+  if (!self.isInline) {
+    CGFloat aspectRatioScale = targetWidth / sourceWidth;
+    drawingWidth = targetWidth;
+    drawingHeight = sourceHeight * aspectRatioScale;
+  } else {
+    drawingWidth = targetWidth;
+    drawingHeight = targetHeight;
+  }
+
+  CGRect drawingRect =
+      CGRectMake((targetWidth - drawingWidth) / 2.0, (targetHeight - drawingHeight) / 2.0, drawingWidth, drawingHeight);
+
+  RCTUIGraphicsImageRenderer *renderer = ImageRendererForSize(CGSizeMake(targetWidth, targetHeight));
+
+  return [renderer imageWithActions:^(RCTUIGraphicsImageRendererContext *context) {
+    if (radius > 0) {
+      CGRect clippingRect = CGRectIntersection(CGRectMake(0, 0, targetWidth, targetHeight), drawingRect);
+      UIBezierPath *path = UIBezierPathWithRoundedRect(clippingRect, radius);
+      [path addClip];
+    }
+    [image drawInRect:drawingRect];
+  }];
+}
+
+- (void)startDownloadingImage
+{
+  if (self.imageURL.length == 0)
+    return;
+
+  __weak typeof(self) weakSelf = self;
+  [[ENRMImageDownloader shared] downloadURL:self.imageURL
+                                 completion:^(RCTUIImage *image) { [weakSelf handleLoadedImage:image]; }];
+}
+
+- (void)refreshDisplay
+{
+  UITextView *textView = [self fetchAssociatedTextView];
+  if (!textView)
+    return;
+
+  NSRange range = [self findAttachmentRangeInText:textView.textStorage];
+  if (range.location != NSNotFound) {
+    [textView.layoutManager invalidateDisplayForCharacterRange:range];
+    if (!self.isInline) {
+      [textView.layoutManager invalidateLayoutForCharacterRange:range actualCharacterRange:NULL];
+    }
+  }
+}
+
+- (ENRMPlatformTextView *)fetchAssociatedTextView
+{
+  if (self.textView)
+    return self.textView;
+  if (!self.textContainer)
+    return nil;
+  self.textView = objc_getAssociatedObject(self.textContainer, kTextViewKey);
+  return self.textView;
+}
+
+- (void)setupPlaceholder
+{
+  CGFloat size = self.cachedHeight;
+  self.bounds = CGRectMake(0, 0, size, size);
+  RCTUIGraphicsImageRenderer *renderer = [[RCTUIGraphicsImageRenderer alloc] initWithSize:CGSizeMake(1, 1)];
+  self.image = [renderer imageWithActions:^(RCTUIGraphicsImageRendererContext *ctx){}];
+}
+
+- (NSRange)findAttachmentRangeInText:(NSAttributedString *)attributedString
+{
+  __block NSRange foundRange = NSMakeRange(NSNotFound, 0);
+  [attributedString enumerateAttribute:NSAttachmentAttributeName
+                               inRange:NSMakeRange(0, attributedString.length)
+                               options:0
+                            usingBlock:^(id value, NSRange range, BOOL *stop) {
+                              if (value == self) {
+                                foundRange = range;
+                                *stop = YES;
+                              }
+                            }];
+  return foundRange;
+}
+
+@end

package/ios/attachments/ENRMMathInlineAttachment+macOS.m

@@ -0,0 +1,60 @@
+#import "ENRMMathInlineAttachmentShared.h"
+
+#if ENRICHED_MARKDOWN_MATH && TARGET_OS_OSX
+
+#if __has_include("ReactNativeEnrichedMarkdown-Swift.h")
+#import "ReactNativeEnrichedMarkdown-Swift.h"
+#elif __has_include(<ReactNativeEnrichedMarkdown/ReactNativeEnrichedMarkdown-Swift.h>)
+#import <ReactNativeEnrichedMarkdown/ReactNativeEnrichedMarkdown-Swift.h>
+#endif
+
+@implementation ENRMMathInlineAttachment (macOS)
+
+- (instancetype)init
+{
+  self = [super init];
+  if (self) {
+    // NSTextAttachment creates a default NSTextAttachmentCell on macOS.
+    // Clear it so NSLayoutManager falls back to the image/bounds properties
+    // we set in renderForMacOS.
+    self.attachmentCell = nil;
+  }
+  return self;
+}
+
+- (void)renderForMacOS
+{
+  RCTUIColor *color = self.mathTextColor ?: [RCTUIColor blackColor];
+  ENRMRaTeXRenderResult *result = [ENRMRaTeXBridge parse:self.latex displayMode:NO fontSize:self.fontSize color:color];
+  if (!result)
+    return;
+
+  _renderResult = result;
+  _mathAscent = result.ascent;
+  _mathDescent = result.descent;
+  _cachedSize = CGSizeMake(ceil(result.width), ceil(result.totalHeight));
+
+  // Render the formula into an NSImage. NSLayoutManager draws self.image
+  // automatically when attachmentCell is nil, so this is the reliable
+  // macOS rendering path instead of imageForBounds:textContainer:characterIndex:.
+  //
+  // NSImage.lockFocus creates a bottom-left origin Quartz context, but RaTeX
+  // expects a UIKit-style top-left origin (Y increases downward). Flip the CTM
+  // so the formula renders right-side up.
+  NSImage *image = [[NSImage alloc] initWithSize:_cachedSize];
+  [image lockFocus];
+  CGContextRef ctx = [[NSGraphicsContext currentContext] CGContext];
+  CGContextSaveGState(ctx);
+  CGContextTranslateCTM(ctx, 0, _cachedSize.height);
+  CGContextScaleCTM(ctx, 1.0, -1.0);
+  [_renderResult drawIn:ctx];
+  CGContextRestoreGState(ctx);
+  [image unlockFocus];
+
+  self.image = image;
+  self.bounds = CGRectMake(0, -_mathDescent, _cachedSize.width, _cachedSize.height);
+}
+
+@end
+
+#endif

package/ios/attachments/ENRMMathInlineAttachment.h

@@ -0,0 +1,47 @@
+#pragma once
+#import "ENRMUIKit.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface ENRMMathInlineAttachment : NSTextAttachment
+
+@property (nonatomic, strong) NSString *latex;
+@property (nonatomic, assign) CGFloat fontSize;
+@property (nonatomic, strong, nullable) RCTUIColor *mathTextColor;
+
+/// YES if block math (`$$...$$`), NO for inline (`$...$`).
+@property (nonatomic, assign) BOOL displayMode;
+
+/// Container style
+@property (nonatomic, strong, nullable) RCTUIColor *containerBackgroundColor;
+@property (nonatomic, strong, nullable) RCTUIColor *containerBorderColor;
+@property (nonatomic, assign) CGFloat containerBorderWidth;
+@property (nonatomic, assign) CGFloat containerBorderRadius;
+@property (nonatomic, assign) CGFloat containerPaddingHorizontal;
+@property (nonatomic, assign) CGFloat containerPaddingVertical;
+
+/// Block-only: margin top/bottom + paragraph alignment
+@property (nonatomic, assign) CGFloat blockMarginTop;
+@property (nonatomic, assign) CGFloat blockMarginBottom;
+@property (nonatomic, assign) NSTextAlignment blockAlignment;
+
+/// Selected state
+@property (nonatomic, strong, nullable) RCTUIColor *selectedBackgroundColor;
+@property (nonatomic, strong, nullable) RCTUIColor *selectedBorderColor;
+@property (nonatomic, assign) BOOL isSelected;
+
+/// Clears the cached glyph render so the next layout regenerates it
+/// (e.g. after style or latex changes).
+- (void)invalidateRender;
+
+#if TARGET_OS_OSX
+/// Pre-renders the formula into self.image and sets self.bounds.
+/// Must be called after latex/fontSize/mathTextColor are set, before the
+/// attachment is inserted into an NSAttributedString. On macOS, NSLayoutManager
+/// uses the image/bounds properties directly rather than calling imageForBounds:.
+- (void)renderForMacOS;
+#endif
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/attachments/ENRMMathInlineAttachment.m

@@ -0,0 +1,142 @@
+#import "ENRMMathInlineAttachmentShared.h"
+
+#if ENRICHED_MARKDOWN_MATH
+
+#if __has_include("ReactNativeEnrichedMarkdown-Swift.h")
+#import "ReactNativeEnrichedMarkdown-Swift.h"
+#elif __has_include(<ReactNativeEnrichedMarkdown/ReactNativeEnrichedMarkdown-Swift.h>)
+#import <ReactNativeEnrichedMarkdown/ReactNativeEnrichedMarkdown-Swift.h>
+#endif
+
+@implementation ENRMMathInlineAttachment
+
+#if !TARGET_OS_OSX
+
+- (void)prepareIfNeeded
+{
+  if (_renderResult)
+    return;
+
+  RCTUIColor *color = self.mathTextColor ?: [RCTUIColor blackColor];
+  ENRMRaTeXRenderResult *result = [ENRMRaTeXBridge parse:self.latex
+                                             displayMode:self.displayMode
+                                                fontSize:self.fontSize
+                                                   color:color];
+  if (!result)
+    return;
+
+  _renderResult = result;
+  _mathAscent = result.ascent;
+  _mathDescent = result.descent;
+  _cachedSize = CGSizeMake(ceil(result.width), ceil(result.totalHeight));
+}
+
+- (void)invalidateRender
+{
+  _renderResult = nil;
+  _cachedSize = CGSizeZero;
+  _mathAscent = 0;
+  _mathDescent = 0;
+}
+
+- (CGRect)attachmentBoundsForTextContainer:(NSTextContainer *)textContainer
+                      proposedLineFragment:(CGRect)lineFragment
+                             glyphPosition:(CGPoint)position
+                            characterIndex:(NSUInteger)characterIndex
+{
+  [self prepareIfNeeded];
+
+  CGFloat intrinsicW = _cachedSize.width + _containerPaddingHorizontal * 2;
+  CGFloat totalH = _cachedSize.height + _containerPaddingVertical * 2;
+
+  if (_displayMode) {
+    totalH += _blockMarginTop + _blockMarginBottom;
+    // Block chip claims the full line fragment so text can't share the row.
+    // Fall back to intrinsic width when the proposed fragment is degenerate
+    // (e.g. during initial layout before the text container has a size).
+    CGFloat fullW = MAX(lineFragment.size.width, intrinsicW);
+    return CGRectMake(0, -(_mathDescent + _containerPaddingVertical + _blockMarginBottom), fullW, totalH);
+  }
+  return CGRectMake(0, -(_mathDescent + _containerPaddingVertical), intrinsicW, totalH);
+}
+
+- (UIImage *)imageForBounds:(CGRect)imageBounds
+              textContainer:(NSTextContainer *)textContainer
+             characterIndex:(NSUInteger)characterIndex
+{
+  [self prepareIfNeeded];
+  if (!_renderResult)
+    return nil;
+
+  // Block chips claim the full line fragment (set in attachmentBounds…), so
+  // the canvas is `imageBounds.width` wide and the formula floats inside it
+  // according to `blockAlignment`. Inline chips fall back to intrinsic width.
+  CGFloat intrinsicW = _cachedSize.width + _containerPaddingHorizontal * 2;
+  CGFloat totalW = (_displayMode && imageBounds.size.width > intrinsicW) ? imageBounds.size.width : intrinsicW;
+  CGFloat totalH = _cachedSize.height + _containerPaddingVertical * 2;
+  CGSize totalSize = CGSizeMake(totalW, totalH);
+
+  RCTUIColor *bg = _isSelected ? (_selectedBackgroundColor ?: _containerBackgroundColor) : _containerBackgroundColor;
+  RCTUIColor *border = _isSelected ? (_selectedBorderColor ?: _containerBorderColor) : _containerBorderColor;
+  CGFloat borderWidth = _containerBorderWidth;
+  CGFloat borderRadius = _containerBorderRadius;
+  CGFloat padH = _containerPaddingHorizontal;
+  CGFloat padV = _containerPaddingVertical;
+  ENRMRaTeXRenderResult *render = _renderResult;
+  CGFloat formulaW = _cachedSize.width;
+  NSTextAlignment alignment = _blockAlignment;
+  BOOL displayMode = _displayMode;
+
+  UIGraphicsImageRendererFormat *format = [UIGraphicsImageRendererFormat preferredFormat];
+  format.opaque = NO;
+
+  UIGraphicsImageRenderer *renderer = [[UIGraphicsImageRenderer alloc] initWithSize:totalSize format:format];
+
+  return [renderer imageWithActions:^(UIGraphicsImageRendererContext *rendererContext) {
+    CGContextRef ctx = rendererContext.CGContext;
+
+    if (bg) {
+      CGFloat inset = borderWidth / 2.0;
+      CGRect rect = CGRectMake(inset, inset, totalW - borderWidth, totalH - borderWidth);
+      UIBezierPath *path = [UIBezierPath bezierPathWithRoundedRect:rect cornerRadius:borderRadius];
+      [bg setFill];
+      [path fill];
+    }
+
+    if (border && borderWidth > 0) {
+      CGFloat inset = borderWidth / 2.0;
+      CGRect rect = CGRectMake(inset, inset, totalW - borderWidth, totalH - borderWidth);
+      UIBezierPath *path = [UIBezierPath bezierPathWithRoundedRect:rect cornerRadius:borderRadius];
+      [border setStroke];
+      path.lineWidth = borderWidth;
+      [path stroke];
+    }
+
+    CGFloat glyphOffset = padH;
+    if (displayMode && totalW > intrinsicW) {
+      CGFloat slack = totalW - formulaW - padH * 2;
+      switch (alignment) {
+        case NSTextAlignmentCenter:
+          glyphOffset = padH + slack / 2.0;
+          break;
+        case NSTextAlignmentRight:
+          glyphOffset = padH + slack;
+          break;
+        default:
+          glyphOffset = padH;
+          break;
+      }
+    }
+
+    CGContextSaveGState(ctx);
+    CGContextTranslateCTM(ctx, glyphOffset, padV);
+    [render drawIn:ctx];
+    CGContextRestoreGState(ctx);
+  }];
+}
+
+#endif
+
+@end
+
+#endif

package/ios/attachments/ENRMMathInlineAttachmentShared.h

@@ -0,0 +1,17 @@
+#pragma once
+#import "ENRMFeatureFlags.h"
+#import "ENRMMathInlineAttachment.h"
+
+#if ENRICHED_MARKDOWN_MATH
+
+@class ENRMRaTeXRenderResult;
+
+@interface ENRMMathInlineAttachment () {
+  CGSize _cachedSize;
+  CGFloat _mathAscent;
+  CGFloat _mathDescent;
+  ENRMRaTeXRenderResult *_renderResult;
+}
+@end
+
+#endif

package/ios/attachments/ThematicBreakAttachment.h

@@ -0,0 +1,15 @@
+#pragma once
+#import "ENRMUIKit.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface ThematicBreakAttachment : NSTextAttachment
+
+@property (nonatomic, strong) RCTUIColor *lineColor;
+@property (nonatomic, assign) CGFloat lineHeight;
+@property (nonatomic, assign) CGFloat marginTop;
+@property (nonatomic, assign) CGFloat marginBottom;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/attachments/ThematicBreakAttachment.m

@@ -0,0 +1,33 @@
+#import "ThematicBreakAttachment.h"
+
+@implementation ThematicBreakAttachment
+
+- (CGRect)attachmentBoundsForTextContainer:(NSTextContainer *)textContainer
+                      proposedLineFragment:(CGRect)lineFrag
+                             glyphPosition:(CGPoint)position
+                            characterIndex:(NSUInteger)charIndex
+{
+  CGFloat totalHeight = self.marginTop + self.lineHeight + self.marginBottom;
+  return CGRectMake(0, 0, CGRectGetWidth(lineFrag), totalHeight);
+}
+
+- (RCTUIImage *)imageForBounds:(CGRect)imageBounds
+                 textContainer:(NSTextContainer *)textContainer
+                characterIndex:(NSUInteger)charIndex
+{
+  RCTUIGraphicsImageRenderer *renderer = [[RCTUIGraphicsImageRenderer alloc] initWithSize:imageBounds.size];
+
+  return [renderer imageWithActions:^(RCTUIGraphicsImageRendererContext *_Nonnull rendererContext) {
+    CGContextRef ctx = rendererContext.CGContext;
+
+    CGFloat lineY = self.marginTop + (self.lineHeight / 2.0);
+
+    [self.lineColor setStroke];
+    CGContextSetLineWidth(ctx, self.lineHeight);
+    CGContextMoveToPoint(ctx, 0, lineY);
+    CGContextAddLineToPoint(ctx, imageBounds.size.width, lineY);
+    CGContextStrokePath(ctx);
+  }];
+}
+
+@end

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

@@ -0,0 +1,22 @@
+
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * @generated by codegen project: GenerateComponentDescriptorCpp.js
+ */
+
+#include "ComponentDescriptors.h"
+#include <react/renderer/core/ConcreteComponentDescriptor.h>
+#include <react/renderer/componentregistry/ComponentDescriptorProviderRegistry.h>
+
+namespace facebook::react {
+
+void EnrichedMarkdownTextSpec_registerComponentDescriptorsFromCodegen(
+  std::shared_ptr<const ComponentDescriptorProviderRegistry> registry) {
+
+}
+
+} // namespace facebook::react