react-native-enriched-markdown 0.1.0 → 0.2.0

package/ios/renderer/AttributedRenderer.m

@@ -0,0 +1,152 @@
+#import "AttributedRenderer.h"
+#import "CodeBlockBackground.h"
+#import "LastElementUtils.h"
+#import "MarkdownASTNode.h"
+#import "NodeRenderer.h"
+#import "RenderContext.h"
+#import "RendererFactory.h"
+#import "StyleConfig.h"
+
+@implementation AttributedRenderer {
+  StyleConfig *_config;
+  RendererFactory *_rendererFactory;
+  CGFloat _lastElementMarginBottom;
+  BOOL _allowTrailingMargin;
+}
+
+- (instancetype)initWithConfig:(StyleConfig *)config
+{
+  self = [super init];
+  if (self) {
+    _config = config;
+    _rendererFactory = [[RendererFactory alloc] initWithConfig:config];
+    _lastElementMarginBottom = 0.0;
+    _allowTrailingMargin = NO;
+  }
+  return self;
+}
+
+/**
+ * Entry point for rendering a Markdown AST.
+ * Sets the baseline global style and initiates the recursive traversal.
+ */
+- (NSMutableAttributedString *)renderRoot:(MarkdownASTNode *)root context:(RenderContext *)context
+{
+  if (!root)
+    return [[NSMutableAttributedString alloc] init];
+
+  // 1. Establish the global baseline style.
+  // This ensures that leaf nodes (like Text) have valid attributes if they appear at the root.
+  [context setBlockStyle:BlockTypeParagraph font:_config.paragraphFont color:_config.paragraphColor headingLevel:0];
+
+  NSMutableAttributedString *output = [[NSMutableAttributedString alloc] init];
+
+  // 2. Iterate through root children.
+  // We skip the 'Root' node itself as it is a container, not a renderable element.
+  for (MarkdownASTNode *node in root.children) {
+    [self renderNodeRecursive:node into:output context:context];
+  }
+
+  // 3. Remove trailing paragraph spacing from last block element
+  // Reset lastElementMarginBottom before processing
+  _lastElementMarginBottom = 0.0;
+  [self removeTrailingSpacing:output];
+
+  // 4. Cleanup global state to prevent side effects in subsequent renders.
+  [context clearBlockStyle];
+
+  return output;
+}
+
+/// Removes trailing margin spacing while preserving code block padding
+- (void)removeTrailingSpacing:(NSMutableAttributedString *)output
+{
+  if (output.length == 0)
+    return;
+
+  // Find the last non-newline character
+  NSRange lastContent = [output.string rangeOfCharacterFromSet:[NSCharacterSet.newlineCharacterSet invertedSet]
+                                                       options:NSBackwardsSearch];
+  if (lastContent.location == NSNotFound)
+    return;
+
+  // 1. Capture the Margin Bottom (Scanning from last content to end)
+  _lastElementMarginBottom = 0.0;
+  for (NSUInteger i = lastContent.location; i < output.length;) {
+    NSRange attrRange;
+    NSParagraphStyle *style = [output attribute:NSParagraphStyleAttributeName atIndex:i effectiveRange:&attrRange];
+    if (style) {
+      _lastElementMarginBottom = MAX(_lastElementMarginBottom, style.paragraphSpacing);
+    }
+    i = NSMaxRange(attrRange);
+  }
+
+  // 2. Trim trailing characters
+  NSUInteger logicalEnd = NSMaxRange(lastContent);
+  if (isLastElementCodeBlock(output)) {
+    NSRange codeRange;
+    [output attribute:CodeBlockAttributeName atIndex:lastContent.location effectiveRange:&codeRange];
+    logicalEnd = NSMaxRange(codeRange);
+  }
+
+  if (logicalEnd < output.length) {
+    [output deleteCharactersInRange:NSMakeRange(logicalEnd, output.length - logicalEnd)];
+  }
+
+  // 3. Zero out internal spacing for the last element (if not a code block)
+  if (!isLastElementCodeBlock(output)) {
+    NSRange styleRange;
+    NSParagraphStyle *style = [output attribute:NSParagraphStyleAttributeName
+                                        atIndex:lastContent.location
+                                 effectiveRange:&styleRange];
+
+    if (style) {
+      NSMutableParagraphStyle *mutableStyle = [style mutableCopy];
+      mutableStyle.paragraphSpacing = 0;
+      mutableStyle.paragraphSpacingBefore = 0;
+
+      if (isLastElementImage(output)) {
+        mutableStyle.lineSpacing = 0;
+      }
+
+      NSRange safeRange = NSIntersectionRange(styleRange, NSMakeRange(0, output.length));
+      [output addAttribute:NSParagraphStyleAttributeName value:mutableStyle range:safeRange];
+    }
+  }
+}
+
+- (void)setAllowTrailingMargin:(BOOL)allow
+{
+  _allowTrailingMargin = allow;
+}
+
+- (CGFloat)getLastElementMarginBottom
+{
+  return _lastElementMarginBottom;
+}
+
+/**
+ * Orchestrates the recursive traversal of the AST.
+ * If a specialized renderer exists for a node type, it takes full control.
+ */
+- (void)renderNodeRecursive:(MarkdownASTNode *)node
+                       into:(NSMutableAttributedString *)out
+                    context:(RenderContext *)context
+{
+  if (!node)
+    return;
+
+  id<NodeRenderer> renderer = [_rendererFactory rendererForNodeType:node.type];
+
+  if (renderer) {
+    // Specialized renderers (e.g., Strong, Link, Heading) handle their own sub-trees.
+    [renderer renderNode:node into:out context:context];
+  } else {
+    // Fallback: Default to deep-first traversal for unhandled container nodes.
+    for (MarkdownASTNode *child in node.children) {
+      [self renderNodeRecursive:child into:out context:context];
+    }
+  }
+}
+
+@end

