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

package/ios/internals/ShadowMeasurementUtils.h

@@ -6,31 +6,43 @@
 #include <algorithm>
 #include <cmath>
 #include <react/renderer/core/LayoutConstraints.h>
+#include <react/renderer/core/LayoutContext.h>
 #include <react/utils/ManagedObjectWrapper.h>
 
 namespace facebook::react {
 
-// measureContent runs on Yoga's background layout thread and uses
-// dispatch_sync to main for UIKit reads. Safe because RN never
-// synchronously joins the layout queue from main. A synchronous
-// layout flush from main would deadlock.
-
-static inline CGFloat ENRMFontScaleForMeasurement(bool allowFontScaling)
+// Threading contract (issue #550): measureContent may run on any thread while
+// RN holds commit locks that main-thread committers (e.g. Reanimated) also
+// acquire — with `preventShadowTreeCommitExhaustion`, the JS thread re-runs
+// layout under `revisionMutexRecursive_` after 3 failed optimistic commits.
+// Any dispatch_sync to main from this path can therefore deadlock: JS waits
+// for main, main waits for the mutex JS holds (watchdog kill 0x8BADF00D).
+// Nothing in the measurement path may wait on the main thread.
+// EnrichedMarkdownText and EnrichedMarkdown both measure view-free
+// (ENRMViewFreeMeasurement.h) and comply fully. The one known remaining
+// violation is the text input's own measureContent
+// (EnrichedMarkdownTextInputShadowNode.mm), which measures live editable
+// UITextView state and needs its own strategy.
+
+/**
+ * Font scale (Dynamic Type multiplier) for measurement, without touching the
+ * main thread.
+ *
+ * Reads `LayoutContext::fontSizeMultiplier` instead of calling
+ * `RCTFontSizeMultiplier()` (a UIKit read that previously forced a
+ * dispatch_sync to main on every measure — a deadlock window under the locked
+ * commit fallback, see the contract above). RN maintains the multiplier for
+ * us: `RCTFabricSurface::_updateLayoutContext` sets it on main from
+ * `RCTFontSizeMultiplier()` and re-runs `constraintLayout` whenever
+ * `UIContentSizeCategoryDidChangeNotification` fires, so every Dynamic Type
+ * change re-measures with the fresh value. This is the same source
+ * `ParagraphShadowNode` uses for core text. A measure racing a Dynamic Type
+ * change at worst caches under the outgoing scale, which is never read again
+ * once the re-layout lands.
+ */
+static inline CGFloat ENRMFontScaleForMeasurement(bool allowFontScaling, const LayoutContext &layoutContext)
 {
-  if (!allowFontScaling) {
-    return 1.0;
-  }
-
-  __block CGFloat fontScale = 1.0;
-  void (^readFontScale)(void) = ^{ fontScale = RCTFontSizeMultiplier(); };
-
-  if ([NSThread isMainThread]) {
-    readFontScale();
-  } else {
-    dispatch_sync(dispatch_get_main_queue(), readFontScale);
-  }
-
-  return fontScale;
+  return allowFontScaling ? layoutContext.fontSizeMultiplier : 1.0;
 }
 
 static inline Size ENRMClampMeasuredSize(CGSize size, const LayoutConstraints &layoutConstraints)
@@ -55,41 +67,52 @@ static inline bool ENRMPropsNeedExactStreamingMeasurement(const PropsT &oldProps
          oldProps.md4cFlags.superscript != newProps.md4cFlags.superscript ||
          oldProps.md4cFlags.subscript != newProps.md4cFlags.subscript ||
          oldProps.md4cFlags.latexMath != newProps.md4cFlags.latexMath ||
+         oldProps.md4cFlags.highlight != newProps.md4cFlags.highlight ||
+         oldProps.md4cFlags.hardSoftBreaks != newProps.md4cFlags.hardSoftBreaks ||
          computeStyleFingerprint(oldProps.markdownStyle) != computeStyleFingerprint(newProps.markdownStyle);
 }
 
+/**
+ * Shared measureContent implementation for the markdown component views.
+ *
+ * Owns the thread-safe layers — the streaming fast path (lock-free
+ * `ENRMAtomicSize` mailbox published by `updateLayoutMetrics:`), the
+ * LRU measurement cache, and the `layoutContext`-sourced font scale — then
+ * delegates cache misses to `measureUncached`, through which both components
+ * plug their view-free pipeline (`ENRMMeasureMarkdownViewFree` /
+ * `ENRMMeasureSegmentedMarkdownViewFree`); the resolved view is still handed
+ * to the block for strategies that can use it. `fontScale` handed to the
+ * block is the real multiplier even when streaming skips the cache —
+ * rendering must always use it.
+ */
 template <typename PropsT, typename ViewT>
-static inline Size ENRMMeasureMarkdownContent(const PropsT &typedProps, const std::shared_ptr<void> &componentViewRef,
-                                              int receivedCounter, int &lastExactMeasurementCounter,
-                                              MarkdownFlavor flavor, const LayoutConstraints &layoutConstraints,
-                                              ViewT * (^createMockView)(CGFloat width))
+static inline Size
+ENRMMeasureMarkdownContent(const PropsT &typedProps, const std::shared_ptr<void> &componentViewRef, int receivedCounter,
+                           int &lastExactMeasurementCounter, CGSize &lastExactMeasurementSize, MarkdownFlavor flavor,
+                           const LayoutContext &layoutContext, const LayoutConstraints &layoutConstraints,
+                           CGSize (^measureUncached)(ViewT *view, CGFloat maxWidth, CGFloat fontScale))
 {
   CGFloat maxWidth = layoutConstraints.maximumSize.width;
 
   RCTInternalGenericWeakWrapper *weakWrapper = (RCTInternalGenericWeakWrapper *)unwrapManagedObject(componentViewRef);
   ViewT *view = weakWrapper ? (ViewT *)weakWrapper.object : nil;
 
+  // Streaming fast path. Yoga re-measures several times per pass; the first call
+  // bumps lastExactMeasurementCounter, the rest land here. Return the freshly
+  // measured size, not the view's mailbox — mid-pass the frame isn't committed,
+  // so the mailbox is a generation stale and would freeze the height.
   if (typedProps.streamingAnimation && view && receivedCounter <= lastExactMeasurementCounter) {
-    __block CGSize currentSize = CGSizeZero;
-    void (^readCurrentSize)(void) = ^{
-      if (view.bounds.size.width > 0 && view.bounds.size.height > 0) {
-        currentSize = view.bounds.size;
-      }
-    };
-
-    if ([NSThread isMainThread]) {
-      readCurrentSize();
-    } else {
-      dispatch_sync(dispatch_get_main_queue(), readCurrentSize);
+    if (lastExactMeasurementSize.width > 0 && lastExactMeasurementSize.height > 0) {
+      return ENRMClampMeasuredSize(lastExactMeasurementSize, layoutConstraints);
     }
-
-    if (currentSize.height > 0) {
+    CGSize currentSize = [view lastCommittedLayoutSize];
+    if (currentSize.width > 0 && currentSize.height > 0) {
       return ENRMClampMeasuredSize(currentSize, layoutConstraints);
     }
   }
 
   const bool shouldUseMeasurementCache = !typedProps.streamingAnimation;
-  CGFloat fontScale = shouldUseMeasurementCache ? ENRMFontScaleForMeasurement(typedProps.allowFontScaling) : 1.0;
+  CGFloat fontScale = ENRMFontScaleForMeasurement(typedProps.allowFontScaling, layoutContext);
 
   if (shouldUseMeasurementCache && !typedProps.markdown.empty()) {
     auto cacheKey = buildMeasurementCacheKey(typedProps, maxWidth, fontScale, flavor);
@@ -99,26 +122,7 @@ static inline Size ENRMMeasureMarkdownContent(const PropsT &typedProps, const st
     }
   }
 
-  __block CGSize size;
-  NSString *currentMarkdown = typedProps.markdown.empty() ? nil : @(typedProps.markdown.c_str());
-  size_t styleFingerprint =
-      computeStyleFingerprint(typedProps.markdownStyle) ^ std::hash<bool>{}(typedProps.allowTrailingMargin);
-
-  void (^measureBlock)(void) = ^{
-    if (view && (typedProps.streamingAnimation || ([view hasRenderedMarkdown:currentMarkdown] &&
-                                                   [view hasRenderedWithStyleFingerprint:styleFingerprint]))) {
-      size = [view measureSize:maxWidth];
-    } else {
-      ViewT *mockView = createMockView(maxWidth);
-      size = [mockView measureSize:maxWidth];
-    }
-  };
-
-  if ([NSThread isMainThread]) {
-    measureBlock();
-  } else {
-    dispatch_sync(dispatch_get_main_queue(), measureBlock);
-  }
+  CGSize size = measureUncached(view, maxWidth, fontScale);
 
   if (shouldUseMeasurementCache && !typedProps.markdown.empty()) {
     auto cacheKey = buildMeasurementCacheKey(typedProps, maxWidth, fontScale, flavor);
@@ -127,6 +131,7 @@ static inline Size ENRMMeasureMarkdownContent(const PropsT &typedProps, const st
 
   if (typedProps.streamingAnimation) {
     lastExactMeasurementCounter = receivedCounter;
+    lastExactMeasurementSize = size;
   }
 
   return ENRMClampMeasuredSize(size, layoutConstraints);

package/ios/math/ENRMMathChipController.h

@@ -0,0 +1,74 @@
+#pragma once
+
+#import "ENRMInputFormatterStyle.h"
+#import "ENRMMathAtom.h"
+#import "ENRMUIKit.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// Owns everything about a math chip inside the editor's text storage: creating
+/// the attachment, stamping the current style onto it, selection highlighting,
+/// and hit-testing. The host keeps the edit-pipeline and event work; this keeps
+/// the attribute work, mirroring Android's `MathChipController`.
+///
+/// A chip is one `kENRMObjectReplacement` character in the buffer plus an
+/// `ENRMMathInlineAttachment` carrying the LaTeX. Nothing about the formula lives
+/// in the text, so the caret, the input method and every range in the stores
+/// treat it as a single atomic character.
+///
+/// In a math-disabled build every method here degrades to a no-op, so the host
+/// needs no `#if` of its own: `isAvailable` is NO, no chip is ever created, and
+/// the parser never produces an atom to stamp.
+@interface ENRMMathChipController : NSObject
+
+/// NO when math is compiled out. Callers may skip work on the strength of it,
+/// but do not have to: every other method is already inert in that build.
+@property (nonatomic, readonly, class) BOOL isAvailable;
+
+- (instancetype)initWithTextView:(ENRMPlatformTextView *)textView
+                           style:(ENRMInputFormatterStyle *)style NS_DESIGNATED_INITIALIZER;
+- (instancetype)init NS_UNAVAILABLE;
+
+/// Chips in document order, as plain data for `ENRMMarkdownSerializer`.
+- (NSArray<ENRMMathAtom *> *)allAtoms;
+
+/// The chip at `position`, or nil if that character is not a chip.
+- (nullable ENRMMathAtom *)atomAtPosition:(NSUInteger)position;
+
+/// One chip as an attributed string ready to splice into the buffer, including
+/// the paragraph alignment a block chip needs.
+- (NSAttributedString *)attributedChipWithLatex:(NSString *)latex displayMode:(BOOL)displayMode;
+
+/// Turns placeholder characters already in the buffer into chips. Positions are
+/// offsets into the buffer, shifted by `offset` (non-zero when the parse covered
+/// an inserted fragment rather than the whole buffer). A position that no longer
+/// holds a placeholder is skipped rather than overwriting live text.
+- (void)applyAtoms:(NSArray<ENRMMathAtom *> *)atoms offset:(NSUInteger)offset;
+
+/// Rewrites the formula and mode of an existing chip. No text changes — the
+/// formula lives on the attachment — so no store adjustment is needed, only a
+/// re-render and a re-measure. Returns NO if `position` holds no chip.
+- (BOOL)updateChipAtPosition:(NSUInteger)position latex:(NSString *)latex displayMode:(BOOL)displayMode;
+
+/// Selection highlight. `clearSelectionsExceptPosition:` takes NSNotFound to
+/// clear all. Both return whether anything actually changed.
+- (BOOL)setSelected:(BOOL)selected atPosition:(NSUInteger)position;
+- (BOOL)clearSelectionsExceptPosition:(NSUInteger)keepPosition;
+
+/// Re-stamps every chip with the current style — after a `markdownStyle` prop
+/// change or a row-width change. Both move the measured height.
+- (void)refreshAll;
+
+/// Chip glyph rect in text-view coordinates (the space `locationInView:` reports),
+/// or `CGRectNull` when the layout cannot give one.
+- (CGRect)chipRectAtPosition:(NSUInteger)position;
+
+/// Buffer position of the chip under `point`, or NSNotFound. The touch must land
+/// inside the chip's own glyph rect: `closestPositionToPoint:` has no distance
+/// bound and would otherwise report a tap anywhere in the text view as a tap on
+/// the nearest chip.
+- (NSUInteger)chipPositionAtPoint:(CGPoint)point;
+
+@end
+
+NS_ASSUME_NONNULL_END