react-native-enriched-markdown 0.1.0 → 0.1.1

package/ios/renderer/RendererFactory.m

@@ -0,0 +1,110 @@
+#import "RendererFactory.h"
+#import "BlockquoteRenderer.h"
+#import "CodeBlockRenderer.h"
+#import "CodeRenderer.h"
+#import "EmphasisRenderer.h"
+#import "HeadingRenderer.h"
+#import "ImageRenderer.h"
+#import "LinkRenderer.h"
+#import "ListItemRenderer.h"
+#import "ListRenderer.h"
+#import "ParagraphRenderer.h"
+#import "RenderContext.h"
+#import "StrongRenderer.h"
+#import "StyleConfig.h"
+#import "TextRenderer.h"
+#import "ThematicBreakRenderer.h"
+
+@implementation RendererFactory {
+  StyleConfig *_config;
+  NSMutableDictionary<NSNumber *, id<NodeRenderer>> *_cache;
+}
+
+/**
+ * Initializes the factory with a shared style configuration.
+ * Uses a mutable dictionary to cache renderer instances as they are needed.
+ */
+- (instancetype)initWithConfig:(StyleConfig *)config
+{
+  self = [super init];
+  if (self) {
+    _config = config;
+    _cache = [NSMutableDictionary new];
+  }
+  return self;
+}
+
+/**
+ * Returns a shared renderer instance for a specific node type.
+ * Implements lazy initialization to avoid allocating unused renderers.
+ */
+- (id<NodeRenderer>)rendererForNodeType:(MarkdownNodeType)type
+{
+  id<NodeRenderer> cached = _cache[@(type)];
+  if (cached) {
+    return cached;
+  }
+
+  id<NodeRenderer> renderer = [self createRendererForType:type];
+  if (renderer) {
+    _cache[@(type)] = renderer;
+  }
+  return renderer;
+}
+
+/**
+ * Internal factory method to instantiate specialized renderers.
+ */
+- (id<NodeRenderer>)createRendererForType:(MarkdownNodeType)type
+{
+  switch (type) {
+    case MarkdownNodeTypeText:
+      return [TextRenderer new];
+    case MarkdownNodeTypeStrong:
+      return [[StrongRenderer alloc] initWithRendererFactory:self config:_config];
+    case MarkdownNodeTypeEmphasis:
+      return [[EmphasisRenderer alloc] initWithRendererFactory:self config:_config];
+    case MarkdownNodeTypeParagraph:
+      return [[ParagraphRenderer alloc] initWithRendererFactory:self config:_config];
+    case MarkdownNodeTypeLink:
+      return [[LinkRenderer alloc] initWithRendererFactory:self config:_config];
+    case MarkdownNodeTypeHeading:
+      return [[HeadingRenderer alloc] initWithRendererFactory:self config:_config];
+    case MarkdownNodeTypeCode:
+      return [[CodeRenderer alloc] initWithRendererFactory:self config:_config];
+    case MarkdownNodeTypeImage:
+      return [[ImageRenderer alloc] initWithRendererFactory:self config:_config];
+    case MarkdownNodeTypeBlockquote:
+      return [[BlockquoteRenderer alloc] initWithRendererFactory:self config:_config];
+    case MarkdownNodeTypeListItem:
+      return [[ListItemRenderer alloc] initWithRendererFactory:self config:_config];
+    case MarkdownNodeTypeUnorderedList:
+      return [[ListRenderer alloc] initWithRendererFactory:self config:_config isOrdered:NO];
+    case MarkdownNodeTypeOrderedList:
+      return [[ListRenderer alloc] initWithRendererFactory:self config:_config isOrdered:YES];
+    case MarkdownNodeTypeCodeBlock:
+      return [[CodeBlockRenderer alloc] initWithRendererFactory:self config:_config];
+    case MarkdownNodeTypeThematicBreak:
+      return [[ThematicBreakRenderer alloc] initWithRendererFactory:self config:_config];
+    default:
+      return nil;
+  }
+}
+
+/**
+ * Helper method for container renderers to process their children.
+ * Leverages the factory to find the appropriate renderer for each child node.
+ */
+- (void)renderChildrenOfNode:(MarkdownASTNode *)node
+                        into:(NSMutableAttributedString *)output
+                     context:(RenderContext *)context
+{
+  for (MarkdownASTNode *child in node.children) {
+    id<NodeRenderer> renderer = [self rendererForNodeType:child.type];
+    if (renderer) {
+      [renderer renderNode:child into:output context:context];
+    }
+  }
+}
+
+@end