package/ios/renderer/BlockquoteRenderer.h

@@ -0,0 +1,7 @@
+#import "MarkdownASTNode.h"
+#import "NodeRenderer.h"
+#import "RenderContext.h"
+
+@interface BlockquoteRenderer : NSObject <NodeRenderer>
+- (instancetype)initWithRendererFactory:(id)rendererFactory config:(id)config;
+@end

package/ios/renderer/BlockquoteRenderer.m

@@ -0,0 +1,160 @@
+#import "BlockquoteRenderer.h"
+#import "BlockquoteBorder.h"
+#import "FontUtils.h"
+#import "MarkdownASTNode.h"
+#import "ParagraphStyleUtils.h"
+#import "RendererFactory.h"
+#import "StyleConfig.h"
+
+static NSString *const kNestedInfoDepthKey = @"depth";
+static NSString *const kNestedInfoRangeKey = @"range";
+
+@implementation BlockquoteRenderer {
+  RendererFactory *_rendererFactory;
+  StyleConfig *_config;
+}
+
+- (instancetype)initWithRendererFactory:(id)rendererFactory config:(id)config
+{
+  if (self = [super init]) {
+    _rendererFactory = rendererFactory;
+    _config = (StyleConfig *)config;
+  }
+  return self;
+}
+
+- (void)renderNode:(MarkdownASTNode *)node into:(NSMutableAttributedString *)output context:(RenderContext *)context
+{
+  NSInteger currentDepth = context.blockquoteDepth;
+  context.blockquoteDepth = currentDepth + 1;
+
+  [context setBlockStyle:BlockTypeBlockquote
+                    font:[_config blockquoteFont]
+                   color:[_config blockquoteColor]
+            headingLevel:0];
+
+  NSUInteger start = output.length;
+  @try {
+    [_rendererFactory renderChildrenOfNode:node into:output context:context];
+  } @finally {
+    [context clearBlockStyle];
+    context.blockquoteDepth = currentDepth;
+  }
+
+  NSUInteger end = output.length;
+  if (end <= start) {
+    return;
+  }
+
+  [self applyStylingAndSpacing:output start:start end:end currentDepth:currentDepth];
+}
+
+#pragma mark - Styling and Spacing
+
+- (void)applyStylingAndSpacing:(NSMutableAttributedString *)output
+                         start:(NSUInteger)start
+                           end:(NSUInteger)end
+                  currentDepth:(NSInteger)currentDepth
+{
+  NSUInteger contentStart = start;
+  if (currentDepth == 0) {
+    contentStart += applyBlockSpacingBefore(output, start, [_config blockquoteMarginTop]);
+  }
+
+  NSRange blockquoteRange = NSMakeRange(contentStart, end - start);
+  CGFloat levelSpacing = [_config blockquoteBorderWidth] + [_config blockquoteGapWidth];
+  NSArray<NSDictionary *> *nestedInfo = [self collectNestedBlockquotes:output range:blockquoteRange depth:currentDepth];
+
+  // Apply base styling (indentation, depth, background, line height)
+  [self applyBaseBlockquoteStyle:output
+                           range:blockquoteRange
+                           depth:currentDepth
+                    levelSpacing:levelSpacing
+                 backgroundColor:[_config blockquoteBackgroundColor]
+                      lineHeight:[_config blockquoteLineHeight]];
+
+  // Re-apply nested blockquote styles to restore their correct indentation
+  // (applyBaseBlockquoteStyle overwrites nested indents with the parent's indent)
+  [self reapplyNestedStyles:output nestedInfo:nestedInfo levelSpacing:levelSpacing];
+
+  if (currentDepth == 0) {
+    applyBlockSpacingAfter(output, [_config blockquoteMarginBottom]);
+  }
+}
+
+#pragma mark - Nested Blockquote Handling
+
+- (NSArray<NSDictionary *> *)collectNestedBlockquotes:(NSMutableAttributedString *)output
+                                                range:(NSRange)blockquoteRange
+                                                depth:(NSInteger)currentDepth
+{
+  NSMutableArray<NSDictionary *> *nestedInfo = [NSMutableArray array];
+
+  [output
+      enumerateAttribute:BlockquoteDepthAttributeName
+                 inRange:blockquoteRange
+                 options:NSAttributedStringEnumerationLongestEffectiveRangeNotRequired
+              usingBlock:^(id value, NSRange range, BOOL *stop) {
+                NSInteger depth = [value integerValue];
+                if (value && depth > currentDepth) {
+                  [nestedInfo
+                      addObject:@{kNestedInfoDepthKey : value, kNestedInfoRangeKey : [NSValue valueWithRange:range]}];
+                }
+              }];
+
+  return nestedInfo;
+}
+
+- (void)applyBaseBlockquoteStyle:(NSMutableAttributedString *)output
+                           range:(NSRange)blockquoteRange
+                           depth:(NSInteger)currentDepth
+                    levelSpacing:(CGFloat)levelSpacing
+                 backgroundColor:(UIColor *)backgroundColor
+                      lineHeight:(CGFloat)lineHeight
+{
+  NSMutableParagraphStyle *paragraphStyle = getOrCreateParagraphStyle(output, blockquoteRange.location);
+  CGFloat totalIndent = [self calculateIndentForDepth:currentDepth levelSpacing:levelSpacing];
+  paragraphStyle.firstLineHeadIndent = totalIndent;
+  paragraphStyle.headIndent = totalIndent;
+
+  NSMutableDictionary *newAttributes =
+      [NSMutableDictionary dictionaryWithObjectsAndKeys:paragraphStyle, NSParagraphStyleAttributeName, @(currentDepth),
+                                                        BlockquoteDepthAttributeName, nil];
+  if (backgroundColor) {
+    newAttributes[BlockquoteBackgroundColorAttributeName] = backgroundColor;
+  }
+  [output addAttributes:newAttributes range:blockquoteRange];
+
+  applyLineHeight(output, blockquoteRange, lineHeight);
+}
+
+- (void)reapplyNestedStyles:(NSMutableAttributedString *)output
+                 nestedInfo:(NSArray<NSDictionary *> *)nestedInfo
+               levelSpacing:(CGFloat)levelSpacing
+{
+  // Re-apply indentation to nested blockquotes since applyBaseBlockquoteStyle
+  // overwrote them with the parent's indentation
+  for (NSDictionary *info in nestedInfo) {
+    NSRange nestedRange = [info[kNestedInfoRangeKey] rangeValue];
+    NSInteger nestedDepth = [info[kNestedInfoDepthKey] integerValue];
+    NSMutableParagraphStyle *style = getOrCreateParagraphStyle(output, nestedRange.location);
+
+    CGFloat indent = [self calculateIndentForDepth:nestedDepth levelSpacing:levelSpacing];
+    style.firstLineHeadIndent = indent;
+    style.headIndent = indent;
+    style.tailIndent = 0;
+
+    [output
+        addAttributes:@{NSParagraphStyleAttributeName : style, BlockquoteDepthAttributeName : info[kNestedInfoDepthKey]}
+                range:nestedRange];
+  }
+}
+
+#pragma mark - Helper Methods
+
+- (CGFloat)calculateIndentForDepth:(NSInteger)depth levelSpacing:(CGFloat)levelSpacing
+{
+  return (depth + 1) * levelSpacing;
+}
+
+@end

