react-native-enriched-markdown-scaffold 0.7.4-scaffold.9 → 1.0.2-scaffold.2

package/ios/internals/ENRMViewFreeMeasurement.h

@@ -0,0 +1,331 @@
+#pragma once
+
+#import "ENRMCodeBlockContainerView.h"
+#import "ENRMFeatureFlags.h"
+#import "ENRMMarkdownParser.h"
+#import "ENRMTextRenderer.h"
+#import "ENRMTextViewSetup.h"
+#import "ImageRequestHeaderUtils.h"
+#import "MarkdownASTNode.h"
+#import "ParagraphStyleUtils.h"
+#import "RenderedMarkdownSegment.h"
+#import "SegmentRenderer.h"
+#import "StreamingMarkdownFilter.h"
+#import "StylePropsUtils.h"
+#import "TableContainerView.h"
+#include <type_traits>
+#if ENRICHED_MARKDOWN_MATH
+#import "ENRMMathContainerView.h"
+#endif
+
+/**
+ * View-free markdown 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`:
+ *
+ * - `ENRMMeasureMarkdownViewFree` (EnrichedMarkdownText): 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.
+ * - `ENRMMeasureSegmentedMarkdownViewFree` (EnrichedMarkdown): 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
+ *   (`ENRMConfigureMarkdownTextView`): 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;
+  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.markdownStyle)>>;
+  static const StyleT kDefaultStyle{};
+  applyMarkdownStyleToConfig(config, typedProps.markdownStyle, kDefaultStyle);
+  [config setFontScaleMultiplier:fontScale];
+  [config setMaxFontSizeMultiplier:typedProps.maxFontSizeMultiplier];
+  [config setImageRequestHeaders:ENRMImageRequestHeadersFromProps(typedProps.imageRequestHeaders)];
+  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).
+ *
+ * `usesFontLeading` must be NO: a raw NSLayoutManager defaults to YES and
+ * adds the used fonts' leading on top of the paragraph style's line-height
+ * clamp, while the UITextView the visible view renders with does not. Fonts
+ * pulled in by glyph fallback make this observable — Geeza Pro (Arabic)
+ * carries nonzero leading, so with YES every Arabic-script line measures
+ * taller than it renders and the surplus pools as phantom bottom space.
+ * RCTTextLayoutManager disables it for the same view-parity reason.
+ */
+static inline CGSize ENRMMeasureAttributedTextViewFree(NSAttributedString *text, CGFloat maxWidth, StyleConfig *config,
+                                                       BOOL allowTrailingMargin, CGFloat lastElementMarginBottom,
+                                                       CGFloat pointScaleFactor)
+{
+  if (text.length == 0) {
+    return CGSizeZero;
+  }
+
+  NSTextContainer *textContainer = [[NSTextContainer alloc] initWithSize:CGSizeMake(maxWidth, CGFLOAT_MAX)];
+  textContainer.lineFragmentPadding = 0;
+  NSLayoutManager *layoutManager = [[NSLayoutManager alloc] init];
+  layoutManager.allowsNonContiguousLayout = NO;
+  layoutManager.usesFontLeading = NO;
+  [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, text, maxWidth, config, allowTrailingMargin,
+                                      lastElementMarginBottom, pointScaleFactor);
+}
+
+/**
+ * Measures EnrichedMarkdownText 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 markdown, parse failures, and
+ * empty render output — the same fallback `measureSize:` produced.
+ */
+template <typename PropsT>
+static inline CGSize ENRMMeasureMarkdownViewFree(const PropsT &typedProps, CGFloat maxWidth, CGFloat fontScale,
+                                                 CGFloat pointScaleFactor, NSWritingDirection resolvedLayoutDirection)
+{
+  @autoreleasepool {
+    CGSize fallback = CGSizeMake(maxWidth, UIFontLineHeight([UIFont systemFontOfSize:16.0]));
+    if (typedProps.markdown.empty()) {
+      return fallback;
+    }
+
+    NSString *markdown = [[NSString alloc] initWithUTF8String:typedProps.markdown.c_str()];
+    StyleConfig *config = ENRMStyleConfigFromProps(typedProps, fontScale);
+
+    ENRMMd4cFlags *flags = ENRMMd4cFlagsFromProps(typedProps.md4cFlags);
+    ENRMMarkdownParser *parser = [[ENRMMarkdownParser alloc] init];
+    MarkdownASTNode *ast = [parser parseMarkdown:markdown flags:flags];
+    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);
+
+    CGSize size = ENRMMeasureAttributedTextViewFree(text, maxWidth, config, typedProps.allowTrailingMargin,
+                                                    result.lastElementMarginBottom, pointScaleFactor);
+    if (size.height == 0) {
+      return fallback;
+    }
+    return size;
+  }
+}
+
+/**
+ * Measures segmented EnrichedMarkdown content from props alone, on the
+ * calling thread, replicating the view path end to end: the streaming table
+ * filter (`ENRMRenderableMarkdownForStreaming` with the props'
+ * streamingConfig.tableMode), the segment split and per-segment rendering
+ * (`ENRMRenderSegmentsFromAST` + per-text-segment writing direction — the
+ * same calls `renderMarkdownContent:` makes), then the walk from
+ * `computeSegmentLayoutForWidth:`: text segments include their trailing
+ * margin unless last (`!isLast || allowTrailingMargin`), table and math
+ * segments add their config marginTop before and marginBottom after under the
+ * same condition, tables report full width. Finishes with `measureSize:`'s
+ * pixel rounding (width capped at maxWidth) and its
+ * (maxWidth × system-16 line height) fallback for empty/failed content.
+ */
+template <typename PropsT>
+static inline CGSize ENRMMeasureSegmentedMarkdownViewFree(const PropsT &typedProps, CGFloat maxWidth, CGFloat fontScale,
+                                                          CGFloat pointScaleFactor,
+                                                          NSWritingDirection resolvedLayoutDirection)
+{
+  @autoreleasepool {
+    CGSize fallback = CGSizeMake(maxWidth, UIFontLineHeight([UIFont systemFontOfSize:16.0]));
+    if (typedProps.markdown.empty()) {
+      return fallback;
+    }
+
+    NSString *markdown = [[NSString alloc] initWithUTF8String:typedProps.markdown.c_str()];
+
+    if (typedProps.streamingAnimation) {
+      NSString *tableModeStr = [[NSString alloc] initWithUTF8String:typedProps.streamingConfig.tableMode.c_str()];
+      ENRMTableStreamingMode tableStreamingMode =
+          [tableModeStr isEqualToString:@"hidden"] ? ENRMTableStreamingModeHidden : ENRMTableStreamingModeProgressive;
+      NSString *codeBlockModeStr =
+          [[NSString alloc] initWithUTF8String:typedProps.streamingConfig.codeBlockMode.c_str()];
+      ENRMCodeBlockStreamingMode codeBlockStreamingMode = [codeBlockModeStr isEqualToString:@"hidden"]
+                                                              ? ENRMCodeBlockStreamingModeHidden
+                                                              : ENRMCodeBlockStreamingModeProgressive;
+      markdown = ENRMRenderableMarkdownForStreaming(markdown, tableStreamingMode, codeBlockStreamingMode, NULL);
+      if (markdown.length == 0) {
+        return fallback;
+      }
+    }
+
+    StyleConfig *config = ENRMStyleConfigFromProps(typedProps, fontScale);
+
+    ENRMMd4cFlags *flags = ENRMMd4cFlagsFromProps(typedProps.md4cFlags);
+    ENRMMarkdownParser *parser = [[ENRMMarkdownParser alloc] init];
+    MarkdownASTNode *ast = [parser parseMarkdown:markdown flags:flags];
+    if (!ast) {
+      return fallback;
+    }
+
+    NSLineBreakStrategy lineBreakStrategy =
+        ENRMResolveLineBreakStrategy([[NSString alloc] initWithUTF8String:typedProps.lineBreakStrategyIOS.c_str()]);
+    ENRMWritingDirectionMode writingDirectionMode =
+        ENRMResolveWritingDirectionMode([[NSString alloc] initWithUTF8String:typedProps.writingDirection.c_str()]);
+
+    NSArray<ENRMRenderedSegment *> *segments =
+        ENRMRenderSegmentsFromAST(ast, config, typedProps.allowTrailingMargin, typedProps.allowFontScaling,
+                                  typedProps.maxFontSizeMultiplier, lineBreakStrategy);
+    for (ENRMRenderedSegment *segment in segments) {
+      if (segment.kind == ENRMSegmentKindText && segment.textResult) {
+        ENRMApplyWritingDirectionMode(segment.textResult.attributedText, writingDirectionMode, resolvedLayoutDirection);
+      }
+    }
+
+    if (segments.count == 0) {
+      return fallback;
+    }
+
+    CGFloat yOffset = 0.0;
+    CGFloat maxContentWidth = 0.0;
+    const NSUInteger lastIndex = segments.count - 1;
+
+    for (NSUInteger i = 0; i < segments.count; i++) {
+      ENRMRenderedSegment *segment = segments[i];
+      const BOOL isLast = (i == lastIndex);
+      const BOOL shouldAddBottomMargin = (!isLast || typedProps.allowTrailingMargin);
+
+      if (segment.kind == ENRMSegmentKindText && segment.textResult) {
+        CGSize textSize = ENRMMeasureAttributedTextViewFree(
+            segment.textResult.attributedText, maxWidth, config, shouldAddBottomMargin,
+            segment.textResult.lastElementMarginBottom, pointScaleFactor);
+        yOffset += textSize.height;
+        maxContentWidth = MAX(maxContentWidth, textSize.width);
+      } else if (segment.kind == ENRMSegmentKindTable && segment.tableSegment) {
+        yOffset += config.tableMarginTop;
+        yOffset += [TableContainerView measureHeightForTableNode:segment.tableSegment.tableNode
+                                                          config:config
+                                                allowFontScaling:typedProps.allowFontScaling
+                                           maxFontSizeMultiplier:typedProps.maxFontSizeMultiplier
+                                            writingDirectionMode:writingDirectionMode
+                                         resolvedLayoutDirection:resolvedLayoutDirection];
+        maxContentWidth = maxWidth;
+        if (shouldAddBottomMargin) {
+          yOffset += config.tableMarginBottom;
+        }
+      } else if (segment.kind == ENRMSegmentKindCodeBlock && segment.codeBlockSegment) {
+        yOffset += config.codeBlockMarginTop;
+        yOffset += [ENRMCodeBlockContainerView measureHeightForCodeBlockNode:segment.codeBlockSegment.codeBlockNode
+                                                                      config:config];
+        maxContentWidth = maxWidth;
+        if (shouldAddBottomMargin) {
+          yOffset += config.codeBlockMarginBottom;
+        }
+      }
+#if ENRICHED_MARKDOWN_MATH
+      else if (segment.kind == ENRMSegmentKindMath && segment.mathSegment) {
+        yOffset += config.mathMarginTop;
+        yOffset += [ENRMMathContainerView measureHeightForLatex:segment.mathSegment.latex
+                                                         config:config
+                                                       maxWidth:maxWidth];
+        maxContentWidth = maxWidth;
+        if (shouldAddBottomMargin) {
+          yOffset += config.mathMarginBottom;
+        }
+      }
+#endif
+    }
+
+    if (yOffset == 0) {
+      return fallback;
+    }
+
+    CGFloat measuredWidth = MIN(ceil(maxContentWidth * pointScaleFactor) / pointScaleFactor, maxWidth);
+    CGFloat measuredHeight = ceil(yOffset * pointScaleFactor) / pointScaleFactor;
+    return CGSizeMake(measuredWidth, measuredHeight);
+  }
+}

