react-native-enriched-markdown-scaffold 0.6.0-scaffold.4

package/ios/utils/RTFExportUtils.m

@@ -0,0 +1,297 @@
+#import "RTFExportUtils.h"
+#import "BlockquoteBorder.h"
+#import "CodeBackground.h"
+#import "LastElementUtils.h"
+#import "ListItemRenderer.h"
+#import "RenderContext.h"
+#import "StyleConfig.h"
+#import "ThematicBreakAttachment.h"
+
+static const CGFloat kListIndentPerLevel = 12.0;
+static const CGFloat kMinParagraphSpacing = 4.0;
+static const CGFloat kPaddingLineHeightThreshold = 20.0;
+static const CGFloat kNormalizedPaddingHeight = 2.0;
+
+/// Lightweight struct for marker insertion (avoids NSDictionary allocation overhead)
+typedef struct {
+  NSUInteger position;
+  NSInteger depth;
+  NSInteger itemNumber;
+  BOOL isOrdered;
+} MarkerInfo;
+
+#pragma mark - Line Position Utilities
+
+static void collectLineStartsInRange(NSString *string, NSRange range, void (^handler)(NSUInteger lineStart))
+{
+  NSUInteger pos = range.location;
+  NSUInteger end = NSMaxRange(range);
+
+  while (pos < end) {
+    handler(pos);
+    NSRange lineRange = [string lineRangeForRange:NSMakeRange(pos, 0)];
+    pos = NSMaxRange(lineRange);
+  }
+}
+
+#pragma mark - Inline Code Processing
+
+static void processCodes(NSMutableAttributedString *text, RCTUIColor *bgColor)
+{
+  if (!bgColor)
+    return;
+
+  [text enumerateAttribute:CodeAttributeName
+                   inRange:NSMakeRange(0, text.length)
+                   options:0
+                usingBlock:^(id value, NSRange range, BOOL *stop) {
+                  if (![value boolValue])
+                    return;
+
+                  [text addAttribute:NSBackgroundColorAttributeName value:bgColor range:range];
+                }];
+}
+
+#pragma mark - Code Block Processing
+
+static void processCodeBlocks(NSMutableAttributedString *text, RCTUIColor *bgColor)
+{
+  if (!bgColor)
+    return;
+
+  [text enumerateAttribute:CodeBlockAttributeName
+                   inRange:NSMakeRange(0, text.length)
+                   options:0
+                usingBlock:^(id value, NSRange range, BOOL *stop) {
+                  if (![value boolValue])
+                    return;
+
+                  [text addAttribute:NSBackgroundColorAttributeName value:bgColor range:range];
+
+                  // Normalize padding spacers (small fixed line heights used for visual padding)
+                  [text enumerateAttribute:NSParagraphStyleAttributeName
+                                   inRange:range
+                                   options:0
+                                usingBlock:^(NSParagraphStyle *style, NSRange paraRange, BOOL *innerStop) {
+                                  if (!style)
+                                    return;
+
+                                  CGFloat minHeight = style.minimumLineHeight;
+                                  CGFloat maxHeight = style.maximumLineHeight;
+
+                                  if (minHeight > 0 && minHeight == maxHeight &&
+                                      minHeight < kPaddingLineHeightThreshold) {
+                                    NSMutableParagraphStyle *normalStyle = [style mutableCopy];
+                                    normalStyle.minimumLineHeight = kNormalizedPaddingHeight;
+                                    normalStyle.maximumLineHeight = kNormalizedPaddingHeight;
+                                    [text addAttribute:NSParagraphStyleAttributeName value:normalStyle range:paraRange];
+                                  }
+                                }];
+                }];
+}
+
+#pragma mark - Blockquote Processing
+
+static void processBlockquotes(NSMutableAttributedString *text, RCTUIColor *bgColor)
+{
+  NSString *string = text.string;
+
+  // Collect marker positions (using C array for performance)
+  NSMutableData *markersData = [NSMutableData data];
+
+  [text enumerateAttribute:BlockquoteDepthAttributeName
+                   inRange:NSMakeRange(0, text.length)
+                   options:0
+                usingBlock:^(id value, NSRange range, BOOL *stop) {
+                  if (!value || [value integerValue] < 0)
+                    return;
+
+                  NSInteger depth = [value integerValue];
+                  collectLineStartsInRange(string, range, ^(NSUInteger lineStart) {
+                    MarkerInfo info = {.position = lineStart, .depth = depth, .itemNumber = 0, .isOrdered = NO};
+                    [markersData appendBytes:&info length:sizeof(MarkerInfo)];
+                  });
+                }];
+
+  // Sort descending (insert from end to avoid index shifting)
+  NSUInteger count = markersData.length / sizeof(MarkerInfo);
+  MarkerInfo *markers = (MarkerInfo *)markersData.mutableBytes;
+
+  qsort_b(markers, count, sizeof(MarkerInfo), ^int(const void *a, const void *b) {
+    NSUInteger posA = ((MarkerInfo *)a)->position;
+    NSUInteger posB = ((MarkerInfo *)b)->position;
+    return (posB > posA) - (posB < posA);
+  });
+
+  // Insert "> " markers from end to start
+  for (NSUInteger i = 0; i < count; i++) {
+    MarkerInfo info = markers[i];
+
+    NSMutableString *marker = [NSMutableString stringWithCapacity:(info.depth + 1) * 2];
+    for (NSInteger d = 0; d <= info.depth; d++) {
+      [marker appendString:@"> "];
+    }
+
+    NSDictionary *attrs = [text attributesAtIndex:info.position effectiveRange:NULL];
+    NSMutableDictionary *markerAttrs = bgColor ? [attrs mutableCopy] : attrs;
+    if (bgColor) {
+      markerAttrs[NSBackgroundColorAttributeName] = bgColor;
+    }
+
+    NSAttributedString *markerString = [[NSAttributedString alloc] initWithString:marker attributes:markerAttrs];
+    [text insertAttributedString:markerString atIndex:info.position];
+  }
+
+  // Normalize styles (background, spacing, remove indentation since markers provide visual indication)
+  [text enumerateAttribute:BlockquoteDepthAttributeName
+                   inRange:NSMakeRange(0, text.length)
+                   options:0
+                usingBlock:^(id value, NSRange range, BOOL *stop) {
+                  if (!value || [value integerValue] < 0)
+                    return;
+
+                  if (bgColor) {
+                    [text addAttribute:NSBackgroundColorAttributeName value:bgColor range:range];
+                  }
+
+                  [text enumerateAttribute:NSParagraphStyleAttributeName
+                                   inRange:range
+                                   options:0
+                                usingBlock:^(NSParagraphStyle *style, NSRange paraRange, BOOL *innerStop) {
+                                  if (!style)
+                                    return;
+
+                                  NSMutableParagraphStyle *normalStyle = [style mutableCopy];
+                                  if (normalStyle.paragraphSpacing > kMinParagraphSpacing) {
+                                    normalStyle.paragraphSpacing = kMinParagraphSpacing;
+                                  }
+                                  normalStyle.paragraphSpacingBefore = 0;
+                                  normalStyle.firstLineHeadIndent = 0;
+                                  normalStyle.headIndent = 0;
+
+                                  [text addAttribute:NSParagraphStyleAttributeName value:normalStyle range:paraRange];
+                                }];
+                }];
+}
+
+#pragma mark - List Processing
+
+static void processLists(NSMutableAttributedString *text)
+{
+  NSString *string = text.string;
+
+  // Collect list item positions
+  NSMutableData *markersData = [NSMutableData data];
+
+  [text enumerateAttribute:ListDepthAttribute
+                   inRange:NSMakeRange(0, text.length)
+                   options:0
+                usingBlock:^(id value, NSRange range, BOOL *stop) {
+                  if (!value || [value integerValue] < 0)
+                    return;
+
+                  collectLineStartsInRange(string, range, ^(NSUInteger lineStart) {
+                    NSDictionary *attrs = [text attributesAtIndex:lineStart effectiveRange:NULL];
+                    NSNumber *depthNum = attrs[ListDepthAttribute];
+                    NSNumber *listType = attrs[ListTypeAttribute];
+                    NSNumber *itemNumber = attrs[ListItemNumberAttribute];
+
+                    if (depthNum && [depthNum integerValue] >= 0) {
+                      MarkerInfo info = {.position = lineStart,
+                                         .depth = [depthNum integerValue],
+                                         .itemNumber = itemNumber ? [itemNumber integerValue] : 1,
+                                         .isOrdered = listType && [listType integerValue] == ListTypeOrdered};
+                      [markersData appendBytes:&info length:sizeof(MarkerInfo)];
+                    }
+                  });
+                }];
+
+  // Sort descending
+  NSUInteger count = markersData.length / sizeof(MarkerInfo);
+  MarkerInfo *markers = (MarkerInfo *)markersData.mutableBytes;
+
+  qsort_b(markers, count, sizeof(MarkerInfo), ^int(const void *a, const void *b) {
+    NSUInteger posA = ((MarkerInfo *)a)->position;
+    NSUInteger posB = ((MarkerInfo *)b)->position;
+    return (posB > posA) - (posB < posA);
+  });
+
+  // Insert markers
+  for (NSUInteger i = 0; i < count; i++) {
+    MarkerInfo info = markers[i];
+    NSString *marker = info.isOrdered ? [NSString stringWithFormat:@"%ld.  ", (long)info.itemNumber] : @"•  ";
+
+    NSDictionary *attrs = [text attributesAtIndex:info.position effectiveRange:NULL];
+    NSAttributedString *markerString = [[NSAttributedString alloc] initWithString:marker attributes:attrs];
+    [text insertAttributedString:markerString atIndex:info.position];
+  }
+
+  // Normalize indentation
+  [text enumerateAttribute:ListDepthAttribute
+                   inRange:NSMakeRange(0, text.length)
+                   options:0
+                usingBlock:^(id value, NSRange range, BOOL *stop) {
+                  if (!value || [value integerValue] < 0)
+                    return;
+
+                  NSInteger depth = [value integerValue];
+                  CGFloat indent = depth * kListIndentPerLevel;
+
+                  [text enumerateAttribute:NSParagraphStyleAttributeName
+                                   inRange:range
+                                   options:0
+                                usingBlock:^(NSParagraphStyle *style, NSRange paraRange, BOOL *innerStop) {
+                                  if (!style)
+                                    return;
+
+                                  NSMutableParagraphStyle *normalStyle = [style mutableCopy];
+                                  normalStyle.firstLineHeadIndent = indent;
+                                  normalStyle.headIndent = indent;
+                                  [text addAttribute:NSParagraphStyleAttributeName value:normalStyle range:paraRange];
+                                }];
+                }];
+}
+
+#pragma mark - Thematic Break Processing
+
+static void processThematicBreaks(NSMutableAttributedString *text)
+{
+  [text enumerateAttribute:NSAttachmentAttributeName
+                   inRange:NSMakeRange(0, text.length)
+                   options:NSAttributedStringEnumerationReverse
+                usingBlock:^(id attachment, NSRange range, BOOL *stop) {
+                  if (![attachment isKindOfClass:[ThematicBreakAttachment class]])
+                    return;
+
+                  NSMutableDictionary *attrs = [[text attributesAtIndex:range.location
+                                                         effectiveRange:NULL] mutableCopy];
+                  [attrs removeObjectForKey:NSAttachmentAttributeName];
+
+                  NSAttributedString *replacement = [[NSAttributedString alloc] initWithString:@"\n---\n"
+                                                                                    attributes:attrs];
+                  [text replaceCharactersInRange:range withAttributedString:replacement];
+                }];
+}
+
+#pragma mark - Public API
+
+NSAttributedString *prepareAttributedStringForRTFExport(NSAttributedString *attributedString,
+                                                        StyleConfig *_Nullable styleConfig)
+{
+  if (!styleConfig)
+    return attributedString;
+
+  NSMutableAttributedString *prepared = [attributedString mutableCopy];
+
+  RCTUIColor *codeBgColor = [styleConfig codeBackgroundColor];
+  RCTUIColor *codeBlockBgColor = [styleConfig codeBlockBackgroundColor];
+  RCTUIColor *blockquoteBgColor = [styleConfig blockquoteBackgroundColor];
+
+  processThematicBreaks(prepared);
+  processCodes(prepared, codeBgColor);
+  processCodeBlocks(prepared, codeBlockBgColor);
+  processBlockquotes(prepared, blockquoteBgColor);
+  processLists(prepared);
+
+  return prepared;
+}

