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

package/ios/attachments/ENRMMathInlineAttachment.m

@@ -0,0 +1,4 @@
+#import "ENRMMathInlineAttachment.h"
+
+@implementation ENRMMathInlineAttachment
+@end

package/ios/attachments/ThematicBreakAttachment.h

@@ -0,0 +1,15 @@
+#pragma once
+#import "ENRMUIKit.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface ThematicBreakAttachment : NSTextAttachment
+
+@property (nonatomic, strong) RCTUIColor *lineColor;
+@property (nonatomic, assign) CGFloat lineHeight;
+@property (nonatomic, assign) CGFloat marginTop;
+@property (nonatomic, assign) CGFloat marginBottom;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/attachments/ThematicBreakAttachment.m

@@ -0,0 +1,33 @@
+#import "ThematicBreakAttachment.h"
+
+@implementation ThematicBreakAttachment
+
+- (CGRect)attachmentBoundsForTextContainer:(NSTextContainer *)textContainer
+                      proposedLineFragment:(CGRect)lineFrag
+                             glyphPosition:(CGPoint)position
+                            characterIndex:(NSUInteger)charIndex
+{
+  CGFloat totalHeight = self.marginTop + self.lineHeight + self.marginBottom;
+  return CGRectMake(0, 0, CGRectGetWidth(lineFrag), totalHeight);
+}
+
+- (RCTUIImage *)imageForBounds:(CGRect)imageBounds
+                 textContainer:(NSTextContainer *)textContainer
+                characterIndex:(NSUInteger)charIndex
+{
+  RCTUIGraphicsImageRenderer *renderer = [[RCTUIGraphicsImageRenderer alloc] initWithSize:imageBounds.size];
+
+  return [renderer imageWithActions:^(RCTUIGraphicsImageRendererContext *_Nonnull rendererContext) {
+    CGContextRef ctx = rendererContext.CGContext;
+
+    CGFloat lineY = self.marginTop + (self.lineHeight / 2.0);
+
+    [self.lineColor setStroke];
+    CGContextSetLineWidth(ctx, self.lineHeight);
+    CGContextMoveToPoint(ctx, 0, lineY);
+    CGContextAddLineToPoint(ctx, imageBounds.size.width, lineY);
+    CGContextStrokePath(ctx);
+  }];
+}
+
+@end

package/ios/internals/ENRMViewFreeMeasurement.h