package/ios/internals/EnrichedMarkdownShadowNode.h

@@ -35,9 +35,7 @@ public:
 private:
   int localHeightRecalculationCounter_{0};
   mutable int lastExactMeasurementCounter_{0};
-
-  // Creates mock view off-screen for initial measurement when real view doesn't exist
-  id setupMockEnrichedMarkdown_(CGFloat width) const;
+  mutable CGSize lastExactMeasurementSize_{0, 0};
 };
 
 } // namespace facebook::react

package/ios/internals/EnrichedMarkdownShadowNode.mm

@@ -1,4 +1,5 @@
 #import "EnrichedMarkdownShadowNode.h"
+#import "ENRMViewFreeMeasurement.h"
 #import "EnrichedMarkdown.h"
 #import "ShadowMeasurementUtils.h"
 #import <yoga/Yoga.h>
@@ -19,7 +20,9 @@ EnrichedMarkdownShadowNode::EnrichedMarkdownShadowNode(const ShadowNode &sourceS
       localHeightRecalculationCounter_(
           static_cast<const EnrichedMarkdownShadowNode &>(sourceShadowNode).localHeightRecalculationCounter_),
       lastExactMeasurementCounter_(
-          static_cast<const EnrichedMarkdownShadowNode &>(sourceShadowNode).lastExactMeasurementCounter_)
+          static_cast<const EnrichedMarkdownShadowNode &>(sourceShadowNode).lastExactMeasurementCounter_),
+      lastExactMeasurementSize_(
+          static_cast<const EnrichedMarkdownShadowNode &>(sourceShadowNode).lastExactMeasurementSize_)
 {
   const auto &oldProps = *std::static_pointer_cast<const EnrichedMarkdownProps>(sourceShadowNode.getProps());
   const auto &newProps = *std::static_pointer_cast<const EnrichedMarkdownProps>(this->getProps());
@@ -42,32 +45,25 @@ void EnrichedMarkdownShadowNode::dirtyLayoutIfNeeded()
   }
 }
 
