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

package/ios/renderer/HeadingRenderer.m

@@ -0,0 +1,94 @@
+#import "HeadingRenderer.h"
+#import "FontUtils.h"
+#import "ParagraphStyleUtils.h"
+#import "RenderContext.h"
+#import "RendererFactory.h"
+#import "RuntimeKeys.h"
+#import "StyleConfig.h"
+
+// Lightweight struct to hold style data without object overhead
+typedef struct {
+  __unsafe_unretained UIFont *font;
+  __unsafe_unretained RCTUIColor *color;
+  CGFloat marginTop;
+  CGFloat marginBottom;
+  CGFloat lineHeight;
+  NSTextAlignment textAlign;
+} HeadingStyle;
+
+static NSString *const kHeadingTypes[] = {nil,          @"heading-1", @"heading-2", @"heading-3",
+                                          @"heading-4", @"heading-5", @"heading-6"};
+
+@implementation HeadingRenderer
+
+- (void)renderNode:(MarkdownASTNode *)node into:(NSMutableAttributedString *)output context:(RenderContext *)context
+{
+  NSInteger level = [node.attributes[@"level"] integerValue];
+  if (level < 1 || level > 6)
+    level = 1;
+
+  HeadingStyle style = [self styleForLevel:level];
+  [context setBlockStyle:BlockTypeHeading font:style.font color:style.color headingLevel:level];
+
+  NSUInteger start = output.length;
+  NSUInteger contentStart = start;
+
+  // Spacing at the very start of the document requires a spacer character (index 0 check)
+  if (start == 0) {
+    NSUInteger offset = applyBlockSpacingBefore(output, 0, style.marginTop);
+    contentStart += offset;
+    start += offset;
+  }
+
+  @try {
+    [_rendererFactory renderChildrenOfNode:node into:output context:context];
+  } @finally {
+    [context clearBlockStyle];
+  }
+
+  NSRange range = NSMakeRange(start, output.length - start);
+  if (range.length == 0)
+    return;
+
+  // Register heading for accessibility
+  NSString *headingText = [[output attributedSubstringFromRange:range] string];
+  [context registerHeadingRange:range level:level text:headingText];
+
+  // Metadata attribute used for post-processing (e.g., Export to Markdown/HTML)
+  [output addAttribute:MarkdownTypeAttributeName value:kHeadingTypes[level] range:range];
+
+  applyLineHeight(output, range, style.lineHeight);
+  applyTextAlignment(output, range, style.textAlign);
+
+  // Skip marginTop for the first block — already handled by applyBlockSpacingBefore above
+  if (contentStart != 1) {
+    NSUInteger inserted = applyParagraphSpacingBefore(output, range, style.marginTop);
+    start += inserted;
+  }
+  applyParagraphSpacingAfter(output, start, style.marginBottom);
+}
+
+#pragma mark - Style Mapping
+
+- (HeadingStyle)styleForLevel:(NSInteger)level
+{
+  StyleConfig *c = _config;
+  switch (level) {
+    case 1:
+      return (HeadingStyle){c.h1Font, c.h1Color, c.h1MarginTop, c.h1MarginBottom, c.h1LineHeight, c.h1TextAlign};
+    case 2:
+      return (HeadingStyle){c.h2Font, c.h2Color, c.h2MarginTop, c.h2MarginBottom, c.h2LineHeight, c.h2TextAlign};
+    case 3:
+      return (HeadingStyle){c.h3Font, c.h3Color, c.h3MarginTop, c.h3MarginBottom, c.h3LineHeight, c.h3TextAlign};
+    case 4:
+      return (HeadingStyle){c.h4Font, c.h4Color, c.h4MarginTop, c.h4MarginBottom, c.h4LineHeight, c.h4TextAlign};
+    case 5:
+      return (HeadingStyle){c.h5Font, c.h5Color, c.h5MarginTop, c.h5MarginBottom, c.h5LineHeight, c.h5TextAlign};
+    case 6:
+      return (HeadingStyle){c.h6Font, c.h6Color, c.h6MarginTop, c.h6MarginBottom, c.h6LineHeight, c.h6TextAlign};
+    default:
+      return [self styleForLevel:1];
+  }
+}
+
+@end