@@ -0,0 +1,208 @@
+#pragma once
+
+#import "ENRMFeatureFlags.h"
+#import "ENRMLinkRegexProps.h"
+#import "ENRMTiptapParser.h"
+#import "ENRMTextRenderer.h"
+#import "ENRMTextViewSetup.h"
+#import "ImageRequestHeaderUtils.h"
+#import "LinkPillContentUtils.h"
+#import "TiptapASTNode.h"
+#import "ParagraphStyleUtils.h"
+#import "StylePropsUtils.h"
+#include <type_traits>
+
+/**
+ * View-free tiptap measurement (issue #550).
+ *
+ * The previous measurement path built throwaway component views on the main
+ * thread via `dispatch_sync` — a deadlock when `measureContent` runs under
+ * RN's locked commit fallback while a main-thread committer (Reanimated) is
+ * blocked on the same mutex, and a serialization bottleneck (streaming jank)
+ * even when it doesn't deadlock.
+ *
+ * These pipelines measure on the calling thread with no view and no
+ * main-thread dependency, mirroring RN core's `RCTTextLayoutManager` (which
+ * measures every `<Text>` this way in production) and this library's own
+ * Android `MeasurementStore`:
+ *
+ * - `ENRMMeasureTiptapViewFree` (EnrichedTiptapText): parse (md4c) →
+ *   `ENRMRenderASTNodes` (the SAME renderer the visible view uses, so
+ *   measured layout ≡ rendered layout) → a fresh per-call
+ *   NSTextStorage/NSLayoutManager/NSTextContainer stack → shared finalize.
+ * - `ENRMMeasureSegmentedTiptapViewFree` (EnrichedTiptap): the iOS
+ *   counterpart of Android's `MeasurementStore.measureAndCacheSplit` — split
+ *   the AST into segments via the same `ENRMRenderSegmentsFromAST` the view
+ *   uses, then walk them exactly like the view's
+ *   `computeSegmentLayoutForWidth:`: text via the TextKit stack, tables via
+ *   `+[TableContainerView measureHeightForTableNode:…]`, math via
+ *   `+[ENRMMathContainerView measureHeightForLatex:…]`, with the same
+ *   margin arithmetic.
+ *
+ * TextKit objects are thread-CONFINED, not main-thread-only: safe off main as
+ * long as one thread owns a given stack (Apple-sanctioned; the
+ * Texture/AsyncDisplayKit pattern). Allocating the stack per call — exactly
+ * what `RCTTextLayoutManager` does — makes confinement trivially true.
+ * `boundingRectWithSize:` (tables, math fallback) is documented thread-safe.
+ *
+ * Ambient-state rules for this path:
+ * - Font scale comes in as a parameter (from `LayoutContext::fontSizeMultiplier`),
+ *   never from `RCTFontSizeMultiplier()` (UIKit read).
+ * - Pixel rounding uses `LayoutContext::pointScaleFactor`, never
+ *   `RCTScreenScale()` (dispatch_syncs to main on first use).
+ * - The resolved layout direction comes from `LayoutConstraints::layoutDirection`,
+ *   never from `RCTI18nUtil`.
+ * - The geometry config must match the visible view's
+ *   (`ENRMConfigureTiptapTextView`): zero insets, `lineFragmentPadding = 0`,
+ *   `allowsNonContiguousLayout = NO`. The view's custom `TextViewLayoutManager`
+ *   subclass only draws backgrounds and does not affect geometry.
+ * - Each entry point drains its own `@autoreleasepool`. The calling JS/layout
+ *   thread has no runloop draining pools, and a full measure autoreleases
+ *   thousands of objects (AST, attributed string, TextKit stack, fonts) — the
+ *   old main-thread path silently leaned on the main runloop's per-cycle
+ *   drain, and without a local pool sustained re-measurement accumulates
+ *   until jetsam kills the app.
+ *
+ * RaTeX concurrency (math segments and lazily-measured inline math
+ * attachments now parse on the calling thread, possibly concurrently with the
+ * render thread): verified safe against RaTeX sources. The Swift engine is
+ * stateless per call, font registration is NSLock-guarded and idempotent
+ * (RaTeXFontLoader), the FFI's last-error slot is thread_local, the Rust
+ * core's only statics are immutable OnceLock/LazyLock tables, and renderer
+ * font caches are per-call locals.
+ */
+
+template <typename Md4cFlagsT> static inline ENRMMd4cFlags *ENRMMd4cFlagsFromProps(const Md4cFlagsT &props)
+{
+  ENRMMd4cFlags *flags = [ENRMMd4cFlags defaultFlags];
+  flags.underline = props.underline;
+  flags.superscript = props.superscript;
+  flags.subscript = props.subscript;
+  flags.latexMath = props.latexMath;
+  flags.highlight = props.highlight;
+  flags.hardSoftBreaks = props.hardSoftBreaks;
+  flags.preserveBlankLines = props.preserveBlankLines;
+  flags.admonitions = props.admonitions;
+  return flags;
+}
+
+/**
+ * Builds a StyleConfig from props alone, replicating the mock-view recipe
+ * field for field: a fresh config receives the props' style diffed against a
+ * default-constructed style struct (the mock view's `updateProps
+ * oldProps:nullptr` applied the same diff against default props), then the
+ * font scale, max multiplier, and image request headers.
+ */
+template <typename PropsT>
+static inline StyleConfig *ENRMStyleConfigFromProps(const PropsT &typedProps, CGFloat fontScale)
+{
+  StyleConfig *config = [[StyleConfig alloc] init];
+  using StyleT = std::remove_cv_t<std::remove_reference_t<decltype(typedProps.tiptapStyle)>>;
+  static const StyleT kDefaultStyle{};
+  applyTiptapStyleToConfig(config, typedProps.tiptapStyle, kDefaultStyle);
+  [config setFontScaleMultiplier:fontScale];
+  [config setMaxFontSizeMultiplier:typedProps.maxFontSizeMultiplier];
+  [config setImageRequestHeaders:ENRMImageRequestHeadersFromProps(typedProps.imageRequestHeaders)];
+  [config setLinkPillContent:ENRMLinkPillContentFromProps(typedProps.linkPillContent)];
+  return config;
+}
+
+/**
+ * Lays out an already-rendered attributed string in a fresh, call-confined
+ * TextKit stack and finalizes with the shared algorithm
+ * (`ENRMFinalizeMeasuredTextSize`). Returns CGSizeZero for empty text — the
+ * same result the view path produces, and a guard against TextKit's
+ * empty-string layout freeze (see RCTTextLayoutManager).
+ *
+ * Uses the same `usesFontLeading` as the views that draw the text; see
+ * ENRMLayoutManagerUsesFontLeading.
+ */
+static inline CGSize ENRMMeasureAttributedTextViewFree(NSAttributedString *text, CGFloat maxWidth, StyleConfig *config,
+                                                       BOOL allowTrailingMargin, CGFloat lastElementMarginBottom,
+                                                       CGFloat pointScaleFactor, NSInteger numberOfLines,
+                                                       NSLineBreakMode lineBreakMode, BOOL subtractExtraLineFragment)
+{
+  if (text.length == 0) {
+    return CGSizeZero;
+  }
+
+  NSTextContainer *textContainer = [[NSTextContainer alloc] initWithSize:CGSizeMake(maxWidth, CGFLOAT_MAX)];
+  textContainer.lineFragmentPadding = 0;
+  if (numberOfLines > 0) {
+    textContainer.maximumNumberOfLines = numberOfLines;
+    textContainer.lineBreakMode = lineBreakMode;
+  }
+  NSLayoutManager *layoutManager = [[NSLayoutManager alloc] init];
+  layoutManager.allowsNonContiguousLayout = NO;
+  layoutManager.usesFontLeading = ENRMLayoutManagerUsesFontLeading;
+  [layoutManager addTextContainer:textContainer];
+  NSTextStorage *textStorage = [[NSTextStorage alloc] initWithAttributedString:text];
+  [textStorage addLayoutManager:layoutManager];
+
+  [layoutManager ensureLayoutForTextContainer:textContainer];
+  ENRMTextLayoutResult layout;
+  layout.usedRect = [layoutManager usedRectForTextContainer:textContainer];
+  layout.extraLineFragmentRect = layoutManager.extraLineFragmentRect;
+
+  return ENRMFinalizeMeasuredTextSize(layout, layoutManager, maxWidth, config, allowTrailingMargin,
+                                      lastElementMarginBottom, subtractExtraLineFragment, pointScaleFactor);
+}
+
+/**
+ * Measures EnrichedTiptapText content from props alone, on the calling
+ * thread. The line-break strategy and writing-direction mode are resolved
+ * from the props exactly as `updateProps:` resolves them. Falls back to
+ * (maxWidth × system-16 line height) for empty tiptap, parse failures, and
+ * empty render output — the same fallback `measureSize:` produced.
+ */
+template <typename PropsT>
+static inline CGSize ENRMMeasureTiptapViewFree(const PropsT &typedProps, CGFloat maxWidth, CGFloat fontScale,
+                                                 CGFloat pointScaleFactor, NSWritingDirection resolvedLayoutDirection)
+{
+  @autoreleasepool {
+    CGSize fallback = CGSizeMake(maxWidth, UIFontLineHeight([UIFont systemFontOfSize:16.0]));
+    if (typedProps.document.empty()) {
+      return fallback;
+    }
+
+    NSString *tiptap = [[NSString alloc] initWithUTF8String:typedProps.document.c_str()];
+    StyleConfig *config = ENRMStyleConfigFromProps(typedProps, fontScale);
+
+    ENRMMd4cFlags *flags = ENRMMd4cFlagsFromProps(typedProps.md4cFlags);
+    ENRMTiptapParser *parser = [[ENRMTiptapParser alloc] init];
+    TiptapASTNode *ast = [parser parseTiptap:tiptap
+                                           flags:flags
+                                           isGFM:typedProps.isGFM
+                                       linkRegex:ENRMLinkRegexConfigFromProps(typedProps.linkRecognition.text)
+                             inlineCodeLinkRegex:ENRMLinkRegexConfigFromProps(typedProps.linkRecognition.inlineCode)];
+    if (!ast) {
+      return fallback;
+    }
+
+    NSLineBreakStrategy lineBreakStrategy =
+        ENRMResolveLineBreakStrategy([[NSString alloc] initWithUTF8String:typedProps.lineBreakStrategyIOS.c_str()]);
+    ENRMRenderResult *result =
+        ENRMRenderASTNodes(ast.children, config, typedProps.allowTrailingMargin, typedProps.allowFontScaling,
+                           typedProps.maxFontSizeMultiplier, lineBreakStrategy);
+    NSMutableAttributedString *text = result.attributedText;
+    if (text.length == 0) {
+      return fallback;
+    }
+
+    ENRMWritingDirectionMode writingDirectionMode =
+        ENRMResolveWritingDirectionMode([[NSString alloc] initWithUTF8String:typedProps.writingDirection.c_str()]);
+    ENRMApplyWritingDirectionMode(text, writingDirectionMode, resolvedLayoutDirection);
+
+    NSInteger numberOfLines = (NSInteger)typedProps.numberOfLines;
+    NSLineBreakMode lineBreakMode =
+        ENRMResolveEllipsizeLineBreakMode([[NSString alloc] initWithUTF8String:typedProps.ellipsizeMode.c_str()]);
+    CGSize size = ENRMMeasureAttributedTextViewFree(text, maxWidth, config, typedProps.allowTrailingMargin,
+                                                    result.lastElementMarginBottom, pointScaleFactor, numberOfLines,
+                                                    lineBreakMode, YES);
+    if (size.height == 0) {
+      return fallback;
+    }
+    return size;
+  }
+}
+