package/ios/utils/RenderedMarkdownSegment.h

@@ -0,0 +1,49 @@
+#pragma once
+
+#import <Foundation/Foundation.h>
+
+@class ENRMRenderResult;
+@class MarkdownASTNode;
+
+NS_ASSUME_NONNULL_BEGIN
+
+typedef NS_ENUM(NSInteger, ENRMSegmentKind) { ENRMSegmentKindText, ENRMSegmentKindTable, ENRMSegmentKindMath };
+
+@interface ENRMTextSegment : NSObject
+@property (nonatomic, strong) NSArray<MarkdownASTNode *> *nodes;
++ (instancetype)segmentWithNodes:(NSArray<MarkdownASTNode *> *)nodes;
+@end
+
+@interface ENRMTableSegment : NSObject
+@property (nonatomic, strong) MarkdownASTNode *tableNode;
++ (instancetype)segmentWithTableNode:(MarkdownASTNode *)node;
+@end
+
+@interface ENRMMathSegment : NSObject
+@property (nonatomic, strong) NSString *latex;
++ (instancetype)segmentWithLatex:(NSString *)latex;
+@end
+
+@interface ENRMRenderedSegment : NSObject
+@property (nonatomic, assign) ENRMSegmentKind kind;
+@property (nonatomic, assign) uint64_t signature;
+@property (nonatomic, strong, nullable) ENRMRenderResult *textResult;
+@property (nonatomic, strong, nullable) ENRMTableSegment *tableSegment;
+@property (nonatomic, strong, nullable) ENRMMathSegment *mathSegment;
++ (instancetype)textSegmentWithResult:(ENRMRenderResult *)result signature:(uint64_t)signature;
++ (instancetype)tableSegmentWithSegment:(ENRMTableSegment *)segment signature:(uint64_t)signature;
++ (instancetype)mathSegmentWithSegment:(ENRMMathSegment *)segment signature:(uint64_t)signature;
+@end
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+uint64_t ENRMSignatureForNode(MarkdownASTNode *_Nullable node);
+uint64_t ENRMSignatureForNodes(NSArray<MarkdownASTNode *> *nodes);
+
+#ifdef __cplusplus
+}
+#endif
+
+NS_ASSUME_NONNULL_END

