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

package/ios/utils/ENRMLinkRegexProps.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#import "ENRMLinkRegexConfig.h"
+
+#ifdef __cplusplus
+// Props share EnrichedTiptapTextInput's native regex transport.
+template <typename RegexProps> static inline ENRMLinkRegexConfig *ENRMLinkRegexConfigFromProps(const RegexProps &props)
+{
+  if (props.isDisabled || props.isDefault || props.pattern.empty())
+    return nil;
+  return [ENRMLinkRegexConfig cachedConfigWithPattern:[NSString stringWithUTF8String:props.pattern.c_str()]
+                                      caseInsensitive:props.caseInsensitive
+                                               dotAll:props.dotAll];
+}
+
+template <typename RegexProps>
+static inline BOOL ENRMLinkRegexPropsEqual(const RegexProps &oldProps, const RegexProps &newProps)
+{
+  return oldProps.isDisabled == newProps.isDisabled && oldProps.isDefault == newProps.isDefault &&
+         oldProps.caseInsensitive == newProps.caseInsensitive && oldProps.dotAll == newProps.dotAll &&
+         oldProps.pattern == newProps.pattern;
+}
+#endif

package/ios/utils/ENRMLocalImageLoader.h

@@ -0,0 +1,35 @@
+#pragma once
+#import "ENRMUIKit.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ * Local (non-network) image loading for tiptap sources (issue #377).
+ *
+ * React Native's asset system resolves `require('./img.png')` to a Metro http
+ * URL in dev, but to a `file://` URL near the app bundle in release builds
+ * (`AssetSourceResolver.scaledAssetURLNearBundle`), and libraries like
+ * expo-asset also hand out percent-encoded `file://` paths in the caches
+ * directory. These should not go through NSURLSession + NSURLCache: they gain
+ * nothing from HTTP caching or timeouts, and bundle assets lose `@2x`/`@3x`
+ * scale selection and asset-catalog resolution.
+ *
+ * Resolution mirrors RN's RCTImageFromLocalAssetURL: bundle-relative names are
+ * tried with `imageNamed:` first (scale suffixes, asset catalogs, and system
+ * caching for free), then the loader falls back to loading the file directly,
+ * appending `.png` when the path has no extension.
+ */
+
+/// YES when the URL refers to a non-network source: any `file://` URL, or a
+/// scheme-less string (bare bundle-relative asset name or absolute path).
+BOOL ENRMIsLocalImageURL(NSString *url);
+
+/// Resolves a local file or file-backed bundle asset, including scale suffixes.
+/// Does not decode pixels. Asset-catalog-only names have no file path and return nil.
+FOUNDATION_EXPORT NSString *_Nullable ENRMResolveLocalImagePath(NSString *url);
+
+/// Synchronously loads a local image; returns nil when the source cannot be
+/// resolved. Safe to call off the main thread.
+RCTUIImage *_Nullable ENRMLoadLocalImage(NSString *url);
+
+NS_ASSUME_NONNULL_END

package/ios/utils/ENRMLocalImageLoader.m