package/ios/renderer/CodeBlockRenderer.h

@@ -0,0 +1,10 @@
+#pragma once
+#import "NodeRenderer.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface CodeBlockRenderer : NSObject <NodeRenderer>
+- (instancetype)initWithRendererFactory:(id)rendererFactory config:(id)config;
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/renderer/CodeBlockRenderer.m

@@ -0,0 +1,90 @@
+#import "CodeBlockRenderer.h"
+#import "CodeBlockBackground.h"
+#import "LastElementUtils.h"
+#import "MarkdownASTNode.h"
+#import "ParagraphStyleUtils.h"
+#import "RenderContext.h"
+#import "RendererFactory.h"
+#import "StyleConfig.h"
+
+@implementation CodeBlockRenderer {
+  RendererFactory *_rendererFactory;
+  StyleConfig *_config;
+}
+
+- (instancetype)initWithRendererFactory:(id)rendererFactory config:(id)config
+{
+  if (self = [super init]) {
+    _rendererFactory = rendererFactory;
+    _config = (StyleConfig *)config;
+  }
+  return self;
+}
+
+- (void)renderNode:(MarkdownASTNode *)node into:(NSMutableAttributedString *)output context:(RenderContext *)context
+{
+  [context setBlockStyle:BlockTypeCodeBlock font:[_config codeBlockFont] color:[_config codeBlockColor] headingLevel:0];
+
+  CGFloat padding = [_config codeBlockPadding];
+  CGFloat lineHeight = [_config codeBlockLineHeight];
+  CGFloat marginTop = [_config codeBlockMarginTop];
+  CGFloat marginBottom = [_config codeBlockMarginBottom];
+
+  NSUInteger blockStart = output.length;
+  blockStart += applyBlockSpacingBefore(output, blockStart, marginTop);
+
+  // Top Padding: Inserted as a spacer character inside the background area
+  [output appendAttributedString:kNewlineAttributedString];
+  NSMutableParagraphStyle *topSpacerStyle = [context spacerStyleWithHeight:padding spacing:0];
+  [output addAttribute:NSParagraphStyleAttributeName value:topSpacerStyle range:NSMakeRange(blockStart, 1)];
+
+  NSUInteger contentStart = output.length;
+  @try {
+    [_rendererFactory renderChildrenOfNode:node into:output context:context];
+  } @finally {
+    [context clearBlockStyle];
+  }
+
+  NSUInteger contentEnd = output.length;
+  if (contentEnd <= contentStart)
+    return;
+
+  NSRange contentRange = NSMakeRange(contentStart, contentEnd - contentStart);
+
+  UIFont *codeFont = [_config codeBlockFont];
+  UIColor *codeColor = [_config codeBlockColor];
+  if (codeColor) {
+    [output addAttributes:@{NSFontAttributeName : codeFont, NSForegroundColorAttributeName : codeColor}
+                    range:contentRange];
+  } else {
+    [output addAttribute:NSFontAttributeName value:codeFont range:contentRange];
+  }
+
+  if (lineHeight > 0) {
+    applyLineHeight(output, contentRange, lineHeight);
+  }
+
+  // Apply horizontal indents to the content
+  NSMutableParagraphStyle *baseStyle = [getOrCreateParagraphStyle(output, contentStart) mutableCopy];
+  baseStyle.firstLineHeadIndent = padding;
+  baseStyle.headIndent = padding;
+  baseStyle.tailIndent = -padding;
+  [output addAttribute:NSParagraphStyleAttributeName value:baseStyle range:contentRange];
+
+  // Bottom Padding: Inserted as a spacer character inside the background area
+  NSUInteger bottomPaddingStart = output.length;
+  [output appendAttributedString:kNewlineAttributedString];
+  NSMutableParagraphStyle *bottomPaddingStyle = [context spacerStyleWithHeight:padding spacing:0];
+  [output addAttribute:NSParagraphStyleAttributeName value:bottomPaddingStyle range:NSMakeRange(bottomPaddingStart, 1)];
+
+  // Define the range for background rendering (includes padding, excludes margins)
+  NSRange backgroundRange = NSMakeRange(blockStart, output.length - blockStart);
+  [output addAttribute:CodeBlockAttributeName value:@YES range:backgroundRange];
+
+  // External Margin: Applied outside the background range
+  if (marginBottom > 0) {
+    applyBlockSpacingAfter(output, marginBottom);
+  }
+}
+
+@end

