@mathers101/react-native-render-rich-text 0.1.9 → 0.1.14

package/ios/internals/ENRMViewFreeMeasurement.h

@@ -1,208 +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;
-  }
-}
-
+#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

@@ -1,19 +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
+#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

@@ -1,43 +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
+#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