package/ios/renderer/HighlightRenderer.h

@@ -0,0 +1,7 @@
+#pragma once
+#import "BaseRenderer.h"
+
+extern NSString *const HighlightAttributeName;
+
+@interface HighlightRenderer : BaseRenderer <NodeRenderer>
+@end

package/ios/renderer/HighlightRenderer.m

@@ -0,0 +1,31 @@
+#import "HighlightRenderer.h"
+#import "MarkdownASTNode.h"
+#import "RenderContext.h"
+#import "RendererFactory.h"
+#import "StyleConfig.h"
+
+NSString *const HighlightAttributeName = @"EnrichedMarkdownHighlight";
+
+@implementation HighlightRenderer
+
+#pragma mark - Rendering
+
+- (void)renderNode:(MarkdownASTNode *)node into:(NSMutableAttributedString *)output context:(RenderContext *)context
+{
+  NSUInteger start = output.length;
+  [_rendererFactory renderChildrenOfNode:node into:output context:context];
+
+  NSRange range = NSMakeRange(start, output.length - start);
+  if (range.length == 0)
+    return;
+
+  BlockStyle *blockStyle = [context getBlockStyle];
+  RCTUIColor *foregroundColor = [RenderContext calculateHighlightColor:[_config highlightColor]
+                                                        paragraphColor:[_config paragraphColor]
+                                                            blockColor:blockStyle.color];
+  [output addAttribute:NSForegroundColorAttributeName value:foregroundColor range:range];
+  [output addAttribute:NSBackgroundColorAttributeName value:[_config highlightBackgroundColor] range:range];
+  [output addAttribute:HighlightAttributeName value:@YES range:range];
+}
+
+@end

package/ios/renderer/LinkRenderer.h

@@ -0,0 +1,6 @@
+#import "BaseRenderer.h"
+#import "MarkdownASTNode.h"
+#import "RenderContext.h"
+
+@interface LinkRenderer : BaseRenderer <NodeRenderer>
+@end

package/ios/renderer/LinkRenderer.m

@@ -0,0 +1,82 @@
+#import "LinkRenderer.h"
+#import "FontUtils.h"
+#import "RenderContext.h"
+#import "RendererFactory.h"
+#import "StyleConfig.h"
+#import <React/RCTFont.h>
+
+@implementation LinkRenderer
+
+#pragma mark - Rendering
+
+- (void)renderNode:(MarkdownASTNode *)node 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
+  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];
+
+  NSNumber *underlineStyle = @(linkUnderline ? NSUnderlineStyleSingle : NSUnderlineStyleNone);
+
+  // 3. Apply core link functionality (non-destructive)
+  [output addAttribute:NSLinkAttributeName value:url range:range];
+
+  // 4. Optimize visual attributes via enumeration to avoid redundant updates
+  [output enumerateAttributesInRange:range
+                             options:NSAttributedStringEnumerationLongestEffectiveRangeNotRequired
+                          usingBlock:^(NSDictionary<NSAttributedStringKey, id> *attrs, NSRange subrange, BOOL *stop) {
+                            NSMutableDictionary *newAttributes = [NSMutableDictionary dictionary];
+
+                            // Only apply link color if the subrange isn't already colored by the link style
+                            if (linkColor && ![attrs[NSForegroundColorAttributeName] isEqual:linkColor]) {
+                              newAttributes[NSForegroundColorAttributeName] = linkColor;
+                              newAttributes[NSUnderlineColorAttributeName] = linkColor;
+                            }
+
+                            // Only update underline style if it differs from the config
+                            if (![attrs[NSUnderlineStyleAttributeName] isEqual:underlineStyle]) {
+                              newAttributes[NSUnderlineStyleAttributeName] = underlineStyle;
+                            }
+
+                            if (linkFontFamily.length > 0) {
+                              UIFont *currentFont = attrs[NSFontAttributeName];
+                              if (currentFont) {
+                                UIFont *linkFont = [RCTFont updateFont:currentFont
+                                                            withFamily:linkFontFamily
+                                                                  size:nil
+                                                                weight:nil
+                                                                 style:nil
+                                                               variant:nil
+                                                       scaleMultiplier:1.0];
+                                if (linkFont && ![currentFont isEqual:linkFont]) {
+                                  newAttributes[NSFontAttributeName] = linkFont;
+                                }
+                              }
+                            }
+
+                            if (newAttributes.count > 0) {
+                              [output addAttributes:newAttributes range:subrange];
+                            }
+                          }];
+
+  if (backgroundColor) {
+    [output addAttribute:NSBackgroundColorAttributeName value:backgroundColor range:range];
+  }
+
+  [context registerLinkRange:range url:url];
+}
+
+@end