package/ios/renderer/CodeRenderer.h

@@ -0,0 +1,10 @@
+#pragma once
+#import "NodeRenderer.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface CodeRenderer : NSObject <NodeRenderer>
+- (instancetype)initWithRendererFactory:(id)rendererFactory config:(id)config;
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/renderer/CodeRenderer.m

@@ -0,0 +1,60 @@
+#import "CodeRenderer.h"
+#import "CodeBackground.h"
+#import "FontUtils.h"
+#import "MarkdownASTNode.h"
+#import "RenderContext.h"
+#import "RendererFactory.h"
+#import "StyleConfig.h"
+
+@implementation CodeRenderer {
+  RendererFactory *_rendererFactory;
+  StyleConfig *_config;
+}
+
+- (instancetype)initWithRendererFactory:(id)rendererFactory config:(id)config
+{
+  self = [super init];
+  if (self) {
+    _rendererFactory = rendererFactory;
+    _config = (StyleConfig *)config;
+  }
+  return self;
+}
+
+- (void)renderNode:(MarkdownASTNode *)node into:(NSMutableAttributedString *)output context:(RenderContext *)context
+{
+
+  BlockStyle *blockStyle = [context getBlockStyle];
+
+  UIColor *codeColor = _config.codeColor;
+
+  UIFont *blockFont = cachedFontFromBlockStyle(blockStyle, context);
+
+  UIFontDescriptorSymbolicTraits traits = blockFont.fontDescriptor.symbolicTraits;
+  UIFontWeight weight = (traits & UIFontDescriptorTraitBold) ? UIFontWeightBold : UIFontWeightRegular;
+
+  UIFont *monospacedFont = [UIFont monospacedSystemFontOfSize:blockStyle.fontSize weight:weight];
+
+  NSUInteger start = output.length;
+
+  [_rendererFactory renderChildrenOfNode:node into:output context:context];
+
+  NSRange range = [RenderContext rangeForRenderedContent:output start:start];
+  if (range.length > 0) {
+    NSDictionary *existingAttributes = [output attributesAtIndex:start effectiveRange:NULL];
+    NSMutableDictionary *codeAttributes = [existingAttributes ?: @{} mutableCopy];
+
+    codeAttributes[NSFontAttributeName] = monospacedFont;
+    if (codeColor) {
+      codeAttributes[NSForegroundColorAttributeName] = codeColor;
+    }
+    codeAttributes[CodeAttributeName] = @YES;
+
+    // Store block line height directly for CodeBackground to use
+    codeAttributes[@"BlockLineHeight"] = @(blockFont.lineHeight);
+
+    [output setAttributes:codeAttributes range:range];
+  }
+}
+
+@end