-id EnrichedMarkdownShadowNode::setupMockEnrichedMarkdown_(CGFloat width) const
-{
-  EnrichedMarkdown *mockView = [[EnrichedMarkdown alloc] initWithFrame:CGRectMake(20000, 20000, width, 1000)];
-
-  const auto props = this->getProps();
-  [mockView updateProps:props oldProps:nullptr];
-
-  const auto &typedProps = *std::static_pointer_cast<const EnrichedMarkdownProps>(props);
-  if (!typedProps.markdown.empty()) {
-    NSString *markdown = [NSString stringWithUTF8String:typedProps.markdown.c_str()];
-    [mockView renderMarkdownSynchronously:markdown];
-  }
-
-  return mockView;
-}
-
 Size EnrichedMarkdownShadowNode::measureContent(const LayoutContext &layoutContext,
                                                 const LayoutConstraints &layoutConstraints) const
 {
-  const auto &typedProps = *std::static_pointer_cast<const EnrichedMarkdownProps>(this->getProps());
+  const auto propsHandle = std::static_pointer_cast<const EnrichedMarkdownProps>(this->getProps());
+  const auto &typedProps = *propsHandle;
   const int receivedCounter = getStateData().getHeightRecalculationCounter();
+  const EnrichedMarkdownProps *props = propsHandle.get();
+  CGFloat pointScaleFactor = layoutContext.pointScaleFactor;
+  NSWritingDirection resolvedLayoutDirection = layoutConstraints.layoutDirection == LayoutDirection::RightToLeft
+                                                   ? NSWritingDirectionRightToLeft
+                                                   : NSWritingDirectionLeftToRight;
 
   return ENRMMeasureMarkdownContent<EnrichedMarkdownProps, EnrichedMarkdown>(
       typedProps, getStateData().getComponentViewRef(), receivedCounter, lastExactMeasurementCounter_,
-      MarkdownFlavor::GitHub, layoutConstraints,
-      ^(CGFloat width) { return (EnrichedMarkdown *)setupMockEnrichedMarkdown_(width); });
+      lastExactMeasurementSize_, MarkdownFlavor::GitHub, layoutContext, layoutConstraints,
+      ^(EnrichedMarkdown *view, CGFloat maxWidth, CGFloat fontScale) {
+        return ENRMMeasureSegmentedMarkdownViewFree(*props, maxWidth, fontScale, pointScaleFactor,
+                                                    resolvedLayoutDirection);
+      });
 }
 
 } // namespace facebook::react