@@ -0,0 +1,111 @@
+#import "ENRMLocalImageLoader.h"
+
+static NSString *_Nullable ENRMBundleRelativePath(NSString *path)
+{
+  NSString *bundlePath = [[NSBundle mainBundle] resourcePath];
+  if (bundlePath == nil || ![path hasPrefix:bundlePath]) {
+    return nil;
+  }
+  NSString *relative = [path substringFromIndex:bundlePath.length];
+  return [relative hasPrefix:@"/"] ? [relative substringFromIndex:1] : relative;
+}
+
+static RCTUIImage *_Nullable ENRMImageNamed(NSString *name)
+{
+  return [RCTUIImage imageNamed:name];
+}
+
+static RCTUIImage *_Nullable ENRMImageAtPath(NSString *path)
+{
+  if (path.pathExtension.length == 0) {
+    path = [path stringByAppendingPathExtension:@"png"];
+  }
+#if !TARGET_OS_OSX
+  return [RCTUIImage imageWithContentsOfFile:path];
+#else
+  return [[RCTUIImage alloc] initWithContentsOfFile:path];
+#endif
+}
+
+BOOL ENRMIsLocalImageURL(NSString *url)
+{
+  if ([url hasPrefix:@"file://"]) {
+    return YES;
+  }
+  NSURL *parsed = [NSURL URLWithString:url];
+  return parsed == nil || parsed.scheme.length == 0;
+}
+
+static NSDictionary<NSString *, NSString *> *ENRMLocalImageSourcePaths(NSString *url)
+{
+  NSString *filePath = nil;
+  NSString *imageName = nil;
+
+  if ([url hasPrefix:@"file://"]) {
+    NSURL *fileURL = [NSURL URLWithString:url];
+    if (fileURL.fileURL) {
+      filePath = @(fileURL.fileSystemRepresentation);
+    } else {
+      NSString *stripped = [url substringFromIndex:@"file://".length];
+      filePath = [stripped stringByRemovingPercentEncoding] ?: stripped;
+    }
+    imageName = ENRMBundleRelativePath(filePath);
+  } else {
+    NSString *decoded = [url stringByRemovingPercentEncoding] ?: url;
+    if (decoded.absolutePath) {
+      filePath = decoded;
+    } else {
+      imageName = decoded;
+      filePath = [[[NSBundle mainBundle] resourcePath] stringByAppendingPathComponent:decoded];
+    }
+  }
+
+  return @{@"filePath" : filePath ?: @"", @"imageName" : imageName ?: @""};
+}
+
+NSString *_Nullable ENRMResolveLocalImagePath(NSString *url)
+{
+  if (url.length == 0 || !ENRMIsLocalImageURL(url))
+    return nil;
+  NSDictionary *paths = ENRMLocalImageSourcePaths(url);
+  NSString *path = paths[@"filePath"];
+  if (path.length == 0)
+    return nil;
+  if (path.pathExtension.length == 0)
+    path = [path stringByAppendingPathExtension:@"png"];
+  NSMutableArray<NSString *> *candidates = [NSMutableArray new];
+  if ([paths[@"imageName"] length] > 0) {
+    NSString *stem = path.stringByDeletingPathExtension;
+    if (![stem hasSuffix:@"@2x"] && ![stem hasSuffix:@"@3x"]) {
+#if !TARGET_OS_OSX
+      NSInteger scale = MAX(1, MIN(3, (NSInteger)UIScreen.mainScreen.scale));
+#else
+      NSInteger scale = MAX(1, MIN(3, (NSInteger)NSScreen.mainScreen.backingScaleFactor));
+#endif
+      for (NSNumber *candidateScale in @[ @(scale), @3, @2 ]) {
+        if (candidateScale.integerValue > 1)
+          [candidates addObject:[[stem stringByAppendingFormat:@"@%@x", candidateScale]
+                                    stringByAppendingPathExtension:path.pathExtension]];
+      }
+    }
+  }
+  [candidates addObject:path];
+  for (NSString *candidate in candidates) {
+    BOOL directory = NO;
+    if ([NSFileManager.defaultManager fileExistsAtPath:candidate isDirectory:&directory] && !directory)
+      return [candidate stringByResolvingSymlinksInPath];
+  }
+  return nil;
+}
+
+RCTUIImage *_Nullable ENRMLoadLocalImage(NSString *url)
+{
+  NSDictionary *paths = ENRMLocalImageSourcePaths(url);
+  NSString *filePath = paths[@"filePath"];
+  NSString *imageName = paths[@"imageName"];
+  RCTUIImage *image = imageName.length > 0 ? ENRMImageNamed(imageName) : nil;
+  if (image == nil && filePath.length > 0) {
+    image = ENRMImageAtPath(ENRMResolveLocalImagePath(url) ?: filePath);
+  }
+  return image;
+}

package/ios/utils/ENRMMenuAction.h

@@ -0,0 +1,27 @@
+#pragma once
+#include <TargetConditionals.h>
+
+#if TARGET_OS_OSX
+#import <AppKit/AppKit.h>
+
+// NSMenuItem uses target/action with no block-based API, so we use a lightweight
+// action object as the target. NSMenuItem.target is a WEAK reference (AppKit does
+// not retain it), so we also store the action object in representedObject (strong)
+// to tie its lifetime to the menu item.
+@interface ENRMMenuAction : NSObject
+- (instancetype)initWithBlock:(void (^)(void))block;
+- (BOOL)validateMenuItem:(NSMenuItem *)menuItem;
+- (void)performAction:(id)sender;
+@end
+
+/// Creates an NSMenuItem whose action fires a block.
+static inline NSMenuItem *ENRMCreateMenuItem(NSString *title, void (^action)(void))
+{
+  ENRMMenuAction *actionObject = [[ENRMMenuAction alloc] initWithBlock:action];
+  NSMenuItem *item = [[NSMenuItem alloc] initWithTitle:title action:@selector(performAction:) keyEquivalent:@""];
+  item.target = actionObject;
+  item.representedObject = actionObject;
+  return item;
+}
+
+#endif // TARGET_OS_OSX