package/ios/renderer/ListItemRenderer.h

@@ -0,0 +1,12 @@
+#import "BaseRenderer.h"
+
+extern NSString *const ListDepthAttribute;
+extern NSString *const ListTypeAttribute;
+extern NSString *const ListItemNumberAttribute;
+
+extern NSString *const TaskItemAttribute;
+extern NSString *const TaskCheckedAttribute;
+extern NSString *const TaskIndexAttribute;
+
+@interface ListItemRenderer : BaseRenderer <NodeRenderer>
+@end

package/ios/renderer/ListItemRenderer.m

@@ -0,0 +1,175 @@
+#import "ListItemRenderer.h"
+#import "ENRMUIKit.h"
+#import "LastElementUtils.h"
+#import "MarkdownASTNode.h"
+#import "ParagraphStyleUtils.h"
+#import "RenderContext.h"
+#import "RendererFactory.h"
+#import "StyleConfig.h"
+
+NSString *const ListDepthAttribute = @"ListDepth";
+NSString *const ListTypeAttribute = @"ListType";
+NSString *const ListItemNumberAttribute = @"ListItemNumber";
+NSString *const TaskItemAttribute = @"TaskItem";
+NSString *const TaskCheckedAttribute = @"TaskChecked";
+NSString *const TaskIndexAttribute = @"TaskIndex";
+
+@interface ListItemRenderer ()
+- (void)applyCheckedDecorationsTo:(NSMutableAttributedString *)output
+                            range:(NSRange)range
+                     nestingLevel:(NSInteger)nestingLevel;
+@end
+
+@implementation ListItemRenderer
+
+- (void)renderNode:(MarkdownASTNode *)node into:(NSMutableAttributedString *)output context:(RenderContext *)context
+{
+  if (!context)
+    return;
+
+  context.listItemNumber++;
+  const NSInteger currentPosition = context.listItemNumber;
+  const NSInteger currentDepth = context.listDepth; // 1-based (1 = top level)
+
+  const BOOL isTask = [node.attributes[@"isTask"] isEqualToString:@"true"];
+  const BOOL isChecked = isTask && [node.attributes[@"taskChecked"] isEqualToString:@"true"];
+  NSInteger taskIndex = -1;
+  if (isTask) {
+    taskIndex = context.taskItemCount;
+    context.taskItemCount++;
+  }
+
+  const NSUInteger startLocation = output.length;
+
+  // Render the actual content of the list item (text, bolding, etc.)
+  [_rendererFactory renderChildrenOfNode:node into:output context:context];
+
+  // Ensure every list item ends with a newline to prevent paragraph merging
+  if (output.length > startLocation && ![output.string hasSuffix:@"\n"]) {
+    [output appendAttributedString:kNewlineAttributedString];
+  }
+
+  const NSRange itemRange = NSMakeRange(startLocation, output.length - startLocation);
+  if (itemRange.length == 0)
+    return;
+
+  // Informs MarkdownAccessibilityElementBuilder about the specific boundaries of this list item
+  [context registerListItemRange:itemRange
+                        position:currentPosition
+                           depth:currentDepth
+                       isOrdered:(context.listType == ListTypeOrdered)];
+
+  // currentDepth - 1 handles the horizontal offset for nested lists
+  const NSInteger nestingLevel = currentDepth - 1;
+  const CGFloat baseMarkerWidth = isTask                                  ? [_config effectiveListMarginLeftForTask]
+                                  : (context.listType == ListTypeOrdered) ? [_config effectiveListMarginLeftForNumber]
+                                                                          : [_config effectiveListMarginLeftForBullet];
+
+  const CGFloat totalIndent =
+      baseMarkerWidth + [_config effectiveListGapWidth] + (nestingLevel * [_config listStyleMarginLeft]);
+
+  const CGFloat lineHeightConfig = [_config listStyleLineHeight];
+
+  // Boxing metadata for attributed string storage
+  NSMutableDictionary *metadata = [@{
+    ListDepthAttribute : @(nestingLevel),
+    ListTypeAttribute : @(context.listType),
+    ListItemNumberAttribute : @(currentPosition)
+  } mutableCopy];
+
+  if (isTask) {
+    metadata[TaskItemAttribute] = @YES;
+    metadata[TaskCheckedAttribute] = @(isChecked);
+    metadata[TaskIndexAttribute] = @(taskIndex);
+  }
+
+  // We enumerate to ensure we don't overwrite styles of nested sub-lists
+  // or code blocks that may have already been rendered inside this item.
+  [output enumerateAttribute:ListDepthAttribute
+                     inRange:itemRange
+                     options:0
+                  usingBlock:^(id depthAttr, NSRange range, BOOL *stop) {
+                    // If a segment already has a Depth attribute higher than our current level,
+                    // it belongs to a nested list and we should skip it to preserve its styling.
+                    if (depthAttr && [depthAttr integerValue] > nestingLevel) {
+                      return;
+                    }
+
+                    // Skip code block ranges — CodeBlockRenderer already applied its own
+                    // paragraph style (padding, LTR indent). Overwriting would add list
+                    // markers ("2.") inside the code block.
+                    NSNumber *isCodeBlock = [output attribute:CodeBlockAttributeName
+                                                      atIndex:range.location
+                                               effectiveRange:nil];
+                    if ([isCodeBlock boolValue]) {
+                      return;
+                    }
+
+                    NSMutableParagraphStyle *style = [[NSMutableParagraphStyle alloc] init];
+                    style.firstLineHeadIndent = totalIndent;
+                    style.headIndent = totalIndent;
+
+                    if (lineHeightConfig > 0) {
+                      style.minimumLineHeight = lineHeightConfig;
+                      style.maximumLineHeight = lineHeightConfig;
+                    }
+
+                    NSMutableDictionary *attributesToApply = [metadata mutableCopy];
+                    attributesToApply[NSParagraphStyleAttributeName] = style;
+
+                    [output addAttributes:attributesToApply range:range];
+                  }];
+
+  if (isTask && isChecked) {
+    [self applyCheckedDecorationsTo:output range:itemRange nestingLevel:nestingLevel];
+  }
+}
+
+- (void)applyCheckedDecorationsTo:(NSMutableAttributedString *)output
+                            range:(NSRange)range
+                     nestingLevel:(NSInteger)nestingLevel
+{
+  RCTUIColor *checkedColor = [_config taskListCheckedTextColor];
+  BOOL shouldStrikethrough = [_config taskListCheckedStrikethrough];
+
+  if (!checkedColor && !shouldStrikethrough) {
+    return;
+  }
+
+  NSMutableDictionary *checkedAttrs = [NSMutableDictionary dictionary];
+
+  if (checkedColor) {
+    checkedAttrs[NSForegroundColorAttributeName] = checkedColor;
+  }
+
+  if (shouldStrikethrough) {
+    checkedAttrs[NSStrikethroughStyleAttributeName] = @(NSUnderlineStyleSingle);
+
+    RCTUIColor *lineColor = checkedColor ?: [_config listStyleColor];
+    if (lineColor) {
+      checkedAttrs[NSStrikethroughColorAttributeName] = lineColor;
+    }
+  }
+
+  [output enumerateAttribute:ListDepthAttribute
+                     inRange:range
+                     options:0
+                  usingBlock:^(NSNumber *depth, NSRange segmentRange, BOOL *stop) {
+                    BOOL isNestedSubItem = (depth && [depth integerValue] > nestingLevel);
+                    if (isNestedSubItem) {
+                      return;
+                    }
+
+                    // Skip code block ranges — preserve CodeBlockRenderer styles.
+                    NSNumber *isCodeBlock = [output attribute:CodeBlockAttributeName
+                                                      atIndex:segmentRange.location
+                                               effectiveRange:nil];
+                    if ([isCodeBlock boolValue]) {
+                      return;
+                    }
+
+                    [output addAttributes:checkedAttrs range:segmentRange];
+                  }];
+}
+
+@end

