@mathers101/react-native-render-rich-text 0.0.0-stage → 0.1.10

package/ios/renderer/BlockquoteRenderer.m

@@ -0,0 +1,258 @@
+#import "BlockquoteRenderer.h"
+#import "BlockquoteBorder.h"
+#import "FontUtils.h"
+#import "LastElementUtils.h"
+#import "ListItemRenderer.h"
+#import "TiptapASTNode.h"
+#import "ParagraphStyleUtils.h"
+#import "RenderContext.h"
+#import "RendererFactory.h"
+#import "StyleConfig.h"
+
+static NSString *const kNestedInfoDepthKey = @"depth";
+static NSString *const kNestedInfoRangeKey = @"range";
+
+@implementation BlockquoteRenderer
+
+- (id)takeContextSnapshot:(RenderContext *)context
+{
+  return [context snapshotScope];
+}
+
+- (void)renderNodeContent:(TiptapASTNode *)node
+                     into:(NSMutableAttributedString *)output
+                  context:(RenderContext *)context
+{
+  if (output.length > 0 && ![output.string hasSuffix:@"\n"]) {
+    [output appendAttributedString:kNewlineAttributedString];
+  }
+
+  NSInteger currentDepth = context.blockquoteDepth;
+  context.blockquoteDepth = currentDepth + 1;
+
+  [context setBlockStyle:BlockTypeBlockquote
+                    font:[_config blockquoteFont]
+                   color:[_config blockquoteColor]
+            headingLevel:0];
+
+  NSUInteger start = output.length;
+  [_rendererFactory renderChildrenOfNode:node into:output context:context];
+
+  NSUInteger end = output.length;
+  if (end <= start) {
+    return;
+  }
+
+  [self applyStylingAndSpacing:output start:start end:end currentDepth:currentDepth context:context];
+}
+
+#pragma mark - Styling and Spacing
+
+- (void)applyStylingAndSpacing:(NSMutableAttributedString *)output
+                         start:(NSUInteger)start
+                           end:(NSUInteger)end
+                  currentDepth:(NSInteger)currentDepth
+                       context:(RenderContext *)context
+{
+  NSUInteger contentStart = start;
+  if (currentDepth == 0) {
+    contentStart += applyBlockSpacingBefore(output, start, [_config blockquoteMarginTop]);
+  }
+
+  // nested quotes pad their own box (matching web CSS padding)
+  CGFloat padding = [_config blockquotePadding];
+  NSUInteger topPadLength = 0;
+  NSUInteger bottomPadLength = 0;
+  if (padding > 0) {
+    NSMutableParagraphStyle *topSpacerStyle = [context spacerStyleWithHeight:padding spacing:0];
+    NSAttributedString *topSpacer = [[NSAttributedString alloc]
+        initWithString:@"\n"
+            attributes:@{NSParagraphStyleAttributeName : topSpacerStyle, BlockquoteSpacerAttributeName : @YES}];
+    [output insertAttributedString:topSpacer atIndex:contentStart];
+    topPadLength = 1;
+
+    NSUInteger bottomSpacerLocation = output.length;
+    [output appendAttributedString:kNewlineAttributedString];
+    NSMutableParagraphStyle *bottomSpacerStyle = [context spacerStyleWithHeight:padding spacing:0];
+    [output addAttributes:@{NSParagraphStyleAttributeName : bottomSpacerStyle, BlockquoteSpacerAttributeName : @YES}
+                    range:NSMakeRange(bottomSpacerLocation, 1)];
+    bottomPadLength = 1;
+  }
+
+  NSRange blockquoteRange = NSMakeRange(contentStart, (end - start) + topPadLength + bottomPadLength);
+  NSRange innerRange = NSMakeRange(contentStart + topPadLength, end - start);
+  CGFloat levelSpacing = [_config blockquoteBorderWidth] + [_config blockquoteGapWidth];
+  NSArray<NSDictionary *> *nestedInfo = [self collectNestedBlockquotes:output range:innerRange depth:currentDepth];
+
+  // Apply base styling (indentation, depth, background, line height)
+  [self applyBaseBlockquoteStyle:output
+                        boxRange:blockquoteRange
+                      innerRange:innerRange
+                           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
+                        boxRange:(NSRange)boxRange
+                      innerRange:(NSRange)innerRange
+                           depth:(NSInteger)currentDepth
+                    levelSpacing:(CGFloat)levelSpacing
+                 backgroundColor:(RCTUIColor *)backgroundColor
+                      lineHeight:(CGFloat)lineHeight
+{
+  CGFloat totalIndent = blockquoteIndentForDepth(currentDepth + 1, levelSpacing);
+  CGFloat padding = [_config blockquotePadding];
+
+  // Depth and background cover the whole box (incl. padding spacers) so the
+  // border and background render behind list content and the padding rows.
+  NSMutableDictionary *depthAttributes =
+      [NSMutableDictionary dictionaryWithObjectsAndKeys:@(currentDepth), BlockquoteDepthAttributeName, nil];
+  if (backgroundColor) {
+    depthAttributes[BlockquoteBackgroundColorAttributeName] = backgroundColor;
+  }
+  [output addAttributes:depthAttributes range:boxRange];
+
+  // List items bake the blockquote indent into their own paragraph style; only non-list content is stamped here.
+  [self enumerateNonListRangesIn:output
+                           range:innerRange
+                      usingBlock:^(NSRange nonListRange) {
+                        NSMutableParagraphStyle *paragraphStyle =
+                            getOrCreateParagraphStyle(output, nonListRange.location);
+                        paragraphStyle.firstLineHeadIndent = totalIndent;
+                        paragraphStyle.headIndent = totalIndent;
+                        if (padding > 0) {
+                          paragraphStyle.tailIndent = -padding;
+                        }
+                        [output addAttribute:NSParagraphStyleAttributeName value:paragraphStyle range:nonListRange];
+                        applyLineHeight(output, nonListRange, lineHeight);
+                        applyBaselineOffset(output, nonListRange);
+                      }];
+
+  if (padding > 0) {
+    [self applyTailIndent:-padding toListRangesIn:output range:innerRange];
+  }
+}
+
+- (void)applyTailIndent:(CGFloat)tailIndent toListRangesIn:(NSMutableAttributedString *)output range:(NSRange)range
+{
+  [output enumerateAttribute:ListDepthAttribute
+                     inRange:range
+                     options:0
+                  usingBlock:^(id value, NSRange listRange, BOOL *stop) {
+                    if (!value) {
+                      return;
+                    }
+                    [output enumerateAttribute:NSParagraphStyleAttributeName
+                                       inRange:listRange
+                                       options:0
+                                    usingBlock:^(NSParagraphStyle *style, NSRange styleRange, BOOL *innerStop) {
+                                      NSMutableParagraphStyle *mutableStyle =
+                                          style ? [style mutableCopy] : [[NSMutableParagraphStyle alloc] init];
+                                      mutableStyle.tailIndent = tailIndent;
+                                      [output addAttribute:NSParagraphStyleAttributeName
+                                                     value:mutableStyle
+                                                     range:styleRange];
+                                    }];
+                  }];
+}
+
+- (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
+  CGFloat padding = [_config blockquotePadding];
+  for (NSDictionary *info in nestedInfo) {
+    NSRange nestedRange = [info[kNestedInfoRangeKey] rangeValue];
+    NSInteger nestedDepth = [info[kNestedInfoDepthKey] integerValue];
+    CGFloat indent = blockquoteIndentForDepth(nestedDepth + 1, levelSpacing);
+
+    [output addAttribute:BlockquoteDepthAttributeName value:info[kNestedInfoDepthKey] range:nestedRange];
+
+    [self enumerateNonListRangesIn:output
+                             range:nestedRange
+                        usingBlock:^(NSRange nonListRange) {
+                          NSMutableParagraphStyle *style = getOrCreateParagraphStyle(output, nonListRange.location);
+                          style.firstLineHeadIndent = indent;
+                          style.headIndent = indent;
+                          style.tailIndent = padding > 0 ? -padding : 0;
+                          [output addAttribute:NSParagraphStyleAttributeName value:style range:nonListRange];
+                        }];
+  }
+}
+
+- (void)enumerateNonListRangesIn:(NSMutableAttributedString *)output
+                           range:(NSRange)range
+                      usingBlock:(void (^)(NSRange nonListRange))block
+{
+  // List items — and code blocks nested inside them (which carry a list-derived
+  // indent instead of ListDepthAttribute) — already bake the correct indent in.
+  NSMutableArray<NSValue *> *listRanges = [NSMutableArray array];
+  void (^collectRanges)(NSString *) = ^(NSString *attribute) {
+    [output enumerateAttribute:attribute
+                       inRange:range
+                       options:0
+                    usingBlock:^(id value, NSRange subRange, BOOL *stop) {
+                      if (value) {
+                        [listRanges addObject:[NSValue valueWithRange:subRange]];
+                      }
+                    }];
+  };
+  collectRanges(ListDepthAttribute);
+  collectRanges(CodeBlockIndentAttributeName);
+  collectRanges(BlockquoteSpacerAttributeName);
+  [listRanges sortUsingComparator:^NSComparisonResult(NSValue *a, NSValue *b) {
+    NSUInteger la = [a rangeValue].location;
+    NSUInteger lb = [b rangeValue].location;
+    return la < lb ? NSOrderedAscending : (la > lb ? NSOrderedDescending : NSOrderedSame);
+  }];
+
+  NSUInteger pos = range.location;
+  const NSUInteger end = NSMaxRange(range);
+  for (NSValue *val in listRanges) {
+    NSRange listRange = [val rangeValue];
+    if (pos < listRange.location) {
+      block(NSMakeRange(pos, listRange.location - pos));
+    }
+    pos = MAX(pos, NSMaxRange(listRange));
+  }
+  if (pos < end) {
+    block(NSMakeRange(pos, end - pos));
+  }
+}
+
+@end

package/ios/renderer/CodeBlockRenderer.h

@@ -0,0 +1,9 @@
+#pragma once
+#import "BaseRenderer.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface CodeBlockRenderer : BaseRenderer
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/renderer/CodeBlockRenderer.m

@@ -0,0 +1,99 @@
+#import "CodeBlockRenderer.h"
+#import "CodeBlockBackground.h"
+#import "ENRMCodeBlockContent.h"
+#import "LastElementUtils.h"
+#import "TiptapASTNode.h"
+#import "ParagraphStyleUtils.h"
+#import "RenderContext.h"
+#import "RendererFactory.h"
+#import "StyleConfig.h"
+
+@implementation CodeBlockRenderer
+
+- (id)takeContextSnapshot:(RenderContext *)context
+{
+  return [context snapshotScope];
+}
+
+- (void)renderNodeContent:(TiptapASTNode *)node
+                     into:(NSMutableAttributedString *)output
+                  context:(RenderContext *)context
+{
+  // In tight lists md4c emits raw Text siblings without paragraph wrappers,
+  // so the preceding content may not terminate with a newline.
+  if (output.length > 0 && ![output.string hasSuffix:@"\n"]) {
+    [output appendAttributedString:kNewlineAttributedString];
+  }
+
+  [context setBlockStyle:BlockTypeCodeBlock font:[_config codeBlockFont] color:[_config codeBlockColor] headingLevel:0];
+
+  CGFloat listIndent = context.accumulatedIndent;
+  CGFloat padding = [_config codeBlockPadding];
+  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
+  // apply only when positive
+  if (padding > 0) {
+    [output appendAttributedString:kNewlineAttributedString];
+    NSMutableParagraphStyle *topSpacerStyle = [context spacerStyleWithHeight:padding spacing:0];
+    topSpacerStyle.baseWritingDirection = NSWritingDirectionLeftToRight;
+    [output addAttribute:NSParagraphStyleAttributeName value:topSpacerStyle range:NSMakeRange(blockStart, 1)];
+  }
+
+  NSUInteger contentStart = output.length;
+  [_rendererFactory renderChildrenOfNode:node into:output context:context];
+
+  NSUInteger contentEnd = output.length;
+  if (contentEnd <= contentStart)
+    return;
+
+  NSRange contentRange = NSMakeRange(contentStart, contentEnd - contentStart);
+
+  ENRMApplyCodeBlockTextAttributes(output, contentRange, _config);
+
+  // Horizontal padding is paragraph indentation in this flavor; the shared
+  // helper already forced the LTR left-aligned base style.
+  NSMutableParagraphStyle *baseStyle = [getOrCreateParagraphStyle(output, contentStart) mutableCopy];
+  baseStyle.firstLineHeadIndent = padding + listIndent;
+  baseStyle.headIndent = padding + listIndent;
+  baseStyle.tailIndent = -padding;
+  [output addAttribute:NSParagraphStyleAttributeName value:baseStyle range:contentRange];
+
+  // Bottom Padding: Inserted as a spacer character inside the background area
+  // apply it only when positive
+  if (padding > 0) {
+    NSUInteger bottomPaddingStart = output.length;
+    [output appendAttributedString:kNewlineAttributedString];
+    NSMutableParagraphStyle *bottomPaddingStyle = [context spacerStyleWithHeight:padding spacing:0];
+    bottomPaddingStyle.baseWritingDirection = NSWritingDirectionLeftToRight;
+    [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];
+  if (listIndent > 0) {
+    [output addAttribute:CodeBlockIndentAttributeName value:@(listIndent) range:backgroundRange];
+  }
+
+  // Recovered by a tap for onCodeBlockPress (the AST node is gone after render).
+  NSString *codeBlockText = ENRMCodeBlockExtractCode(node) ?: @"";
+  [output addAttribute:@"codeBlockText" value:codeBlockText range:backgroundRange];
+  NSString *codeBlockLanguage = ENRMCodeBlockLanguage(node);
+  if (codeBlockLanguage) {
+    [output addAttribute:@"codeBlockLanguage" value:codeBlockLanguage range:backgroundRange];
+  }
+
+  // External Margin: Applied outside the background range
+  if (marginBottom > 0) {
+    applyBlockSpacingAfter(output, marginBottom);
+  }
+}
+
+@end

package/ios/renderer/CodeRenderer.h

@@ -0,0 +1,9 @@
+#pragma once
+#import "BaseRenderer.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface CodeRenderer : BaseRenderer
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/renderer/CodeRenderer.m

@@ -0,0 +1,69 @@
+#import "CodeRenderer.h"
+#import "CodeBackground.h"
+#import "ENRMUIKit.h"
+#import "FontUtils.h"
+#import "TiptapASTNode.h"
+#import "RenderContext.h"
+#import "RendererFactory.h"
+#import "StyleConfig.h"
+#import <React/RCTFont.h>
+
+@implementation CodeRenderer
+
+- (void)renderNodeContent:(TiptapASTNode *)node
+                     into:(NSMutableAttributedString *)output
+                  context:(RenderContext *)context
+{
+
+  BlockStyle *blockStyle = [context getBlockStyle];
+
+  RCTUIColor *codeColor = _config.codeColor;
+
+  UIFont *blockFont = cachedFontFromBlockStyle(blockStyle, context);
+
+  UIFontDescriptorSymbolicTraits traits = blockFont.fontDescriptor.symbolicTraits;
+  UIFontWeight weight = (traits & UIFontDescriptorTraitBold) ? UIFontWeightBold : UIFontWeightRegular;
+
+  CGFloat codeFontSize = _config.codeFontSize > 0 ? _config.codeFontSize : blockStyle.fontSize;
+
+  // Both sizes above are unscaled; apply the same multiplier as the surrounding block font.
+  CGFloat fontScale = context.allowFontScaling ? RCTFontSizeMultiplierWithMax(context.maxFontSizeMultiplier) : 1.0;
+
+  NSString *codeFontFamily = _config.codeFontFamily;
+  UIFont *codeFont;
+  if (codeFontFamily.length > 0) {
+    NSString *weightStr = (weight == UIFontWeightBold) ? @"bold" : nil;
+    codeFont = [RCTFont updateFont:nil
+                        withFamily:codeFontFamily
+                              size:@(codeFontSize)
+                            weight:weightStr
+                             style:nil
+                           variant:nil
+                   scaleMultiplier:fontScale];
+  } else {
+    codeFont = [UIFont monospacedSystemFontOfSize:codeFontSize * fontScale 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] = codeFont;
+    if (codeColor) {
+      codeAttributes[NSForegroundColorAttributeName] = codeColor;
+    }
+    codeAttributes[CodeAttributeName] = @YES;
+
+    // Store block line height directly for CodeBackground to use
+    codeAttributes[@"BlockLineHeight"] = @(UIFontLineHeight(blockFont));
+
+    [output setAttributes:codeAttributes range:range];
+  }
+}
+
+@end

package/ios/renderer/ENRMBlockquoteTextRenderer.h

@@ -0,0 +1,25 @@
+#pragma once
+#import <Foundation/Foundation.h>
+
+@class RenderContext;
+@class StyleConfig;
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ * Renders a GFM blockquote's own prose content - the nodes left after nested quotes, code blocks and
+ * other block segments have been split out - as blockquote text.
+ *
+ * It decorates a generic AttributedRenderer pass rather than owning the render envelope itself:
+ * -pushOnContext: enters the blockquote baseline block style (+depth) so text picks up the quote's
+ * font/color and paragraphs render tight (currentBlockType == Blockquote), matching the commonmark
+ * path; -postProcess: applies the quote's line height once the string is complete. It draws no
+ * border/background/padding - the ENRMBlockquoteContainerView draws the box.
+ */
+@interface ENRMBlockquoteTextRenderer : NSObject
+- (instancetype)initWithConfig:(StyleConfig *)config;
+- (void)pushOnContext:(RenderContext *)context;
+- (void)postProcess:(NSMutableAttributedString *)text;
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/renderer/ENRMBlockquoteTextRenderer.m

@@ -0,0 +1,48 @@
+#import "ENRMBlockquoteTextRenderer.h"
+#import "ParagraphStyleUtils.h"
+#import "RenderContext.h"
+#import "StyleConfig.h"
+
+@implementation ENRMBlockquoteTextRenderer {
+  StyleConfig *_config;
+}
+
+- (instancetype)initWithConfig:(StyleConfig *)config
+{
+  self = [super init];
+  if (self) {
+    _config = config;
+  }
+  return self;
+}
+
+- (void)pushOnContext:(RenderContext *)context
+{
+  // Only set the blockquote baseline block style (tight paragraphs + the quote's font/color).
+  // Unlike the commonmark inline path we do NOT bump blockquoteDepth: the ENRMBlockquoteContainerView
+  // already insets its content by the quote's border/gap/padding, so bumping it here would make
+  // ListItemRenderer add a second blockquoteIndentForDepth on top and over-indent nested lists.
+  [context setBlockStyle:BlockTypeBlockquote font:_config.blockquoteFont color:_config.blockquoteColor headingLevel:0];
+}
+
+- (void)postProcess:(NSMutableAttributedString *)text
+{
+  // Stamp the quote's line height per paragraph. applyLineHeight copies the paragraph style at the
+  // range start over the whole range, so applying it across the entire run would overwrite every
+  // paragraph with the first one's style - wiping each list item's firstLineHeadIndent/headIndent
+  // (the marker draws from a separate attribute, so it would then land on top of un-indented text).
+  CGFloat lineHeight = [_config blockquoteLineHeight];
+  if (text.length == 0 || lineHeight <= 0) {
+    return;
+  }
+  NSString *string = text.string;
+  NSUInteger location = 0;
+  while (location < text.length) {
+    NSRange paragraph = [string paragraphRangeForRange:NSMakeRange(location, 0)];
+    applyLineHeight(text, paragraph, lineHeight);
+    applyBaselineOffset(text, paragraph);
+    location = NSMaxRange(paragraph);
+  }
+}
+
+@end

package/ios/renderer/EmphasisRenderer.h

@@ -0,0 +1,5 @@
+#pragma once
+#import "BaseRenderer.h"
+
+@interface EmphasisRenderer : BaseRenderer
+@end

package/ios/renderer/EmphasisRenderer.m

@@ -0,0 +1,100 @@
+#import "EmphasisRenderer.h"
+#import "FontUtils.h"
+#import "TiptapASTNode.h"
+#import "RenderContext.h"
+#import "RendererFactory.h"
+#import "StyleConfig.h"
+#import <React/RCTFont.h>
+
+@implementation EmphasisRenderer
+
+#pragma mark - Rendering
+
+- (void)renderNodeContent:(TiptapASTNode *)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 *configEmphasisColor = [_config emphasisColor];
+  NSString *emphasisFontFamily = [_config emphasisFontFamily];
+  NSString *emphasisFontStyle = [_config emphasisFontStyle];
+  BOOL useNormalStyle = [emphasisFontStyle isEqualToString:@"normal"];
+
+  // Cache the Strong color calculation to efficiently detect nested Strong nodes
+  RCTUIColor *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) {
+                            UIFont *currentFont =
+                                attrs[NSFontAttributeName] ?: cachedFontFromBlockStyle(blockStyle, context);
+                            UIFont *resolvedFont = nil;
+
+                            if (emphasisFontFamily.length > 0) {
+                              resolvedFont = [RCTFont updateFont:currentFont
+                                                      withFamily:emphasisFontFamily
+                                                            size:nil
+                                                          weight:nil
+                                                           style:useNormalStyle ? nil : @"italic"
+                                                         variant:nil
+                                                 scaleMultiplier:1.0];
+                            } else if (currentFont &&
+                                       !(currentFont.fontDescriptor.symbolicTraits & UIFontDescriptorTraitItalic)) {
+                              resolvedFont = [self ensureFontIsItalic:currentFont];
+                            }
+
+                            if (resolvedFont && ![resolvedFont isEqual:currentFont]) {
+                              [output addAttribute:NSFontAttributeName value:resolvedFont range:subrange];
+                            }
+
+                            // 2. Color Optimization: Handle nesting and avoid redundant updates
+                            if (configEmphasisColor) {
+                              RCTUIColor *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/FactoidRenderer.h

@@ -0,0 +1,9 @@
+#pragma once
+#import "BaseRenderer.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface FactoidRenderer : BaseRenderer
+@end
+
+NS_ASSUME_NONNULL_END