package/ios/internals/EnrichedMarkdownTextShadowNode.h

@@ -37,9 +37,7 @@ public:
 private:
   int localHeightRecalculationCounter_{0};
   mutable int lastExactMeasurementCounter_{0};
-
-  // Creates mock view off-screen for initial measurement when real view doesn't exist
-  id setupMockEnrichedMarkdownText_(CGFloat width) const;
+  mutable CGSize lastExactMeasurementSize_{0, 0};
 };
 
 } // namespace facebook::react

package/ios/internals/EnrichedMarkdownTextShadowNode.mm

@@ -1,4 +1,5 @@
 #import "EnrichedMarkdownTextShadowNode.h"
+#import "ENRMViewFreeMeasurement.h"
 #import "EnrichedMarkdownText.h"
 #import "ShadowMeasurementUtils.h"
 #import <yoga/Yoga.h>
@@ -20,7 +21,9 @@ EnrichedMarkdownTextShadowNode::EnrichedMarkdownTextShadowNode(const ShadowNode
       localHeightRecalculationCounter_(
           static_cast<const EnrichedMarkdownTextShadowNode &>(sourceShadowNode).localHeightRecalculationCounter_),
       lastExactMeasurementCounter_(
-          static_cast<const EnrichedMarkdownTextShadowNode &>(sourceShadowNode).lastExactMeasurementCounter_)
+          static_cast<const EnrichedMarkdownTextShadowNode &>(sourceShadowNode).lastExactMeasurementCounter_),
+      lastExactMeasurementSize_(
+          static_cast<const EnrichedMarkdownTextShadowNode &>(sourceShadowNode).lastExactMeasurementSize_)
 {
   const auto &oldProps = *std::static_pointer_cast<const EnrichedMarkdownTextProps>(sourceShadowNode.getProps());
   const auto &newProps = *std::static_pointer_cast<const EnrichedMarkdownTextProps>(this->getProps());
@@ -43,32 +46,24 @@ void EnrichedMarkdownTextShadowNode::dirtyLayoutIfNeeded()
   }
 }
 