package/ios/utils/ENRMMenuAction.m

@@ -0,0 +1,33 @@
+#include <TargetConditionals.h>
+
+#if TARGET_OS_OSX
+#import "ENRMMenuAction.h"
+
+@implementation ENRMMenuAction {
+  void (^_block)(void);
+}
+
+- (instancetype)initWithBlock:(void (^)(void))block
+{
+  self = [super init];
+  if (self) {
+    _block = [block copy];
+  }
+  return self;
+}
+
+- (BOOL)validateMenuItem:(NSMenuItem *)menuItem
+{
+  return YES;
+}
+
+- (void)performAction:(id)sender
+{
+  if (_block) {
+    _block();
+  }
+}
+
+@end
+
+#endif // TARGET_OS_OSX

package/ios/utils/ENRMSpoilerOverlayManager.h

@@ -0,0 +1,15 @@
+#import <Foundation/Foundation.h>
+
+typedef NS_ENUM(NSInteger, ENRMSpoilerOverlayMode) {
+  ENRMSpoilerOverlayModeNone = 0,
+};
+
+ENRMSpoilerOverlayMode ENRMSpoilerOverlayFromString(NSString *mode);
+
+@interface ENRMSpoilerOverlayManager : NSObject
+@property (nonatomic, assign) ENRMSpoilerOverlayMode spoilerOverlay;
+- (instancetype)initWithTextView:(id)textView config:(id)config;
+- (void)setNeedsUpdate;
+- (void)updateIfNeeded;
+- (void)removeAllOverlays;
+@end

package/ios/utils/ENRMSpoilerOverlayManager.m

@@ -0,0 +1,19 @@
+#import "ENRMSpoilerOverlayManager.h"
+
+ENRMSpoilerOverlayMode ENRMSpoilerOverlayFromString(NSString *mode)
+{
+  (void)mode;
+  return ENRMSpoilerOverlayModeNone;
+}
+
+@implementation ENRMSpoilerOverlayManager
+- (instancetype)initWithTextView:(id)textView config:(id)config
+{
+  (void)textView;
+  (void)config;
+  return [super init];
+}
+- (void)setNeedsUpdate {}
+- (void)updateIfNeeded {}
+- (void)removeAllOverlays {}
+@end

package/ios/utils/ENRMSpoilerTapUtils.h

@@ -0,0 +1,6 @@
+#import <Foundation/Foundation.h>
+
+// Spoilers are not rendered. The attribute name stays so link hit-testing compiles.
+extern NSString *const SpoilerAttributeName;
+
+BOOL handleSpoilerTap(id textView, id recognizer, id manager);

package/ios/utils/ENRMSpoilerTapUtils.m

@@ -0,0 +1,11 @@
+#import "ENRMSpoilerTapUtils.h"
+
+NSString *const SpoilerAttributeName = @"Spoiler";
+
+BOOL handleSpoilerTap(id textView, id recognizer, id manager)
+{
+  (void)textView;
+  (void)recognizer;
+  (void)manager;
+  return NO;
+}

package/ios/utils/ENRMTailFadeInAnimator.h

@@ -0,0 +1,16 @@
+#pragma once
+#import "ENRMUIKit.h"
+#import "LinkTapUtils.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface ENRMTailFadeInAnimator : NSObject
+
+- (instancetype)initWithTextView:(ENRMPlatformTextView *)textView;
+
+- (void)animateFrom:(NSUInteger)tailStart to:(NSUInteger)tailEnd;
+- (void)cancel;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/utils/ENRMTailFadeInAnimator.m