package/ios/internals/EnrichedTiptapTextComponentDescriptor.h

@@ -0,0 +1,19 @@
+#pragma once
+#include "EnrichedTiptapTextShadowNode.h"
+#include <react/debug/react_native_assert.h>
+#include <react/renderer/core/ConcreteComponentDescriptor.h>
+
+namespace facebook::react {
+
+class EnrichedTiptapTextComponentDescriptor final
+    : public ConcreteComponentDescriptor<EnrichedTiptapTextShadowNode> {
+public:
+  using ConcreteComponentDescriptor::ConcreteComponentDescriptor;
+
+  void adopt(ShadowNode &shadowNode) const override {
+    react_native_assert(dynamic_cast<EnrichedTiptapTextShadowNode *>(&shadowNode));
+    ConcreteComponentDescriptor::adopt(shadowNode);
+  }
+};
+
+} // namespace facebook::react

package/ios/internals/EnrichedTiptapTextShadowNode.h

@@ -0,0 +1,43 @@
+#pragma once
+#include "MeasurementCache.h"
+#include <ReactNativeRenderRichText/EnrichedTiptapTextState.h>
+#include <ReactNativeRenderRichText/EventEmitters.h>
+#include <ReactNativeRenderRichText/Props.h>
+#include <react/renderer/components/view/ConcreteViewShadowNode.h>
+#include <react/renderer/core/LayoutConstraints.h>
+
+namespace facebook::react {
+
+JSI_EXPORT extern const char EnrichedTiptapTextComponentName[];
+
+/// ShadowNode implementing measureContent for automatic height calculation.
+class EnrichedTiptapTextShadowNode
+    : public ConcreteViewShadowNode<EnrichedTiptapTextComponentName, EnrichedTiptapTextProps,
+                                    EnrichedTiptapTextEventEmitter, EnrichedTiptapTextState> {
+public:
+  using ConcreteViewShadowNode::ConcreteViewShadowNode;
+
+  EnrichedTiptapTextShadowNode(const ShadowNodeFragment &fragment, const ShadowNodeFamily::Shared &family,
+                                 ShadowNodeTraits traits);
+
+  EnrichedTiptapTextShadowNode(const ShadowNode &sourceShadowNode, const ShadowNodeFragment &fragment);
+
+  void dirtyLayoutIfNeeded();
+
+  Size measureContent(const LayoutContext &layoutContext, const LayoutConstraints &layoutConstraints) const override;
+
+  static ShadowNodeTraits BaseTraits()
+  {
+    auto traits = ConcreteViewShadowNode::BaseTraits();
+    traits.set(ShadowNodeTraits::Trait::LeafYogaNode);
+    traits.set(ShadowNodeTraits::Trait::MeasurableYogaNode);
+    return traits;
+  }
+
+private:
+  int localHeightRecalculationCounter_{0};
+  mutable int lastExactMeasurementCounter_{0};
+  mutable CGSize lastExactMeasurementSize_{0, 0};
+};
+
+} // namespace facebook::react