-id EnrichedMarkdownTextShadowNode::setupMockEnrichedMarkdownText_(CGFloat width) const
-{
-  EnrichedMarkdownText *mockView = [[EnrichedMarkdownText alloc] initWithFrame:CGRectMake(20000, 20000, width, 1000)];
-
-  const auto props = this->getProps();
-  [mockView updateProps:props oldProps:nullptr];
-
-  const auto &typedProps = *std::static_pointer_cast<const EnrichedMarkdownTextProps>(props);
-  if (!typedProps.markdown.empty()) {
-    NSString *markdown = [NSString stringWithUTF8String:typedProps.markdown.c_str()];
-    [mockView renderMarkdownSynchronously:markdown];
-  }
-
-  return mockView;
-}
-
 Size EnrichedMarkdownTextShadowNode::measureContent(const LayoutContext &layoutContext,
                                                     const LayoutConstraints &layoutConstraints) const
 {
-  const auto &typedProps = *std::static_pointer_cast<const EnrichedMarkdownTextProps>(this->getProps());
+  const auto propsHandle = std::static_pointer_cast<const EnrichedMarkdownTextProps>(this->getProps());
+  const auto &typedProps = *propsHandle;
   const int receivedCounter = getStateData().getHeightRecalculationCounter();
+  const EnrichedMarkdownTextProps *props = propsHandle.get();
+  CGFloat pointScaleFactor = layoutContext.pointScaleFactor;
+  NSWritingDirection resolvedLayoutDirection = layoutConstraints.layoutDirection == LayoutDirection::RightToLeft
+                                                   ? NSWritingDirectionRightToLeft
+                                                   : NSWritingDirectionLeftToRight;
 
   return ENRMMeasureMarkdownContent<EnrichedMarkdownTextProps, EnrichedMarkdownText>(
       typedProps, getStateData().getComponentViewRef(), receivedCounter, lastExactMeasurementCounter_,
-      MarkdownFlavor::CommonMark, layoutConstraints,
-      ^(CGFloat width) { return (EnrichedMarkdownText *)setupMockEnrichedMarkdownText_(width); });
+      lastExactMeasurementSize_, MarkdownFlavor::CommonMark, layoutContext, layoutConstraints,
+      ^(EnrichedMarkdownText *view, CGFloat maxWidth, CGFloat fontScale) {
+        return ENRMMeasureMarkdownViewFree(*props, maxWidth, fontScale, pointScaleFactor, resolvedLayoutDirection);
+      });
 }
 
 } // namespace facebook::react