@@ -0,0 +1,161 @@
+#import "ENRMTailFadeInAnimator.h"
+#import "LinkTapUtils.h"
+#import <QuartzCore/QuartzCore.h>
+#include <TargetConditionals.h>
+
+static const NSTimeInterval kFadeDuration = 0.20;
+
+typedef struct {
+  NSRange range;
+  __unsafe_unretained RCTUIColor *color;
+} ENRMColorEntry;
+
+@implementation ENRMTailFadeInAnimator {
+  __weak ENRMPlatformTextView *_textView;
+#if !TARGET_OS_OSX
+  CADisplayLink *_displayLink;
+#endif
+  CFTimeInterval _startTime;
+
+  NSArray<RCTUIColor *> *_retainedColors;
+  ENRMColorEntry *_colorEntries;
+  NSUInteger _entriesCount;
+}
+
+- (instancetype)initWithTextView:(ENRMPlatformTextView *)textView
+{
+  self = [super init];
+  if (self) {
+    _textView = textView;
+  }
+  return self;
+}
+
+- (void)dealloc
+{
+#if !TARGET_OS_OSX
+  [_displayLink invalidate];
+  _displayLink = nil;
+#endif
+  [self cleanupEntries];
+}
+
+- (void)animateFrom:(NSUInteger)tailStart to:(NSUInteger)tailEnd
+{
+  [self cancel];
+
+  NSTextStorage *storage = _textView.textStorage;
+  if (!storage || tailEnd <= tailStart || tailEnd > storage.length)
+    return;
+
+#if !TARGET_OS_OSX
+  if (UIAccessibilityIsReduceMotionEnabled()) {
+    return;
+  }
+#endif
+
+  NSRange range = NSMakeRange(tailStart, tailEnd - tailStart);
+
+  [self snapshotColorsInRange:range storage:storage];
+  [self updateAlpha:0.0];
+
+#if !TARGET_OS_OSX
+  _startTime = CACurrentMediaTime();
+  _displayLink = [CADisplayLink displayLinkWithTarget:self selector:@selector(step:)];
+  // 0 tells the system to use the display's maximum frame rate — 60 Hz on standard displays and 120 Hz on ProMotion ones
+  _displayLink.preferredFramesPerSecond = 0;
+  [_displayLink addToRunLoop:[NSRunLoop mainRunLoop] forMode:NSRunLoopCommonModes];
+#else
+  // TODO: Implement the tail fade-in animation on macOS.
+  // CADisplayLink doesn't exist on macOS; the equivalent is CVDisplayLink (Core Video)
+  // or an NSTimer driven at the display refresh rate. The iOS step:/eased-progress
+  // logic below can be reused directly once a display-sync callback is wired up.
+  // TODO: When this is implemented, gate it on
+  // NSWorkspace.sharedWorkspace.accessibilityDisplayShouldReduceMotion so macOS
+  // users with Reduce Motion enabled also skip the fade.
+  [self updateAlpha:1.0];
+  [self cleanupEntries];
+#endif
+}
+
+#if !TARGET_OS_OSX
+- (void)step:(CADisplayLink *)link
+{
+  CFTimeInterval elapsed = CACurrentMediaTime() - _startTime;
+  CGFloat progress = fmin(elapsed / kFadeDuration, 1.0);
+
+  CGFloat eased = 1.0 - (1.0 - progress) * (1.0 - progress);
+
+  [self updateAlpha:eased];
+
+  if (progress >= 1.0) {
+    [self cancel];
+  }
+}
+#endif
+
+- (void)updateAlpha:(CGFloat)alpha
+{
+  NSTextStorage *storage = _textView.textStorage;
+  if (!storage || _entriesCount == 0)
+    return;
+
+  [storage beginEditing];
+  for (NSUInteger i = 0; i < _entriesCount; i++) {
+    ENRMColorEntry entry = _colorEntries[i];
+    if (NSMaxRange(entry.range) <= storage.length) {
+      RCTUIColor *fadedColor = [entry.color colorWithAlphaComponent:alpha];
+      [storage addAttribute:NSForegroundColorAttributeName value:fadedColor range:entry.range];
+    }
+  }
+  [storage endEditing];
+}
+
+- (void)snapshotColorsInRange:(NSRange)range storage:(NSTextStorage *)storage
+{
+  [self cleanupEntries];
+
+  NSMutableArray<RCTUIColor *> *colors = [NSMutableArray array];
+  NSMutableArray<NSValue *> *ranges = [NSMutableArray array];
+  [storage enumerateAttribute:NSForegroundColorAttributeName
+                      inRange:range
+                      options:0
+                   usingBlock:^(RCTUIColor *color, NSRange subRange, BOOL *stop) {
+                     [colors addObject:color ?: [RCTUIColor labelColor]];
+                     [ranges addObject:[NSValue valueWithRange:subRange]];
+                   }];
+
+  _entriesCount = colors.count;
+  _retainedColors = [colors copy];
+  _colorEntries = malloc(sizeof(ENRMColorEntry) * _entriesCount);
+
+  for (NSUInteger i = 0; i < _entriesCount; i++) {
+    _colorEntries[i].color = _retainedColors[i];
+    _colorEntries[i].range = [ranges[i] rangeValue];
+  }
+}
+
+- (void)cancel
+{
+#if !TARGET_OS_OSX
+  [_displayLink invalidate];
+  _displayLink = nil;
+#endif
+
+  if (_entriesCount > 0) {
+    [self updateAlpha:1.0];
+    [self cleanupEntries];
+  }
+}
+
+- (void)cleanupEntries
+{
+  if (_colorEntries) {
+    free(_colorEntries);
+    _colorEntries = NULL;
+  }
+  _retainedColors = nil;
+  _entriesCount = 0;
+}
+
+@end