package/ios/renderer/ListRenderer.h

@@ -0,0 +1,13 @@
+#import "NodeRenderer.h"
+
+@class RendererFactory;
+@class StyleConfig;
+@class RenderContext;
+
+@interface ListRenderer : NSObject <NodeRenderer>
+
+- (instancetype)initWithRendererFactory:(RendererFactory *)rendererFactory
+                                 config:(StyleConfig *)config
+                              isOrdered:(BOOL)isOrdered;
+
+@end

package/ios/renderer/ListRenderer.m

@@ -0,0 +1,70 @@
+#import "ListRenderer.h"
+#import "BlockquoteRenderer.h"
+#import "MarkdownASTNode.h"
+#import "ParagraphStyleUtils.h"
+#import "RenderContext.h"
+#import "RendererFactory.h"
+#import "StyleConfig.h"
+
+@implementation ListRenderer {
+  __weak RendererFactory *_rendererFactory;
+  StyleConfig *_config;
+  BOOL _isOrdered;
+}
+
+- (instancetype)initWithRendererFactory:(RendererFactory *)factory config:(StyleConfig *)config isOrdered:(BOOL)ordered
+{
+  if (self = [super init]) {
+    _rendererFactory = factory;
+    _config = config;
+    _isOrdered = ordered;
+  }
+  return self;
+}
+
+- (void)renderNode:(MarkdownASTNode *)node into:(NSMutableAttributedString *)output context:(RenderContext *)context
+{
+  if (!context)
+    return;
+
+  const NSInteger prevDepth = context.listDepth;
+  const ListType prevType = context.listType;
+  const NSInteger prevNum = context.listItemNumber;
+
+  const NSUInteger startLocation = output.length;
+  NSUInteger contentStart = startLocation;
+
+  if (prevDepth == 0) {
+    // Apply top margin for root-level list
+    contentStart += applyBlockSpacingBefore(output, startLocation, _config.listStyleMarginTop);
+  } else if (output.length > 0 && ![output.string hasSuffix:@"\n"]) {
+    // Ensure nested lists start on a new line
+    [output appendAttributedString:kNewlineAttributedString];
+  }
+
+  context.listDepth = prevDepth + 1;
+  context.listType = _isOrdered ? ListTypeOrdered : ListTypeUnordered;
+  context.listItemNumber = 0; // Reset counter for this specific list level
+
+  [context setBlockStyle:_isOrdered ? BlockTypeOrderedList : BlockTypeUnorderedList
+                    font:_config.listStyleFont
+                   color:_config.listStyleColor
+            headingLevel:0];
+
+  @try {
+    [_rendererFactory renderChildrenOfNode:node into:output context:context];
+  } @finally {
+    context.listDepth = prevDepth;
+    context.listType = prevType;
+    context.listItemNumber = prevNum;
+
+    if (prevDepth == 0) {
+      [context clearBlockStyle];
+
+      // Apply bottom margin for root-level list
+      applyBlockSpacingAfter(output, _config.listStyleMarginBottom);
+    }
+  }
+}
+
+@end

