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

package/ios/renderer/RenderContext.h

@@ -0,0 +1,145 @@
+#import "ENRMLatexErrorReporting.h"
+#import "ENRMUIKit.h"
+#import <Foundation/Foundation.h>
+
+typedef NS_ENUM(NSInteger, BlockType) {
+  BlockTypeNone,
+  BlockTypeParagraph,
+  BlockTypeHeading,
+  BlockTypeBlockquote,
+  BlockTypeUnorderedList,
+  BlockTypeOrderedList,
+  BlockTypeCodeBlock
+};
+
+/// YES when the enclosing block re-stamps its own line height over paragraph content and applies the
+/// matching baseline offset itself, so a paragraph nested inside it must not apply its own (the outer
+/// block's line height wins, and applyBaselineOffset skips ranges that already carry an offset).
+/// TODO: loose list items have the same shape (ParagraphRenderer runs, then the list re-stamps its
+/// line height); add BlockTypeUnorderedList/BlockTypeOrderedList here once lists own their offset too.
+static inline BOOL ENRMBlockTypeReappliesBaselineOffset(BlockType type)
+{
+  return type == BlockTypeBlockquote;
+}
+
+typedef NS_ENUM(NSInteger, ListType) { ListTypeUnordered, ListTypeOrdered };
+
+@interface BlockStyle : NSObject
+@property (nonatomic, assign) CGFloat fontSize;
+@property (nonatomic, strong) NSString *fontFamily;
+@property (nonatomic, strong) NSString *fontWeight;
+@property (nonatomic, strong) RCTUIColor *color;
+@property (nonatomic, strong) UIFont *cachedFont;
+@property (nonatomic, strong) NSDictionary *cachedTextAttributes;
+@end
+
+@interface RenderContext : NSObject
+@property (nonatomic, strong) NSMutableArray<NSValue *> *linkRanges;
+@property (nonatomic, strong) NSMutableArray<NSString *> *linkURLs;
+@property (nonatomic, strong) NSMutableArray<NSValue *> *headingRanges;
+@property (nonatomic, strong) NSMutableArray<NSNumber *> *headingLevels;
+@property (nonatomic, strong) NSMutableArray<NSValue *> *imageRanges;
+@property (nonatomic, strong) NSMutableArray<NSString *> *imageAltTexts;
+@property (nonatomic, strong) NSMutableArray<NSString *> *imageURLs;
+@property (nonatomic, strong) NSMutableArray<NSValue *> *listItemRanges;
+@property (nonatomic, strong) NSMutableArray<NSNumber *> *listItemPositions; // Position in parent list (1, 2, 3...)
+@property (nonatomic, strong) NSMutableArray<NSNumber *> *listItemDepths;  // Nesting depth (1 = top level, 2+ = nested)
+@property (nonatomic, strong) NSMutableArray<NSNumber *> *listItemOrdered; // YES = ordered, NO = unordered (bullet)
+@property (nonatomic, assign) BlockType currentBlockType;
+@property (nonatomic, strong) BlockStyle *currentBlockStyle;
+@property (nonatomic, assign) NSInteger currentHeadingLevel;
+@property (nonatomic, assign) NSInteger blockquoteDepth;
+@property (nonatomic, assign) NSInteger listDepth;
+@property (nonatomic, assign) ListType listType;
+@property (nonatomic, assign) NSInteger listItemNumber;
+@property (nonatomic, assign) CGFloat listMarkerWidth;
+@property (nonatomic, assign) CGFloat listMarkerExtra;
+@property (nonatomic, assign) CGFloat ancestorMarkerOffset;
+@property (nonatomic, assign) CGFloat listItemMarkerExtra;
+@property (nonatomic, assign) CGFloat accumulatedIndent;
+@property (nonatomic, assign) BOOL allowFontScaling;
+@property (nonatomic, assign) CGFloat maxFontSizeMultiplier;
+@property (nonatomic, assign) NSInteger taskItemCount;
+@property (nonatomic, strong) NSMutableArray<id<ENRMLatexErrorReporting>> *mathReporters;
+
+- (instancetype)init;
+- (void)reset;
+
+- (UIFont *)cachedFontForSize:(CGFloat)fontSize family:(NSString *)fontFamily weight:(NSString *)fontWeight;
+- (NSMutableParagraphStyle *)spacerStyleWithHeight:(CGFloat)height spacing:(CGFloat)spacing;
+- (NSMutableParagraphStyle *)blockSpacerStyleWithMargin:(CGFloat)margin;
+- (void)registerLinkRange:(NSRange)range url:(NSString *)url;
+
+- (void)applyLinkAttributesToString:(NSMutableAttributedString *)attributedString;
+- (void)applyImageAttributesToString:(NSMutableAttributedString *)attributedString;
+- (void)registerHeadingRange:(NSRange)range level:(NSInteger)level text:(NSString *)text;
+- (void)registerImageRange:(NSRange)range altText:(NSString *)altText url:(NSString *)url;
+- (void)registerListItemRange:(NSRange)range
+                     position:(NSInteger)position
+                        depth:(NSInteger)depth
+                    isOrdered:(BOOL)isOrdered;
+- (void)setBlockStyle:(BlockType)type
+             fontSize:(CGFloat)fontSize
+           fontFamily:(NSString *)fontFamily
+           fontWeight:(NSString *)fontWeight
+                color:(RCTUIColor *)color;
+- (void)setBlockStyle:(BlockType)type
+             fontSize:(CGFloat)fontSize
+           fontFamily:(NSString *)fontFamily
+           fontWeight:(NSString *)fontWeight
+                color:(RCTUIColor *)color
+         headingLevel:(NSInteger)headingLevel;
+- (void)setBlockStyle:(BlockType)type
+                 font:(UIFont *)font
+                color:(RCTUIColor *)color
+         headingLevel:(NSInteger)headingLevel;
+- (BlockStyle *)getBlockStyle;
+- (NSDictionary *)getTextAttributes;
+- (void)clearBlockStyle;
+
+/**
+ * Captures/restores the scoped context state: block style, block type, heading level,
+ * blockquote/list depths, list type, list item counter and accumulated indent.
+ * Accumulators (range registries, taskItemCount) are excluded on purpose — they
+ * must survive restores.
+ */
+- (id)snapshotScope;
+- (void)restoreScope:(id)snapshot;
+
+/**
+ * Checks if colors should be preserved based on existing attributes.
+ * Returns YES if the text is inside a link or inline code, which means
+ * we should preserve their colors instead of applying new colors.
+ */
++ (BOOL)shouldPreserveColors:(NSDictionary *)existingAttributes;
+
+/**
+ * Calculates the color that strong would use based on the configured strong color and block style.
+ * Uses strongColor if explicitly set (different from block color), otherwise uses block color.
+ */
++ (RCTUIColor *)calculateStrongColor:(RCTUIColor *)configStrongColor blockColor:(RCTUIColor *)blockColor;
+
+/**
+ * Resolves highlight foreground color: uses block color when config matches paragraph default.
+ */
++ (RCTUIColor *)calculateHighlightColor:(RCTUIColor *)configHighlightColor
+                         paragraphColor:(RCTUIColor *)paragraphColor
+                             blockColor:(RCTUIColor *)blockColor;
+
+/**
+ * Calculates the range for content rendered between start and current output length.
+ * Returns a range with length 0 if no content was rendered.
+ */
++ (NSRange)rangeForRenderedContent:(NSMutableAttributedString *)output start:(NSUInteger)start;
+
+/**
+ * Applies font and color attributes conditionally, only updating if they've changed.
+ * Returns YES if any attributes were updated, NO otherwise.
+ */
++ (BOOL)applyFontAndColorAttributes:(NSMutableAttributedString *)output
+                              range:(NSRange)range
+                               font:(UIFont *)font
+                              color:(RCTUIColor *)color
+                 existingAttributes:(NSDictionary *)existingAttributes
+               shouldPreserveColors:(BOOL)shouldPreserveColors;
+@end