package/ios/renderer/EmphasisRenderer.h

@@ -0,0 +1,6 @@
+#pragma once
+#import "NodeRenderer.h"
+
+@interface EmphasisRenderer : NSObject <NodeRenderer>
+- (instancetype)initWithRendererFactory:(id)rendererFactory config:(id)config;
+@end

package/ios/renderer/EmphasisRenderer.m

@@ -0,0 +1,96 @@
+#import "EmphasisRenderer.h"
+#import "FontUtils.h"
+#import "MarkdownASTNode.h"
+#import "RenderContext.h"
+#import "RendererFactory.h"
+#import "StyleConfig.h"
+
+@implementation EmphasisRenderer {
+  RendererFactory *_rendererFactory;
+  StyleConfig *_config;
+}
+
+- (instancetype)initWithRendererFactory:(id)rendererFactory config:(id)config
+{
+  self = [super init];
+  if (self) {
+    _rendererFactory = rendererFactory;
+    _config = (StyleConfig *)config;
+  }
+  return self;
+}
+
+#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];
+  UIColor *configEmphasisColor = [_config emphasisColor];
+
+  // Cache the Strong color calculation to efficiently detect nested Strong nodes
+  UIColor *strongColorToPreserve = [_config strongColor] ? [RenderContext calculateStrongColor:[_config strongColor]
+                                                                                    blockColor:blockStyle.color]
+                                                         : nil;
+
+  [output
+      enumerateAttributesInRange:range
+                         options:NSAttributedStringEnumerationLongestEffectiveRangeNotRequired
+                      usingBlock:^(NSDictionary<NSAttributedStringKey, id> *attrs, NSRange subrange, BOOL *stop) {
+                        // 1. Font Optimization: Only apply italic trait if not already present
+                        UIFont *currentFont =
+                            attrs[NSFontAttributeName] ?: cachedFontFromBlockStyle(blockStyle, context);
+                        if (currentFont && !(currentFont.fontDescriptor.symbolicTraits & UIFontDescriptorTraitItalic)) {
+                          UIFont *italicFont = [self ensureFontIsItalic:currentFont];
+                          if (italicFont) {
+                            [output addAttribute:NSFontAttributeName value:italicFont range:subrange];
+                          }
+                        }
+
+                        // 2. Color Optimization: Handle nesting and avoid redundant updates
+                        if (configEmphasisColor) {
+                          UIColor *currentColor = attrs[NSForegroundColorAttributeName];
+                          BOOL isLink = attrs[NSLinkAttributeName] != nil;
+
+                          // Verify if the current color belongs to a Strong parent
+                          BOOL isStrongColor = strongColorToPreserve && [currentColor isEqual:strongColorToPreserve];
+
+                          // Preserving colors for higher-priority elements (links, strong nodes, etc.)
+                          if (!isLink && !isStrongColor && ![RenderContext shouldPreserveColors:attrs]) {
+                            // Only modify the string if the color is actually different
+                            if (![currentColor isEqual:configEmphasisColor]) {
+                              [output addAttribute:NSForegroundColorAttributeName
+                                             value:configEmphasisColor
+                                             range:subrange];
+                            }
+                          }
+                        }
+                      }];
+}
+
+#pragma mark - Helper Methods
+
+- (UIFont *)ensureFontIsItalic:(UIFont *)font
+{
+  if (!font)
+    return nil;
+
+  UIFontDescriptorSymbolicTraits traits = font.fontDescriptor.symbolicTraits;
+  if (traits & UIFontDescriptorTraitItalic)
+    return font;
+
+  // Combine italic with existing traits (e.g., preserving Bold if present)
+  UIFontDescriptorSymbolicTraits combinedTraits = traits | UIFontDescriptorTraitItalic;
+  UIFontDescriptor *italicDescriptor = [font.fontDescriptor fontDescriptorWithSymbolicTraits:combinedTraits];
+
+  // Size 0 in fontWithDescriptor:size: maintains the current point size
+  return [UIFont fontWithDescriptor:italicDescriptor size:0] ?: font;
+}
+
+@end

package/ios/renderer/HeadingRenderer.h

@@ -0,0 +1,7 @@
+#import "MarkdownASTNode.h"
+#import "NodeRenderer.h"
+#import "RenderContext.h"
+
+@interface HeadingRenderer : NSObject <NodeRenderer>
+- (instancetype)initWithRendererFactory:(id)rendererFactory config:(id)config;
+@end