package/ios/utils/RenderedMarkdownSegment.m

@@ -0,0 +1,130 @@
+#import "RenderedMarkdownSegment.h"
+#import "MarkdownASTNode.h"
+
+@implementation ENRMTextSegment
++ (instancetype)segmentWithNodes:(NSArray<MarkdownASTNode *> *)nodes
+{
+  NSParameterAssert(nodes != nil);
+  ENRMTextSegment *segment = [[ENRMTextSegment alloc] init];
+  segment.nodes = [nodes copy];
+  return segment;
+}
+@end
+
+@implementation ENRMTableSegment
++ (instancetype)segmentWithTableNode:(MarkdownASTNode *)node
+{
+  NSParameterAssert(node != nil);
+  ENRMTableSegment *segment = [[ENRMTableSegment alloc] init];
+  segment.tableNode = node;
+  return segment;
+}
+@end
+
+@implementation ENRMMathSegment
++ (instancetype)segmentWithLatex:(NSString *)latex
+{
+  NSParameterAssert(latex != nil);
+  ENRMMathSegment *segment = [[ENRMMathSegment alloc] init];
+  segment.latex = latex;
+  return segment;
+}
+@end
+
+@implementation ENRMRenderedSegment
++ (instancetype)textSegmentWithResult:(ENRMRenderResult *)result signature:(uint64_t)signature
+{
+  NSParameterAssert(result != nil);
+  ENRMRenderedSegment *segment = [[ENRMRenderedSegment alloc] init];
+  segment.kind = ENRMSegmentKindText;
+  segment.textResult = result;
+  segment.signature = signature;
+  return segment;
+}
+
++ (instancetype)tableSegmentWithSegment:(ENRMTableSegment *)tableSegment signature:(uint64_t)signature
+{
+  NSParameterAssert(tableSegment != nil);
+  ENRMRenderedSegment *segment = [[ENRMRenderedSegment alloc] init];
+  segment.kind = ENRMSegmentKindTable;
+  segment.tableSegment = tableSegment;
+  segment.signature = signature;
+  return segment;
+}
+
++ (instancetype)mathSegmentWithSegment:(ENRMMathSegment *)mathSegment signature:(uint64_t)signature
+{
+  NSParameterAssert(mathSegment != nil);
+  ENRMRenderedSegment *segment = [[ENRMRenderedSegment alloc] init];
+  segment.kind = ENRMSegmentKindMath;
+  segment.mathSegment = mathSegment;
+  segment.signature = signature;
+  return segment;
+}
+@end
+
+// FNV-1a 64-bit hash for segment signatures. Collisions are theoretically
+// possible but negligible for the small number of segments per document
+// (~single digits). Worst case is a single skipped view update, corrected
+// on the next streaming tick. This replaces the previous approach of building
+// and comparing multi-KB NSString signatures from the full AST subtree.
+static const uint64_t kFNVOffsetBasis = 14695981039346656037ULL;
+static const uint64_t kFNVPrime = 1099511628211ULL;
+
+static inline uint64_t fnvMixByte(uint64_t hash, uint8_t byte)
+{
+  hash ^= byte;
+  hash *= kFNVPrime;
+  return hash;
+}
+
+static inline uint64_t fnvMixUInt64(uint64_t hash, uint64_t value)
+{
+  for (int i = 0; i < 8; i++) {
+    hash = fnvMixByte(hash, (uint8_t)(value & 0xFF));
+    value >>= 8;
+  }
+  return hash;
+}
+
+static inline uint64_t fnvMixString(uint64_t hash, NSString *string)
+{
+  if (!string)
+    return hash;
+  const char *utf8 = [string UTF8String];
+  while (*utf8) {
+    hash = fnvMixByte(hash, (uint8_t)*utf8++);
+  }
+  return hash;
+}
+
+uint64_t ENRMSignatureForNode(MarkdownASTNode *node)
+{
+  if (!node)
+    return kFNVOffsetBasis;
+
+  uint64_t hash = kFNVOffsetBasis;
+  hash = fnvMixUInt64(hash, (uint64_t)node.type);
+  hash = fnvMixString(hash, node.content);
+
+  NSArray *keys = [[node.attributes allKeys] sortedArrayUsingSelector:@selector(compare:)];
+  for (NSString *key in keys) {
+    hash = fnvMixString(hash, key);
+    hash = fnvMixString(hash, node.attributes[key]);
+  }
+
+  for (MarkdownASTNode *child in node.children) {
+    hash = fnvMixUInt64(hash, ENRMSignatureForNode(child));
+  }
+
+  return hash;
+}
+
+uint64_t ENRMSignatureForNodes(NSArray<MarkdownASTNode *> *nodes)
+{
+  uint64_t hash = kFNVOffsetBasis;
+  for (MarkdownASTNode *node in nodes) {
+    hash = fnvMixUInt64(hash, ENRMSignatureForNode(node));
+  }
+  return hash;
+}