package/ios/renderer/RenderContext.m

@@ -0,0 +1,403 @@
+#import "RenderContext.h"
+#import "CodeBackground.h"
+#import "FontUtils.h"
+#import <React/RCTFont.h>
+
+@implementation BlockStyle
+@end
+
+static NSArray<NSString *> *ENRMScopedKeyPaths(void)
+{
+  static NSArray<NSString *> *keyPaths;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    keyPaths = @[
+      @"currentBlockType",
+      @"currentHeadingLevel",
+      @"currentBlockStyle.fontSize",
+      @"currentBlockStyle.fontFamily",
+      @"currentBlockStyle.fontWeight",
+      @"currentBlockStyle.color",
+      @"currentBlockStyle.cachedFont",
+      @"currentBlockStyle.cachedTextAttributes",
+      @"blockquoteDepth",
+      @"listDepth",
+      @"listType",
+      @"listItemNumber",
+      @"listMarkerWidth",
+      @"listMarkerExtra",
+      @"ancestorMarkerOffset",
+      @"listItemMarkerExtra",
+      @"accumulatedIndent",
+    ];
+  });
+  return keyPaths;
+}
+
+@implementation RenderContext {
+  NSMutableDictionary<NSString *, UIFont *> *_fontCache;
+  NSParagraphStyle *_baseSpacerTemplate;
+  NSParagraphStyle *_baseBlockSpacerTemplate;
+}
+
+- (instancetype)init
+{
+  if (self = [super init]) {
+    _linkRanges = [NSMutableArray array];
+    _linkURLs = [NSMutableArray array];
+    _headingRanges = [NSMutableArray array];
+    _headingLevels = [NSMutableArray array];
+    _imageRanges = [NSMutableArray array];
+    _imageAltTexts = [NSMutableArray array];
+    _imageURLs = [NSMutableArray array];
+    _listItemRanges = [NSMutableArray array];
+    _listItemPositions = [NSMutableArray array];
+    _listItemDepths = [NSMutableArray array];
+    _listItemOrdered = [NSMutableArray array];
+    _mathReporters = [NSMutableArray array];
+    _fontCache = [NSMutableDictionary dictionary];
+    _currentBlockStyle = [[BlockStyle alloc] init];
+    _allowFontScaling = YES;
+    _maxFontSizeMultiplier = 0;
+
+    NSMutableParagraphStyle *spacerTemplate = [[NSMutableParagraphStyle alloc] init];
+    _baseSpacerTemplate = [spacerTemplate copy];
+
+    NSMutableParagraphStyle *blockSpacerTemplate = [[NSMutableParagraphStyle alloc] init];
+    blockSpacerTemplate.minimumLineHeight = 1;
+    blockSpacerTemplate.maximumLineHeight = 1;
+    _baseBlockSpacerTemplate = [blockSpacerTemplate copy];
+
+    [self reset];
+  }
+  return self;
+}
+
+#pragma mark - Font Cache
+
+- (UIFont *)cachedFontForSize:(CGFloat)fontSize family:(NSString *)fontFamily weight:(NSString *)fontWeight
+{
+  CGFloat effectiveMultiplier = _allowFontScaling ? RCTFontSizeMultiplierWithMax(_maxFontSizeMultiplier) : 1.0;
+
+  NSString *weightKey = (fontWeight.length > 0) ? fontWeight : @"";
+  NSString *key =
+      [NSString stringWithFormat:@"%.1f|%@|%@|%.2f", fontSize, fontFamily ?: @"", weightKey, effectiveMultiplier];
+
+  UIFont *cached = _fontCache[key];
+  if (cached) {
+    return cached;
+  }
+
+  NSString *effectiveWeight = (fontWeight.length > 0) ? fontWeight : nil;
+
+  UIFont *font = [RCTFont updateFont:nil
+                          withFamily:fontFamily
+                                size:@(fontSize)
+                              weight:effectiveWeight
+                               style:nil
+                             variant:nil
+                     scaleMultiplier:effectiveMultiplier];
+
+  if (font) {
+    _fontCache[key] = font;
+  }
+  return font;
+}
+
+#pragma mark - Paragraph Style Factory
+
+- (NSMutableParagraphStyle *)spacerStyleWithHeight:(CGFloat)height spacing:(CGFloat)spacing
+{
+  NSMutableParagraphStyle *style = [_baseSpacerTemplate mutableCopy];
+  style.minimumLineHeight = height;
+  style.maximumLineHeight = height;
+  style.paragraphSpacing = spacing;
+  return style;
+}
+
+- (NSMutableParagraphStyle *)blockSpacerStyleWithMargin:(CGFloat)margin
+{
+  NSMutableParagraphStyle *style = [_baseBlockSpacerTemplate mutableCopy];
+  style.paragraphSpacing = margin;
+  return style;
+}
+
+#pragma mark - Link Registry
+
+- (void)registerLinkRange:(NSRange)range url:(NSString *)url
+{
+  if (range.length == 0)
+    return;
+  [self.linkRanges addObject:[NSValue valueWithRange:range]];
+  [self.linkURLs addObject:url ?: @""];
+}
+
+- (void)applyLinkAttributesToString:(NSMutableAttributedString *)attributedString
+{
+  NSUInteger length = attributedString.length;
+  for (NSUInteger i = 0; i < self.linkRanges.count; i++) {
+    NSRange range = [self.linkRanges[i] rangeValue];
+    if (NSMaxRange(range) > length)
+      continue;
+    [attributedString addAttribute:@"linkURL" value:self.linkURLs[i] range:range];
+  }
+}
+
+- (void)applyImageAttributesToString:(NSMutableAttributedString *)attributedString
+{
+  NSUInteger length = attributedString.length;
+  for (NSUInteger i = 0; i < self.imageRanges.count; i++) {
+    NSRange range = [self.imageRanges[i] rangeValue];
+    if (NSMaxRange(range) > length)
+      continue;
+    [attributedString addAttribute:@"imageURL" value:self.imageURLs[i] range:range];
+    [attributedString addAttribute:@"imageAltText" value:self.imageAltTexts[i] range:range];
+  }
+}
+
+- (void)registerHeadingRange:(NSRange)range level:(NSInteger)level text:(NSString *)text
+{
+  if (range.length == 0)
+    return;
+  [self.headingRanges addObject:[NSValue valueWithRange:range]];
+  [self.headingLevels addObject:@(level)];
+}
+
+- (void)registerImageRange:(NSRange)range altText:(NSString *)altText url:(NSString *)url
+{
+  if (range.length == 0)
+    return;
+  [self.imageRanges addObject:[NSValue valueWithRange:range]];
+  [self.imageAltTexts addObject:altText ?: @""];
+  [self.imageURLs addObject:url ?: @""];
+}
+
+#pragma mark - Registration Helpers
+
+- (void)registerListItemRange:(NSRange)range
+                     position:(NSInteger)position
+                        depth:(NSInteger)depth
+                    isOrdered:(BOOL)isOrdered
+{
+  if (![self isValidRange:range])
+    return;
+
+  [self.listItemRanges addObject:[NSValue valueWithRange:range]];
+  [self.listItemPositions addObject:@(position)];
+  [self.listItemDepths addObject:@(depth)];
+  [self.listItemOrdered addObject:@(isOrdered)];
+}
+
+#pragma mark - Private
+
+- (BOOL)isValidRange:(NSRange)range
+{
+  return range.length > 0 && range.location != NSNotFound;
+}
+
+#pragma mark - Block Style Management
+
+/**
+ * Updates the shared BlockStyle object with new traits.
+ * This avoids allocating a new object for every block node in the AST.
+ */
+- (void)setBlockStyle:(BlockType)type
+             fontSize:(CGFloat)fontSize
+           fontFamily:(NSString *)fontFamily
+           fontWeight:(NSString *)fontWeight
+                color:(RCTUIColor *)color
+         headingLevel:(NSInteger)headingLevel
+{
+  _currentBlockType = type;
+  _currentHeadingLevel = headingLevel;
+
+  _currentBlockStyle.fontSize = fontSize;
+  _currentBlockStyle.fontFamily = fontFamily ?: @"";
+  _currentBlockStyle.fontWeight = fontWeight ?: @"normal";
+  _currentBlockStyle.color = color ?: [RCTUIColor blackColor];
+}
+
+- (void)setBlockStyle:(BlockType)type
+             fontSize:(CGFloat)fontSize
+           fontFamily:(NSString *)fontFamily
+           fontWeight:(NSString *)fontWeight
+                color:(RCTUIColor *)color
+{
+  [self setBlockStyle:type fontSize:fontSize fontFamily:fontFamily fontWeight:fontWeight color:color headingLevel:0];
+}
+
+- (void)setBlockStyle:(BlockType)type font:(UIFont *)font color:(RCTUIColor *)color headingLevel:(NSInteger)headingLevel
+{
+  _currentBlockType = type;
+  _currentHeadingLevel = headingLevel;
+
+  RCTUIColor *finalColor = color ?: [RCTUIColor blackColor];
+  _currentBlockStyle.cachedFont = font;
+  _currentBlockStyle.color = finalColor;
+
+  // Pre-create text attributes dictionary if we have both font and color
+  if (font) {
+    _currentBlockStyle.cachedTextAttributes =
+        @{NSFontAttributeName : font, NSForegroundColorAttributeName : finalColor};
+  }
+}
+
+- (BlockStyle *)getBlockStyle
+{
+  return _currentBlockStyle;
+}
+
+- (NSDictionary *)getTextAttributes
+{
+  BlockStyle *style = _currentBlockStyle;
+
+  // Return pre-cached attributes if available
+  if (style.cachedTextAttributes) {
+    return style.cachedTextAttributes;
+  }
+
+  // Fall back to creating attributes from font cache
+  UIFont *font = style.cachedFont;
+  if (!font) {
+    font = [self cachedFontForSize:style.fontSize family:style.fontFamily weight:style.fontWeight];
+  }
+  RCTUIColor *color = style.color ?: [RCTUIColor blackColor];
+
+  // Cache for future calls within same block
+  style.cachedTextAttributes = @{NSFontAttributeName : font, NSForegroundColorAttributeName : color};
+  return style.cachedTextAttributes;
+}
+
+- (void)clearBlockStyle
+{
+  _currentBlockType = BlockTypeNone;
+  _currentHeadingLevel = 0;
+  _currentBlockStyle.cachedFont = nil;
+  _currentBlockStyle.cachedTextAttributes = nil;
+}
+
+- (id)snapshotScope
+{
+  NSArray<NSString *> *keyPaths = ENRMScopedKeyPaths();
+  NSMutableDictionary *snapshot = [NSMutableDictionary dictionaryWithCapacity:keyPaths.count];
+  for (NSString *keyPath in keyPaths) {
+    snapshot[keyPath] = [self valueForKeyPath:keyPath] ?: [NSNull null];
+  }
+  return snapshot;
+}
+
+- (void)restoreScope:(id)snapshot
+{
+  NSDictionary *frame = snapshot;
+  for (NSString *keyPath in ENRMScopedKeyPaths()) {
+    id value = frame[keyPath];
+    [self setValue:(value == [NSNull null] ? nil : value) forKeyPath:keyPath];
+  }
+}
+
+#pragma mark - Reset
+
+- (void)reset
+{
+  [_linkRanges removeAllObjects];
+  [_linkURLs removeAllObjects];
+  [_headingRanges removeAllObjects];
+  [_headingLevels removeAllObjects];
+  [_imageRanges removeAllObjects];
+  [_imageAltTexts removeAllObjects];
+  [_imageURLs removeAllObjects];
+  [_listItemRanges removeAllObjects];
+  [_listItemPositions removeAllObjects];
+  [_listItemDepths removeAllObjects];
+  [_listItemOrdered removeAllObjects];
+  [_mathReporters removeAllObjects];
+  [self clearBlockStyle];
+
+  _blockquoteDepth = 0;
+  _listDepth = 0;
+  _listType = ListTypeUnordered;
+  _listItemNumber = 0;
+  _listMarkerWidth = 0;
+  _listMarkerExtra = 0;
+  _ancestorMarkerOffset = 0;
+  _listItemMarkerExtra = 0;
+  _accumulatedIndent = 0;
+  _taskItemCount = 0;
+
+  // Revert shared style object to baseline defaults
+  _currentBlockStyle.fontSize = 0;
+  _currentBlockStyle.fontFamily = @"";
+  _currentBlockStyle.fontWeight = @"";
+  _currentBlockStyle.color = [RCTUIColor blackColor];
+}
+
+#pragma mark - Static Utilities
+
+/**
+ * Determines if specific inline attributes should protect the current color.
+ */
++ (BOOL)shouldPreserveColors:(NSDictionary *)attrs
+{
+  return (attrs[NSLinkAttributeName] != nil || attrs[CodeAttributeName] != nil);
+}
+
+// TODO: Unify calculateStrongColor and calculateHighlightColor into a single helper that
+// resolves inline foreground color from (configColor, inheritanceBaseline, blockColor).
+
+/**
+ * Calculates whether a strong color should override the block color.
+ */
++ (RCTUIColor *)calculateStrongColor:(RCTUIColor *)configStrongColor blockColor:(RCTUIColor *)blockColor
+{
+  if (!configStrongColor || [configStrongColor isEqual:blockColor]) {
+    return blockColor;
+  }
+  return configStrongColor;
+}
+
++ (RCTUIColor *)calculateHighlightColor:(RCTUIColor *)configHighlightColor
+                         paragraphColor:(RCTUIColor *)paragraphColor
+                             blockColor:(RCTUIColor *)blockColor
+{
+  if ([configHighlightColor isEqual:paragraphColor]) {
+    return blockColor;
+  }
+  return configHighlightColor;
+}
+
+/**
+ * Safely calculates a range based on a start point and the current output length.
+ */
++ (NSRange)rangeForRenderedContent:(NSMutableAttributedString *)output start:(NSUInteger)start
+{
+  if (output.length < start)
+    return NSMakeRange(start, 0);
+  return NSMakeRange(start, output.length - start);
+}
+
+/**
+ * Surgically applies attributes only if they differ from current values.
+ * This minimizes "dirtying" the AttributedString, which improves layout performance.
+ */
++ (void)applyFontAndColorAttributes:(NSMutableAttributedString *)output
+                              range:(NSRange)range
+                               font:(UIFont *)font
+                              color:(RCTUIColor *)color
+                 existingAttributes:(NSDictionary *)attrs
+               shouldPreserveColors:(BOOL)shouldPreserve
+{
+  if (range.length == 0)
+    return;
+
+  // Font Update: Only if it exists and is different
+  if (font && ![font isEqual:attrs[NSFontAttributeName]]) {
+    [output addAttribute:NSFontAttributeName value:font range:range];
+  }
+
+  // Color Update: Only if not a link/code and different from existing
+  if (color && !shouldPreserve && ![color isEqual:attrs[NSForegroundColorAttributeName]]) {
+    [output addAttribute:NSForegroundColorAttributeName value:color range:range];
+  }
+}
+
+@end

package/ios/renderer/RendererFactory.h

@@ -0,0 +1,12 @@
+#import "TiptapASTNode.h"
+#import "NodeRenderer.h"
+
+@class RenderContext;
+
+@interface RendererFactory : NSObject
+- (instancetype)initWithConfig:(id)config;
+- (id<NodeRenderer>)rendererForNodeType:(TiptapNodeType)type;
+- (void)renderChildrenOfNode:(TiptapASTNode *)node
+                        into:(NSMutableAttributedString *)output
+                     context:(RenderContext *)context;
+@end