package/ios/utils/ENRMTextHitTest.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#import "ENRMUIKit.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/// Returns the character index in textView's text storage corresponding to
+/// the tap location, or NSNotFound if the point falls outside the text.
+NSUInteger ENRMCharacterIndexForTap(ENRMPlatformTextView *textView, ENRMTapRecognizer *recognizer);
+
+/// Returns the character index in textView's text storage corresponding to
+/// the given point (in textView coordinates), or NSNotFound if out of range.
+NSUInteger ENRMCharacterIndexAtPoint(ENRMPlatformTextView *textView, CGPoint point);
+
+#ifdef __cplusplus
+}
+#endif
+
+NS_ASSUME_NONNULL_END

package/ios/utils/ENRMTextHitTest.m

@@ -0,0 +1,20 @@
+#import "ENRMTextHitTest.h"
+
+NSUInteger ENRMCharacterIndexAtPoint(ENRMPlatformTextView *textView, CGPoint point)
+{
+  NSLayoutManager *layoutManager = textView.layoutManager;
+  CGPoint adjusted = CGPointMake(point.x - textView.textContainerInset.left, point.y - textView.textContainerInset.top);
+
+  NSUInteger index = [layoutManager characterIndexForPoint:adjusted
+                                           inTextContainer:textView.textContainer
+                  fractionOfDistanceBetweenInsertionPoints:NULL];
+
+  NSUInteger length = ENRMGetAttributedText(textView).length;
+  return index < length ? index : NSNotFound;
+}
+
+NSUInteger ENRMCharacterIndexForTap(ENRMPlatformTextView *textView, ENRMTapRecognizer *recognizer)
+{
+  CGPoint location = [recognizer locationInView:textView];
+  return ENRMCharacterIndexAtPoint(textView, location);
+}

package/ios/utils/ENRMTextInteractionUtils.h

@@ -0,0 +1,20 @@
+#pragma once
+#import "ENRMUIKit.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/// Resolves the link URL at the tap location.
+/// If a link is found, calls onLinkPress and returns YES.
+/// If no link is found, calls ENRMClearSelection and returns NO.
+BOOL ENRMHandleTapOnTextView(ENRMPlatformTextView *textView, ENRMTapRecognizer *recognizer,
+                             void (^onLinkPress)(NSString *url));
+
+#ifdef __cplusplus
+}
+#endif
+
+NS_ASSUME_NONNULL_END

package/ios/utils/ENRMTextInteractionUtils.m

@@ -0,0 +1,15 @@
+#import "ENRMTextInteractionUtils.h"
+#import "LinkTapUtils.h"
+
+BOOL ENRMHandleTapOnTextView(ENRMPlatformTextView *textView, ENRMTapRecognizer *recognizer,
+                             void (^onLinkPress)(NSString *url))
+{
+  NSString *url = linkURLAtTapLocation(textView, recognizer);
+  if (!url) {
+    ENRMClearSelection(textView);
+    return NO;
+  }
+  if (onLinkPress)
+    onLinkPress(url);
+  return YES;
+}

package/ios/utils/ENRMTextRenderer.h