package/ios/renderer/StrongRenderer.h

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

package/ios/renderer/StrongRenderer.m

@@ -0,0 +1,83 @@
+#import "StrongRenderer.h"
+#import "FontUtils.h"
+#import "MarkdownASTNode.h"
+#import "RenderContext.h"
+#import "RendererFactory.h"
+#import "StyleConfig.h"
+
+@implementation StrongRenderer {
+  RendererFactory *_rendererFactory;
+  StyleConfig *_config;
+}
+
+- (instancetype)initWithRendererFactory:(id)rendererFactory config:(id)config
+{
+  if (self = [super init]) {
+    _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 *configStrongColor = [_config strongColor];
+  UIColor *calculatedColor =
+      configStrongColor ? [RenderContext calculateStrongColor:configStrongColor blockColor:blockStyle.color] : nil;
+
+  [output enumerateAttributesInRange:range
+                             options:NSAttributedStringEnumerationLongestEffectiveRangeNotRequired
+                          usingBlock:^(NSDictionary<NSAttributedStringKey, id> *attrs, NSRange subrange, BOOL *stop) {
+                            // 1. Resolve Font
+                            UIFont *currentFont =
+                                attrs[NSFontAttributeName] ?: cachedFontFromBlockStyle(blockStyle, context);
+
+                            // Optimization: Only apply bold if not already bold
+                            if (!([currentFont.fontDescriptor symbolicTraits] & UIFontDescriptorTraitBold)) {
+                              UIFont *boldFont = [self ensureFontIsBold:currentFont];
+                              if (boldFont) {
+                                [output addAttribute:NSFontAttributeName value:boldFont range:subrange];
+                              }
+                            }
+
+                            // 2. Resolve Color
+                            // Only apply if we have a color and the current segment doesn't explicitly forbid overrides
+                            if (calculatedColor && ![RenderContext shouldPreserveColors:attrs]) {
+                              // Optimization: Check if this color is already set to avoid redundant attribute changes
+                              if (![attrs[NSForegroundColorAttributeName] isEqual:calculatedColor]) {
+                                [output addAttribute:NSForegroundColorAttributeName
+                                               value:calculatedColor
+                                               range:subrange];
+                              }
+                            }
+                          }];
+}
+
+#pragma mark - Helper Methods
+
+- (UIFont *)ensureFontIsBold:(UIFont *)font
+{
+  if (!font)
+    return nil;
+
+  UIFontDescriptor *descriptor = font.fontDescriptor;
+  UIFontDescriptorSymbolicTraits traits = descriptor.symbolicTraits;
+
+  // Create new descriptor combining current traits with Bold
+  UIFontDescriptor *boldDescriptor = [descriptor fontDescriptorWithSymbolicTraits:(traits | UIFontDescriptorTraitBold)];
+
+  // Fallback to original font if bold version is unavailable
+  return boldDescriptor ? [UIFont fontWithDescriptor:boldDescriptor size:0] : font;
+}
+
+@end

package/ios/renderer/TextRenderer.h

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

package/ios/renderer/TextRenderer.m

@@ -0,0 +1,16 @@
+#import "TextRenderer.h"
+#import "RenderContext.h"
+
+@implementation TextRenderer
+
+- (void)renderNode:(MarkdownASTNode *)node into:(NSMutableAttributedString *)output context:(RenderContext *)context
+{
+  if (!node.content)
+    return;
+
+  NSAttributedString *text = [[NSAttributedString alloc] initWithString:node.content
+                                                             attributes:[context getTextAttributes]];
+  [output appendAttributedString:text];
+}
+
+@end

package/ios/renderer/ThematicBreakRenderer.h

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

package/ios/renderer/ThematicBreakRenderer.m

@@ -0,0 +1,53 @@
+#import "ThematicBreakRenderer.h"
+#import "MarkdownASTNode.h"
+#import "StyleConfig.h"
+#import "ThematicBreakAttachment.h"
+
+#pragma mark - Renderer Implementation
+
+@implementation ThematicBreakRenderer {
+  __weak id _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
+{
+  [self ensureStartingNewline:output];
+
+  ThematicBreakAttachment *attachment = [[ThematicBreakAttachment alloc] init];
+  attachment.lineColor = _config.thematicBreakColor ?: [UIColor separatorColor];
+  attachment.lineHeight = _config.thematicBreakHeight > 0 ? _config.thematicBreakHeight : 1.0;
+  attachment.marginTop = _config.thematicBreakMarginTop;
+  attachment.marginBottom = _config.thematicBreakMarginBottom;
+
+  NSDictionary *attributes = @{
+    NSAttachmentAttributeName : attachment,
+    NSParagraphStyleAttributeName : [NSParagraphStyle defaultParagraphStyle]
+  };
+
+  NSAttributedString *breakString = [[NSAttributedString alloc] initWithString:@"\uFFFC" attributes:attributes];
+
+  [output appendAttributedString:breakString];
+  [output appendAttributedString:[[NSAttributedString alloc] initWithString:@"\n"]];
+}
+
+#pragma mark - Private Utilities
+
+- (void)ensureStartingNewline:(NSMutableAttributedString *)output
+{
+  if (output.length > 0 && ![output.string hasSuffix:@"\n"]) {
+    [output appendAttributedString:[[NSAttributedString alloc] initWithString:@"\n"]];
+  }
+}
+
+@end

package/ios/styles/StyleConfig.h

@@ -0,0 +1,228 @@
+#pragma once
+#import <UIKit/UIKit.h>
+
+@interface StyleConfig : NSObject <NSCopying>
+- (instancetype)init;
+// Primary font properties
+- (UIColor *)primaryColor;
+- (void)setPrimaryColor:(UIColor *)newValue;
+- (NSNumber *)primaryFontSize;
+- (void)setPrimaryFontSize:(NSNumber *)newValue;
+- (NSString *)primaryFontWeight;
+- (void)setPrimaryFontWeight:(NSString *)newValue;
+- (NSString *)primaryFontFamily;
+- (void)setPrimaryFontFamily:(NSString *)newValue;
+- (UIFont *)primaryFont;
+// Paragraph properties
+- (CGFloat)paragraphFontSize;
+- (void)setParagraphFontSize:(CGFloat)newValue;
+- (NSString *)paragraphFontFamily;
+- (void)setParagraphFontFamily:(NSString *)newValue;
+- (NSString *)paragraphFontWeight;
+- (void)setParagraphFontWeight:(NSString *)newValue;
+- (UIColor *)paragraphColor;
+- (void)setParagraphColor:(UIColor *)newValue;
+- (CGFloat)paragraphMarginBottom;
+- (void)setParagraphMarginBottom:(CGFloat)newValue;
+- (CGFloat)paragraphLineHeight;
+- (void)setParagraphLineHeight:(CGFloat)newValue;
+- (UIFont *)paragraphFont;
+// H1 properties
+- (CGFloat)h1FontSize;
+- (void)setH1FontSize:(CGFloat)newValue;
+- (NSString *)h1FontFamily;
+- (void)setH1FontFamily:(NSString *)newValue;
+- (NSString *)h1FontWeight;
+- (void)setH1FontWeight:(NSString *)newValue;
+- (UIColor *)h1Color;
+- (void)setH1Color:(UIColor *)newValue;
+- (CGFloat)h1MarginBottom;
+- (void)setH1MarginBottom:(CGFloat)newValue;
+- (CGFloat)h1LineHeight;
+- (void)setH1LineHeight:(CGFloat)newValue;
+- (UIFont *)h1Font;
+// H2 properties
+- (CGFloat)h2FontSize;
+- (void)setH2FontSize:(CGFloat)newValue;
+- (NSString *)h2FontFamily;
+- (void)setH2FontFamily:(NSString *)newValue;
+- (NSString *)h2FontWeight;
+- (void)setH2FontWeight:(NSString *)newValue;
+- (UIColor *)h2Color;
+- (void)setH2Color:(UIColor *)newValue;
+- (CGFloat)h2MarginBottom;
+- (void)setH2MarginBottom:(CGFloat)newValue;
+- (CGFloat)h2LineHeight;
+- (void)setH2LineHeight:(CGFloat)newValue;
+- (UIFont *)h2Font;
+// H3 properties
+- (CGFloat)h3FontSize;
+- (void)setH3FontSize:(CGFloat)newValue;
+- (NSString *)h3FontFamily;
+- (void)setH3FontFamily:(NSString *)newValue;
+- (NSString *)h3FontWeight;
+- (void)setH3FontWeight:(NSString *)newValue;
+- (UIColor *)h3Color;
+- (void)setH3Color:(UIColor *)newValue;
+- (CGFloat)h3MarginBottom;
+- (void)setH3MarginBottom:(CGFloat)newValue;
+- (CGFloat)h3LineHeight;
+- (void)setH3LineHeight:(CGFloat)newValue;
+- (UIFont *)h3Font;
+// H4 properties
+- (CGFloat)h4FontSize;
+- (void)setH4FontSize:(CGFloat)newValue;
+- (NSString *)h4FontFamily;
+- (void)setH4FontFamily:(NSString *)newValue;
+- (NSString *)h4FontWeight;
+- (void)setH4FontWeight:(NSString *)newValue;
+- (UIColor *)h4Color;
+- (void)setH4Color:(UIColor *)newValue;
+- (CGFloat)h4MarginBottom;
+- (void)setH4MarginBottom:(CGFloat)newValue;
+- (CGFloat)h4LineHeight;
+- (void)setH4LineHeight:(CGFloat)newValue;
+- (UIFont *)h4Font;
+// H5 properties
+- (CGFloat)h5FontSize;
+- (void)setH5FontSize:(CGFloat)newValue;
+- (NSString *)h5FontFamily;
+- (void)setH5FontFamily:(NSString *)newValue;
+- (NSString *)h5FontWeight;
+- (void)setH5FontWeight:(NSString *)newValue;
+- (UIColor *)h5Color;
+- (void)setH5Color:(UIColor *)newValue;
+- (CGFloat)h5MarginBottom;
+- (void)setH5MarginBottom:(CGFloat)newValue;
+- (CGFloat)h5LineHeight;
+- (void)setH5LineHeight:(CGFloat)newValue;
+- (UIFont *)h5Font;
+// H6 properties
+- (CGFloat)h6FontSize;
+- (void)setH6FontSize:(CGFloat)newValue;
+- (NSString *)h6FontFamily;
+- (void)setH6FontFamily:(NSString *)newValue;
+- (NSString *)h6FontWeight;
+- (void)setH6FontWeight:(NSString *)newValue;
+- (UIColor *)h6Color;
+- (void)setH6Color:(UIColor *)newValue;
+- (CGFloat)h6MarginBottom;
+- (void)setH6MarginBottom:(CGFloat)newValue;
+- (CGFloat)h6LineHeight;
+- (void)setH6LineHeight:(CGFloat)newValue;
+- (UIFont *)h6Font;
+// Link properties
+- (UIColor *)linkColor;
+- (void)setLinkColor:(UIColor *)newValue;
+- (BOOL)linkUnderline;
+- (void)setLinkUnderline:(BOOL)newValue;
+// Strong properties
+- (UIColor *)strongColor;
+- (void)setStrongColor:(UIColor *)newValue;
+// Emphasis properties
+- (UIColor *)emphasisColor;
+- (void)setEmphasisColor:(UIColor *)newValue;
+// Code properties
+- (UIColor *)codeColor;
+- (void)setCodeColor:(UIColor *)newValue;
+- (UIColor *)codeBackgroundColor;
+- (void)setCodeBackgroundColor:(UIColor *)newValue;
+- (UIColor *)codeBorderColor;
+- (void)setCodeBorderColor:(UIColor *)newValue;
+// Image properties
+- (CGFloat)imageHeight;
+- (void)setImageHeight:(CGFloat)newValue;
+- (CGFloat)imageBorderRadius;
+- (void)setImageBorderRadius:(CGFloat)newValue;
+- (CGFloat)imageMarginBottom;
+- (void)setImageMarginBottom:(CGFloat)newValue;
+// Inline image properties
+- (CGFloat)inlineImageSize;
+- (void)setInlineImageSize:(CGFloat)newValue;
+// Blockquote properties
+- (CGFloat)blockquoteFontSize;
+- (void)setBlockquoteFontSize:(CGFloat)newValue;
+- (NSString *)blockquoteFontFamily;
+- (void)setBlockquoteFontFamily:(NSString *)newValue;
+- (NSString *)blockquoteFontWeight;
+- (void)setBlockquoteFontWeight:(NSString *)newValue;
+- (UIColor *)blockquoteColor;
+- (void)setBlockquoteColor:(UIColor *)newValue;
+- (CGFloat)blockquoteMarginBottom;
+- (void)setBlockquoteMarginBottom:(CGFloat)newValue;
+- (CGFloat)blockquoteLineHeight;
+- (void)setBlockquoteLineHeight:(CGFloat)newValue;
+- (UIFont *)blockquoteFont;
+- (UIColor *)blockquoteBorderColor;
+- (void)setBlockquoteBorderColor:(UIColor *)newValue;
+- (CGFloat)blockquoteBorderWidth;
+- (void)setBlockquoteBorderWidth:(CGFloat)newValue;
+- (CGFloat)blockquoteGapWidth;
+- (void)setBlockquoteGapWidth:(CGFloat)newValue;
+- (UIColor *)blockquoteBackgroundColor;
+- (void)setBlockquoteBackgroundColor:(UIColor *)newValue;
+// List style properties (combined for both ordered and unordered lists)
+- (CGFloat)listStyleFontSize;
+- (void)setListStyleFontSize:(CGFloat)newValue;
+- (NSString *)listStyleFontFamily;
+- (void)setListStyleFontFamily:(NSString *)newValue;
+- (NSString *)listStyleFontWeight;
+- (void)setListStyleFontWeight:(NSString *)newValue;
+- (UIColor *)listStyleColor;
+- (void)setListStyleColor:(UIColor *)newValue;
+- (CGFloat)listStyleMarginBottom;
+- (void)setListStyleMarginBottom:(CGFloat)newValue;
+- (CGFloat)listStyleLineHeight;
+- (void)setListStyleLineHeight:(CGFloat)newValue;
+- (UIColor *)listStyleBulletColor;
+- (void)setListStyleBulletColor:(UIColor *)newValue;
+- (CGFloat)listStyleBulletSize;
+- (void)setListStyleBulletSize:(CGFloat)newValue;
+- (UIColor *)listStyleMarkerColor;
+- (void)setListStyleMarkerColor:(UIColor *)newValue;
+- (NSString *)listStyleMarkerFontWeight;
+- (void)setListStyleMarkerFontWeight:(NSString *)newValue;
+- (CGFloat)listStyleGapWidth;
+- (void)setListStyleGapWidth:(CGFloat)newValue;
+- (CGFloat)listStyleMarginLeft;
+- (void)setListStyleMarginLeft:(CGFloat)newValue;
+- (UIFont *)listMarkerFont;
+- (UIFont *)listStyleFont;
+- (CGFloat)effectiveListGapWidth;
+- (CGFloat)effectiveListMarginLeftForBullet;
+- (CGFloat)effectiveListMarginLeftForNumber;
+// Code block properties
+- (CGFloat)codeBlockFontSize;
+- (void)setCodeBlockFontSize:(CGFloat)newValue;
+- (NSString *)codeBlockFontFamily;
+- (void)setCodeBlockFontFamily:(NSString *)newValue;
+- (NSString *)codeBlockFontWeight;
+- (void)setCodeBlockFontWeight:(NSString *)newValue;
+- (UIColor *)codeBlockColor;
+- (void)setCodeBlockColor:(UIColor *)newValue;
+- (CGFloat)codeBlockMarginBottom;
+- (void)setCodeBlockMarginBottom:(CGFloat)newValue;
+- (CGFloat)codeBlockLineHeight;
+- (void)setCodeBlockLineHeight:(CGFloat)newValue;
+- (UIColor *)codeBlockBackgroundColor;
+- (void)setCodeBlockBackgroundColor:(UIColor *)newValue;
+- (UIColor *)codeBlockBorderColor;
+- (void)setCodeBlockBorderColor:(UIColor *)newValue;
+- (CGFloat)codeBlockBorderRadius;
+- (void)setCodeBlockBorderRadius:(CGFloat)newValue;
+- (CGFloat)codeBlockBorderWidth;
+- (void)setCodeBlockBorderWidth:(CGFloat)newValue;
+- (CGFloat)codeBlockPadding;
+- (void)setCodeBlockPadding:(CGFloat)newValue;
+- (UIFont *)codeBlockFont;
+// Thematic break properties
+- (UIColor *)thematicBreakColor;
+- (void)setThematicBreakColor:(UIColor *)newValue;
+- (CGFloat)thematicBreakHeight;
+- (void)setThematicBreakHeight:(CGFloat)newValue;
+- (CGFloat)thematicBreakMarginTop;
+- (void)setThematicBreakMarginTop:(CGFloat)newValue;
+- (CGFloat)thematicBreakMarginBottom;
+- (void)setThematicBreakMarginBottom:(CGFloat)newValue;
+
+@end