package/ios/renderer/NodeRenderer.h

@@ -0,0 +1,8 @@
+#import <Foundation/Foundation.h>
+
+@class MarkdownASTNode;
+@class RenderContext;
+
+@protocol NodeRenderer <NSObject>
+- (void)renderNode:(MarkdownASTNode *)node into:(NSMutableAttributedString *)output context:(RenderContext *)context;
+@end

package/ios/renderer/ParagraphRenderer.h

@@ -0,0 +1,6 @@
+#import "BaseRenderer.h"
+#import "MarkdownASTNode.h"
+#import "RenderContext.h"
+
+@interface ParagraphRenderer : BaseRenderer <NodeRenderer>
+@end

package/ios/renderer/ParagraphRenderer.m

@@ -0,0 +1,70 @@
+#import "ParagraphRenderer.h"
+#import "FontUtils.h"
+#import "MarkdownASTNode.h"
+#import "ParagraphStyleUtils.h"
+#import "RendererFactory.h"
+#import "StyleConfig.h"
+
+@implementation ParagraphRenderer
+
+- (void)renderNode:(MarkdownASTNode *)node into:(NSMutableAttributedString *)output context:(RenderContext *)context
+{
+  // Only set block style if a parent element (e.g. List, Blockquote) hasn't already established one
+  BOOL isTopLevel = (context.currentBlockType == BlockTypeNone);
+
+  if (isTopLevel) {
+    [context setBlockStyle:BlockTypeParagraph font:_config.paragraphFont color:_config.paragraphColor headingLevel:0];
+  }
+
+  NSUInteger start = output.length;
+  BOOL shouldApplyMargin =
+      (context.currentBlockType == BlockTypeNone || context.currentBlockType == BlockTypeParagraph);
+
+  // Detect if the paragraph is a wrapper for a standalone image to use image-specific spacing
+  BOOL isBlockImage = (node.children.count == 1 && ((MarkdownASTNode *)node.children[0]).type == MarkdownNodeTypeImage);
+  CGFloat marginTop = isBlockImage ? _config.imageMarginTop : _config.paragraphMarginTop;
+
+  NSUInteger contentStart = start;
+
+  // Handle leading margin for the first element in the document (Index 0 check)
+  if (shouldApplyMargin && start == 0) {
+    NSUInteger offset = applyBlockSpacingBefore(output, 0, marginTop);
+    contentStart += offset;
+    start += offset;
+  }
+
+  @try {
+    [_rendererFactory renderChildrenOfNode:node into:output context:context];
+  } @finally {
+    if (isTopLevel) {
+      [context clearBlockStyle];
+    }
+  }
+
+  if (output.length <= start)
+    return;
+  NSRange range = NSMakeRange(start, output.length - start);
+
+  // Avoid standard line height on block images to prevent vertical alignment issues
+  if (!isBlockImage) {
+    applyLineHeight(output, range, _config.paragraphLineHeight);
+    applyBaselineOffset(output, range);
+  }
+
+  applyTextAlignment(output, range, _config.paragraphTextAlign);
+
+  // Skip marginTop for the first block — already handled by applyBlockSpacingBefore above
+  if (shouldApplyMargin && contentStart != 1) {
+    NSUInteger inserted = applyParagraphSpacingBefore(output, range, marginTop);
+    start += inserted;
+  }
+
+  CGFloat marginBottom = 0;
+  if (shouldApplyMargin) {
+    marginBottom = isBlockImage ? _config.imageMarginBottom : _config.paragraphMarginBottom;
+  }
+
+  applyParagraphSpacingAfter(output, start, marginBottom);
+}
+
+@end