package/ios/utils/RuntimeKeys.h

@@ -0,0 +1,38 @@
+#pragma once
+#import <objc/runtime.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ * Runtime keys for associated objects.
+ * These keys are used to store references on UIKit objects via objc_setAssociatedObject.
+ */
+
+// Key for storing UITextView on NSTextContainer
+// Used by attachments to retrieve the text view when needed
+extern void *kTextViewKey;
+
+// Key for storing StyleConfig on NSLayoutManager
+// Used by TextViewLayoutManager to access configuration
+extern void *kStyleConfigKey;
+
+// Key for storing CodeBackground instance on NSLayoutManager
+// Used by TextViewLayoutManager for code background drawing
+extern void *kCodeBackgroundKey;
+
+// Key for storing BlockquoteBorder instance on NSLayoutManager
+// Used by TextViewLayoutManager for blockquote border drawing
+extern void *kBlockquoteBorderKey;
+
+// Key for storing ListMarkerDrawer instance on NSLayoutManager
+// Used by TextViewLayoutManager for list marker drawing
+extern void *kListMarkerDrawerKey;
+
+// Key for storing CodeBlockBackground instance on NSLayoutManager
+// Used by TextViewLayoutManager for code block background drawing
+extern void *kCodeBlockBackgroundKey;
+
+// Custom attribute keys for markdown type tracking (used for Copy Markdown)
+extern NSString *const MarkdownTypeAttributeName;
+
+NS_ASSUME_NONNULL_END