package/ios/internals/MeasurementCache.h

@@ -40,19 +40,24 @@ struct MeasurementCacheKey {
   bool md4cFlagsSubscript;
   bool md4cFlagsHighlight;
   bool md4cFlagsLatexMath;
+  bool md4cFlagsHardSoftBreaks;
   size_t styleFingerprint;
   CGFloat fontScale;
   MarkdownFlavor flavor;
+  std::string lineBreakStrategyIOS;
+  std::string writingDirection;
 
   bool operator==(const MeasurementCacheKey &other) const
   {
     return std::tie(markdown, maxWidth, allowTrailingMargin, allowFontScaling, maxFontSizeMultiplier,
                     md4cFlagsUnderline, md4cFlagsSuperscript, md4cFlagsSubscript, md4cFlagsHighlight,
-                    md4cFlagsLatexMath, styleFingerprint, fontScale, flavor) ==
+                    md4cFlagsLatexMath, md4cFlagsHardSoftBreaks, styleFingerprint, fontScale, flavor,
+                    lineBreakStrategyIOS, writingDirection) ==
            std::tie(other.markdown, other.maxWidth, other.allowTrailingMargin, other.allowFontScaling,
                     other.maxFontSizeMultiplier, other.md4cFlagsUnderline, other.md4cFlagsSuperscript,
                     other.md4cFlagsSubscript, other.md4cFlagsHighlight, other.md4cFlagsLatexMath,
-                    other.styleFingerprint, other.fontScale, other.flavor);
+                    other.md4cFlagsHardSoftBreaks, other.styleFingerprint, other.fontScale, other.flavor,
+                    other.lineBreakStrategyIOS, other.writingDirection);
   }
 };
 
@@ -70,9 +75,12 @@ struct MeasurementCacheKeyHash {
     HashUtils::hash_one(h, key.md4cFlagsSubscript);
     HashUtils::hash_one(h, key.md4cFlagsHighlight);
     HashUtils::hash_one(h, key.md4cFlagsLatexMath);
+    HashUtils::hash_one(h, key.md4cFlagsHardSoftBreaks);
     HashUtils::hash_one(h, key.styleFingerprint);
     HashUtils::hash_one(h, key.fontScale);
     HashUtils::hash_one(h, static_cast<uint8_t>(key.flavor));
+    HashUtils::hash_one(h, key.lineBreakStrategyIOS);
+    HashUtils::hash_one(h, key.writingDirection);
     return h;
   }
 };