package/ios/internals/EnrichedTiptapTextShadowNode.mm

@@ -0,0 +1,69 @@
+#import "EnrichedTiptapTextShadowNode.h"
+#import "ENRMViewFreeMeasurement.h"
+#import "EnrichedTiptapText.h"
+#import "ShadowMeasurementUtils.h"
+#import <yoga/Yoga.h>
+
+namespace facebook::react {
+
+extern const char EnrichedTiptapTextComponentName[] = "EnrichedTiptapText";
+
+EnrichedTiptapTextShadowNode::EnrichedTiptapTextShadowNode(const ShadowNodeFragment &fragment,
+                                                               const ShadowNodeFamily::Shared &family,
+                                                               ShadowNodeTraits traits)
+    : ConcreteViewShadowNode(fragment, family, traits)
+{
+}
+
+EnrichedTiptapTextShadowNode::EnrichedTiptapTextShadowNode(const ShadowNode &sourceShadowNode,
+                                                               const ShadowNodeFragment &fragment)
+    : ConcreteViewShadowNode(sourceShadowNode, fragment),
+      localHeightRecalculationCounter_(
+          static_cast<const EnrichedTiptapTextShadowNode &>(sourceShadowNode).localHeightRecalculationCounter_),
+      lastExactMeasurementCounter_(
+          static_cast<const EnrichedTiptapTextShadowNode &>(sourceShadowNode).lastExactMeasurementCounter_),
+      lastExactMeasurementSize_(
+          static_cast<const EnrichedTiptapTextShadowNode &>(sourceShadowNode).lastExactMeasurementSize_)
+{
+  const auto &oldProps = *std::static_pointer_cast<const EnrichedTiptapTextProps>(sourceShadowNode.getProps());
+  const auto &newProps = *std::static_pointer_cast<const EnrichedTiptapTextProps>(this->getProps());
+
+  if (newProps.streamingAnimation && ENRMPropsNeedExactStreamingMeasurement(oldProps, newProps)) {
+    lastExactMeasurementCounter_ = -1;
+  }
+
+  dirtyLayoutIfNeeded();
+}
+
+void EnrichedTiptapTextShadowNode::dirtyLayoutIfNeeded()
+{
+  const auto state = this->getStateData();
+  const int receivedCounter = state.getHeightRecalculationCounter();
+
+  if (receivedCounter > localHeightRecalculationCounter_) {
+    localHeightRecalculationCounter_ = receivedCounter;
+    YGNodeMarkDirty(&yogaNode_);
+  }
+}
+
+Size EnrichedTiptapTextShadowNode::measureContent(const LayoutContext &layoutContext,
+                                                    const LayoutConstraints &layoutConstraints) const
+{
+  const auto propsHandle = std::static_pointer_cast<const EnrichedTiptapTextProps>(this->getProps());
+  const auto &typedProps = *propsHandle;
+  const int receivedCounter = getStateData().getHeightRecalculationCounter();
+  const EnrichedTiptapTextProps *props = propsHandle.get();
+  CGFloat pointScaleFactor = layoutContext.pointScaleFactor;
+  NSWritingDirection resolvedLayoutDirection = layoutConstraints.layoutDirection == LayoutDirection::RightToLeft
+                                                   ? NSWritingDirectionRightToLeft
+                                                   : NSWritingDirectionLeftToRight;
+
+  return ENRMMeasureTiptapContent<EnrichedTiptapTextProps, EnrichedTiptapText>(
+      typedProps, getStateData().getComponentViewRef(), receivedCounter, lastExactMeasurementCounter_,
+      lastExactMeasurementSize_, TiptapFlavor::CommonMark, layoutContext, layoutConstraints,
+      ^(EnrichedTiptapText *view, CGFloat maxWidth, CGFloat fontScale) {
+        return ENRMMeasureTiptapViewFree(*props, maxWidth, fontScale, pointScaleFactor, resolvedLayoutDirection);
+      });
+}
+
+} // namespace facebook::react

package/ios/internals/EnrichedTiptapTextState.h

@@ -0,0 +1,24 @@
+#pragma once
+#include <memory>
+
+namespace facebook::react {
+
+/// Counter triggers layout recalculation, viewRef allows shadow node to access view for measurement.
+class EnrichedTiptapTextState {
+public:
+  EnrichedTiptapTextState() = default;
+  EnrichedTiptapTextState(int counter, std::shared_ptr<void> ref) : counter_(counter), viewRef_(ref) {}
+
+  int getHeightRecalculationCounter() const {
+    return counter_;
+  }
+  std::shared_ptr<void> getComponentViewRef() const {
+    return viewRef_;
+  }
+
+private:
+  int counter_{0};
+  std::shared_ptr<void> viewRef_{nullptr};
+};
+
+} // namespace facebook::react