@@ -0,0 +1,38 @@
+#pragma once
+#import <Foundation/Foundation.h>
+
+@class AccessibilityInfo;
+@class TiptapASTNode;
+@class RenderContext;
+@class StyleConfig;
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface ENRMRenderResult : NSObject
+@property (nonatomic, strong) NSMutableAttributedString *attributedText;
+@property (nonatomic, strong) RenderContext *context;
+@property (nonatomic, strong) AccessibilityInfo *accessibilityInfo;
+@property (nonatomic, assign) CGFloat lastElementMarginBottom;
+@end
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+ENRMRenderResult *ENRMRenderASTNodes(NSArray<TiptapASTNode *> *nodes, StyleConfig *config, BOOL allowTrailingMargin,
+                                     BOOL allowFontScaling, CGFloat maxFontSizeMultiplier,
+                                     NSLineBreakStrategy lineBreakStrategy);
+
+// Renders a blockquote's own text content: like ENRMRenderASTNodes but with a blockquote baseline
+// (tight paragraphs, quote font/color) and the quote's line height applied over the result. Draws
+// no box - the ENRMBlockquoteContainerView draws the border/background/padding. Mirrors Android's
+// BlockquoteTextRenderer.
+ENRMRenderResult *ENRMRenderBlockquoteContentNodes(NSArray<TiptapASTNode *> *nodes, StyleConfig *config,
+                                                   BOOL allowFontScaling, CGFloat maxFontSizeMultiplier,
+                                                   NSLineBreakStrategy lineBreakStrategy);
+
+#ifdef __cplusplus
+}
+#endif
+
+NS_ASSUME_NONNULL_END

package/ios/utils/ENRMTextRenderer.m

@@ -0,0 +1,54 @@
+#import "ENRMTextRenderer.h"
+#import "AccessibilityInfo.h"
+#import "AttributedRenderer.h"
+#import "ENRMBlockquoteTextRenderer.h"
+#import "ParagraphStyleUtils.h"
+#import "RenderContext.h"
+#import "StyleConfig.h"
+
+@implementation ENRMRenderResult
+@end
+
+static ENRMRenderResult *ENRMRenderASTNodesCore(NSArray<TiptapASTNode *> *nodes, StyleConfig *config,
+                                                BOOL allowTrailingMargin, BOOL allowFontScaling,
+                                                CGFloat maxFontSizeMultiplier, NSLineBreakStrategy lineBreakStrategy,
+                                                ENRMBlockquoteTextRenderer *block)
+{
+  AttributedRenderer *renderer = [[AttributedRenderer alloc] initWithConfig:config];
+  [renderer setAllowTrailingMargin:allowTrailingMargin];
+
+  RenderContext *context = [RenderContext new];
+  context.allowFontScaling = allowFontScaling;
+  context.maxFontSizeMultiplier = maxFontSizeMultiplier;
+
+  NSMutableAttributedString *attributedText = [renderer renderNodes:nodes context:context block:block];
+
+  [context applyLinkAttributesToString:attributedText];
+  [context applyImageAttributesToString:attributedText];
+  ENRMApplyLineBreakStrategyToParagraphStyles(attributedText, lineBreakStrategy);
+  ENRMPinLineMetricsToStyledFonts(attributedText, NSMakeRange(0, attributedText.length));
+
+  ENRMRenderResult *result = [[ENRMRenderResult alloc] init];
+  result.attributedText = attributedText;
+  result.context = context;
+  result.accessibilityInfo = [AccessibilityInfo infoFromContext:context];
+  result.lastElementMarginBottom = [renderer getLastElementMarginBottom];
+  return result;
+}
+
+ENRMRenderResult *ENRMRenderASTNodes(NSArray<TiptapASTNode *> *nodes, StyleConfig *config, BOOL allowTrailingMargin,
+                                     BOOL allowFontScaling, CGFloat maxFontSizeMultiplier,
+                                     NSLineBreakStrategy lineBreakStrategy)
+{
+  return ENRMRenderASTNodesCore(nodes, config, allowTrailingMargin, allowFontScaling, maxFontSizeMultiplier,
+                                lineBreakStrategy, /*block*/ nil);
+}
+
+ENRMRenderResult *ENRMRenderBlockquoteContentNodes(NSArray<TiptapASTNode *> *nodes, StyleConfig *config,
+                                                   BOOL allowFontScaling, CGFloat maxFontSizeMultiplier,
+                                                   NSLineBreakStrategy lineBreakStrategy)
+{
+  ENRMBlockquoteTextRenderer *block = [[ENRMBlockquoteTextRenderer alloc] initWithConfig:config];
+  return ENRMRenderASTNodesCore(nodes, config, /*allowTrailingMargin*/ NO, allowFontScaling, maxFontSizeMultiplier,
+                                lineBreakStrategy, block);
+}