package/ios/utils/RuntimeKeys.m

@@ -0,0 +1,11 @@
+#import "RuntimeKeys.h"
+
+void *kTextViewKey = &kTextViewKey;
+void *kStyleConfigKey = &kStyleConfigKey;
+void *kCodeBackgroundKey = &kCodeBackgroundKey;
+void *kBlockquoteBorderKey = &kBlockquoteBorderKey;
+void *kListMarkerDrawerKey = &kListMarkerDrawerKey;
+void *kCodeBlockBackgroundKey = &kCodeBlockBackgroundKey;
+
+// Custom attribute for markdown type tracking
+NSString *const MarkdownTypeAttributeName = @"MarkdownType";

package/ios/utils/SegmentReconciler.h

@@ -0,0 +1,32 @@
+#pragma once
+
+#import "ENRMUIKit.h"
+
+@class ENRMRenderedSegment;
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface ENRMSegmentReconciliationResult : NSObject
+@property (nonatomic, strong) NSMutableArray<RCTUIView *> *views;
+@property (nonatomic, strong) NSMutableArray<NSNumber *> *signatures;
+@end
+
+@interface ENRMSegmentReconciler : NSObject
+// Reconciles segment views using a two-pass strategy:
+// 1. Try positional match: if the view at the same index matches kind, reuse it.
+// 2. Fall back to signature-based lookup: find an unused view with the same
+//    kind+signature elsewhere in the old list. This handles mid-stream segment
+//    insertions where a completed table/math block shifts position.
++ (ENRMSegmentReconciliationResult *)
+    reconcileCurrentViews:(NSArray<RCTUIView *> *)currentViews
+        currentSignatures:(NSArray<NSNumber *> *)currentSignatures
+         renderedSegments:(NSArray<ENRMRenderedSegment *> *)renderedSegments
+                    reset:(BOOL)reset
+               createView:(RCTUIView * (^)(ENRMRenderedSegment *segment))createView
+               updateView:(void (^)(RCTUIView *view, ENRMRenderedSegment *segment))updateView
+               attachView:(void (^)(RCTUIView *view))attachView
+               removeView:(void (^)(RCTUIView *view))removeView
+              matchesKind:(BOOL (^)(RCTUIView *view, ENRMRenderedSegment *segment))matchesKind;
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/utils/SegmentReconciler.m