@@ -108,10 +116,11 @@ template <typename StyleStruct> inline size_t computeStyleFingerprint(const Styl
   hashFields(s.h6.textAlign);
 
   hashTextLayout(s.blockquote);
-  hashFields(s.blockquote.borderWidth, s.blockquote.gapWidth);
+  hashFields(s.blockquote.borderWidth, s.blockquote.gapWidth, s.blockquote.padding, s.blockquote.borderRadius);
 
   hashTextLayout(s.list);
-  hashFields(s.list.bulletSize, s.list.markerMinWidth, s.list.markerFontWeight, s.list.gapWidth, s.list.marginLeft);
+  hashFields(s.list.bulletSize, s.list.markerMinWidth, s.list.markerFontWeight, s.list.gapWidth, s.list.marginLeft,
+             s.list.itemSpacing);
 
   // Code & Inlines
   hashFields(s.codeBlock.fontFamily, s.codeBlock.fontSize, s.codeBlock.fontWeight, s.codeBlock.marginTop,
@@ -122,14 +131,14 @@ template <typename StyleStruct> inline size_t computeStyleFingerprint(const Styl
   hashFields(s.highlight.backgroundColor, s.highlight.color);
 
   // Visual/Spacing Elements
-  hashFields(s.image.height, s.image.marginTop, s.image.marginBottom);
+  hashFields(s.image.height, s.image.maxHeight, s.image.aspectRatio, s.image.marginTop, s.image.marginBottom);
   hashFields(s.inlineImage.size);
   hashFields(s.thematicBreak.height, s.thematicBreak.marginTop, s.thematicBreak.marginBottom);
 
   // Complex Components
   hashTextLayout(s.table);
   hashFields(s.table.headerFontFamily, s.table.cellPaddingHorizontal, s.table.cellPaddingVertical, s.table.borderWidth,
-             s.table.borderRadius);
+             s.table.borderRadius, s.table.horizontalOverflow);
   hashFields(s.math.fontSize, s.math.padding, s.math.marginTop, s.math.marginBottom, s.math.textAlign);
   hashFields(s.inlineMath.paddingVertical);
   hashFields(s.taskList.checkboxSize, s.taskList.checkboxBorderRadius);
@@ -152,9 +161,12 @@ inline MeasurementCacheKey buildMeasurementCacheKey(const PropsType &props, CGFl
       .md4cFlagsSubscript = props.md4cFlags.subscript,
       .md4cFlagsHighlight = props.md4cFlags.highlight,
       .md4cFlagsLatexMath = props.md4cFlags.latexMath,
+      .md4cFlagsHardSoftBreaks = props.md4cFlags.hardSoftBreaks,
       .styleFingerprint = computeStyleFingerprint(props.markdownStyle),
       .fontScale = fontScale,
       .flavor = flavor,
+      .lineBreakStrategyIOS = props.lineBreakStrategyIOS,
+      .writingDirection = props.writingDirection,
   };
 }
 
@@ -211,6 +223,20 @@ public:
     }
   }
 
+  void removeMatchingMarkdown(const std::string &markdown)
+  {
+    std::lock_guard<std::mutex> lock(mutex_);
+
+    for (auto it = list_.begin(); it != list_.end();) {
+      if (it->key.markdown == markdown) {
+        map_.erase(it->key);
+        it = list_.erase(it);
+      } else {
+        ++it;
+      }
+    }
+  }
+
 private:
   MeasurementCache() = default;
 
@@ -221,4 +247,4 @@ private:
   std::unordered_map<MeasurementCacheKey, std::list<CacheEntry>::iterator, MeasurementCacheKeyHash> map_;
 };
 
-} // namespace facebook::react
+} // namespace facebook::react