@@ -0,0 +1,118 @@
+#import "SegmentReconciler.h"
+#import "RenderedMarkdownSegment.h"
+
+@implementation ENRMSegmentReconciliationResult
+@end
+
+@implementation ENRMSegmentReconciler
++ (ENRMSegmentReconciliationResult *)
+    reconcileCurrentViews:(NSArray<RCTUIView *> *)currentViews
+        currentSignatures:(NSArray<NSNumber *> *)currentSignatures
+         renderedSegments:(NSArray<ENRMRenderedSegment *> *)renderedSegments
+                    reset:(BOOL)reset
+               createView:(RCTUIView * (^)(ENRMRenderedSegment *segment))createView
+               updateView:(void (^)(RCTUIView *view, ENRMRenderedSegment *segment))updateView
+               attachView:(void (^)(RCTUIView *view))attachView
+               removeView:(void (^)(RCTUIView *view))removeView
+              matchesKind:(BOOL (^)(RCTUIView *view, ENRMRenderedSegment *segment))matchesKind
+{
+  NSArray<RCTUIView *> *sourceViews = currentViews;
+  NSArray<NSNumber *> *sourceSignatures = currentSignatures;
+
+  if (reset) {
+    [currentViews enumerateObjectsUsingBlock:^(RCTUIView *view, NSUInteger index, BOOL *stop) { removeView(view); }];
+    sourceViews = @[];
+    sourceSignatures = @[];
+  }
+
+  // Build a signature -> (view, index) lookup for fallback reuse when
+  // positional matching fails (e.g. a new segment inserted before an
+  // existing table shifts it to a different index).
+  NSMutableDictionary<NSNumber *, NSMutableArray<NSNumber *> *> *signatureToIndices =
+      [NSMutableDictionary dictionaryWithCapacity:sourceSignatures.count];
+  [sourceSignatures enumerateObjectsUsingBlock:^(NSNumber *sig, NSUInteger idx, BOOL *stop) {
+    NSMutableArray<NSNumber *> *indices = signatureToIndices[sig];
+    if (!indices) {
+      indices = [NSMutableArray arrayWithObject:@(idx)];
+      signatureToIndices[sig] = indices;
+    } else {
+      [indices addObject:@(idx)];
+    }
+  }];
+
+  NSMutableDictionary<NSNumber *, NSNumber *> *remainingNextSignatureCounts =
+      [NSMutableDictionary dictionaryWithCapacity:renderedSegments.count];
+  for (ENRMRenderedSegment *segment in renderedSegments) {
+    NSNumber *signature = @(segment.signature);
+    NSUInteger count = remainingNextSignatureCounts[signature].unsignedIntegerValue;
+    remainingNextSignatureCounts[signature] = @(count + 1);
+  }
+
+  NSMutableArray<RCTUIView *> *nextViews = [NSMutableArray arrayWithCapacity:renderedSegments.count];
+  NSMutableArray<NSNumber *> *nextSignatures = [NSMutableArray arrayWithCapacity:renderedSegments.count];
+  NSMutableSet<RCTUIView *> *reusedViews = [NSMutableSet setWithCapacity:sourceViews.count];
+
+  [renderedSegments enumerateObjectsUsingBlock:^(ENRMRenderedSegment *segment, NSUInteger index, BOOL *stop) {
+    RCTUIView *existingView = index < sourceViews.count ? sourceViews[index] : nil;
+    NSNumber *existingSignature = index < sourceSignatures.count ? sourceSignatures[index] : nil;
+    RCTUIView *view = nil;
+    NSNumber *nextSignature = @(segment.signature);
+
+    NSUInteger remainingNextSignatureCount = remainingNextSignatureCounts[nextSignature].unsignedIntegerValue;
+    if (remainingNextSignatureCount > 1) {
+      remainingNextSignatureCounts[nextSignature] = @(remainingNextSignatureCount - 1);
+    } else {
+      [remainingNextSignatureCounts removeObjectForKey:nextSignature];
+    }
+
+    // 1. Exact positional match: the same view still represents the same segment.
+    if (existingView && ![reusedViews containsObject:existingView] && matchesKind(existingView, segment) &&
+        [existingSignature isEqual:nextSignature]) {
+      view = existingView;
+    }
+
+    // 2. Signature-based fallback: find an unused view with exact same signature.
+    if (!view) {
+      NSMutableArray<NSNumber *> *candidateIndices = signatureToIndices[nextSignature];
+      while (candidateIndices.count > 0) {
+        NSUInteger candidateIdx = candidateIndices.firstObject.unsignedIntegerValue;
+        [candidateIndices removeObjectAtIndex:0];
+        RCTUIView *candidate = sourceViews[candidateIdx];
+        if (![reusedViews containsObject:candidate] && matchesKind(candidate, segment)) {
+          view = candidate;
+          break;
+        }
+      }
+    }
+
+    // 3. Same-kind positional update. If this old signature appears later in
+    // the new list, leave the view available for that exact reuse instead.
+    if (!view && existingView && ![reusedViews containsObject:existingView] && matchesKind(existingView, segment) &&
+        (existingSignature == nil || remainingNextSignatureCounts[existingSignature].unsignedIntegerValue == 0)) {
+      updateView(existingView, segment);
+      view = existingView;
+    }
+
+    // 4. No reusable view found — create a new one.
+    if (!view) {
+      view = createView(segment);
+      attachView(view);
+    }
+
+    [nextViews addObject:view];
+    [nextSignatures addObject:nextSignature];
+    [reusedViews addObject:view];
+  }];
+
+  [sourceViews enumerateObjectsUsingBlock:^(RCTUIView *view, NSUInteger index, BOOL *stop) {
+    if (![reusedViews containsObject:view]) {
+      removeView(view);
+    }
+  }];
+
+  ENRMSegmentReconciliationResult *result = [[ENRMSegmentReconciliationResult alloc] init];
+  result.views = nextViews;
+  result.signatures = nextSignatures;
+  return result;
+}
+@end