react-native-enriched-markdown-scaffold 0.7.4-scaffold.8 → 1.0.2-scaffold.1

package/ios/utils/ENRMTextViewSetup.h

@@ -30,26 +30,32 @@ static inline void ENRMDetachLayoutManager(ENRMPlatformTextView *textView)
   }
 }
 
-static inline CGSize ENRMMeasureMarkdownText(ENRMPlatformTextView *textView, CGFloat maxWidth, StyleConfig *config,
-                                             BOOL allowTrailingMargin, CGFloat lastElementMarginBottom)
+/// Turns a raw TextKit layout pass into the final measured size. Shared by
+/// the view-backed path (`ENRMMeasureMarkdownText`) and the view-free path
+/// (`ENRMMeasureMarkdownViewFree`) so both measure with one algorithm.
+///
+/// Steps, in order:
+/// - Multiline pin: if the first line fragment doesn't span all glyphs the
+///   text wrapped, and returning the tight usedRect width would let flexShrink
+///   narrow the view below maxWidth, re-wrapping at the narrower width and
+///   mismatching the measured height — so multiline content reports maxWidth,
+///   while single-line content keeps its tight width for shrink-to-fit.
+/// - Subtract the extra line fragment (iOS counts a trailing newline's empty
+///   line fragment into usedRect).
+/// - Add code-block padding when the last element is a code block, and the
+///   trailing margin when enabled.
+/// - Round up to the pixel grid of `scale` (pass `RCTScreenScale()` on main;
+///   off-main callers must pass `LayoutContext::pointScaleFactor` instead —
+///   `RCTScreenScale()` dispatch_syncs to main on first use, which the
+///   measure path must never do, see issue #550).
+static inline CGSize ENRMFinalizeMeasuredTextSize(ENRMTextLayoutResult layout, NSLayoutManager *layoutManager,
+                                                  NSAttributedString *text, CGFloat maxWidth, StyleConfig *config,
+                                                  BOOL allowTrailingMargin, CGFloat lastElementMarginBottom,
+                                                  CGFloat scale)
 {
-  NSAttributedString *text = ENRMGetAttributedText(textView);
-  if (text.length == 0) {
-    return CGSizeZero;
-  }
-
-  ENRMTextLayoutResult layout = ENRMMeasureTextLayout(textView, maxWidth);
-
   CGFloat measuredWidth = layout.usedRect.size.width;
   CGFloat measuredHeight = layout.usedRect.size.height;
 
-  // Detect multiline content by checking if the layout produced more than one
-  // line fragment. When text wraps, returning the tight usedRect width lets
-  // flexShrink narrow the view below maxWidth, causing re-wrap at the narrower
-  // width and a height mismatch. Pin to maxWidth for multiline content so Yoga
-  // assigns the width the text was actually measured at. Single-line content
-  // keeps its tight width for shrink-to-fit behavior.
-  NSLayoutManager *layoutManager = textView.layoutManager;
   NSUInteger glyphCount = [layoutManager numberOfGlyphs];
   if (glyphCount > 0) {
     NSRange firstLineRange;
@@ -71,8 +77,20 @@ static inline CGSize ENRMMeasureMarkdownText(ENRMPlatformTextView *textView, CGF
     measuredHeight += lastElementMarginBottom;
   }
 
-  CGFloat scale = RCTScreenScale();
   return CGSizeMake(ceil(measuredWidth * scale) / scale, ceil(measuredHeight * scale) / scale);
 }
 
+static inline CGSize ENRMMeasureMarkdownText(ENRMPlatformTextView *textView, CGFloat maxWidth, StyleConfig *config,
+                                             BOOL allowTrailingMargin, CGFloat lastElementMarginBottom)
+{
+  NSAttributedString *text = ENRMGetAttributedText(textView);
+  if (text.length == 0) {
+    return CGSizeZero;
+  }
+
+  ENRMTextLayoutResult layout = ENRMMeasureTextLayout(textView, maxWidth);
+  return ENRMFinalizeMeasuredTextSize(layout, textView.layoutManager, text, maxWidth, config, allowTrailingMargin,
+                                      lastElementMarginBottom, RCTScreenScale());
+}
+
 NS_ASSUME_NONNULL_END

package/ios/utils/EditMenuUtils.m

@@ -47,13 +47,34 @@ static UIAction *_Nullable createCopyImageURLAction(NSArray<NSString *> *imageUR
                            handler:^(__kindof UIAction *action) { copyStringToPasteboard(urlsToCopy); }];
 }
 
+/// Rebuilds the standard-edit menu with the system Copy swapped for the enhanced
+/// copy action. All other system items are kept — dropping them would remove
+/// Select All, which on iOS 16+ is the only way to start a selection from the
+/// long-press menu of a non-editable text view.
 static UIMenu *createEnhancedStandardEditMenu(UIMenu *originalMenu, UIAction *copyAction)
 {
+  NSMutableArray<UIMenuElement *> *children = [NSMutableArray arrayWithCapacity:originalMenu.children.count];
+  BOOL replacedCopy = NO;
+
+  for (UIMenuElement *element in originalMenu.children) {
+    if (!replacedCopy && [element isKindOfClass:[UICommand class]] &&
+        ((UICommand *)element).action == @selector(copy:)) {
+      [children addObject:copyAction];
+      replacedCopy = YES;
+      continue;
+    }
+    [children addObject:element];
+  }
+
+  if (!replacedCopy) {
+    [children insertObject:copyAction atIndex:0];
+  }
+
   return [UIMenu menuWithTitle:originalMenu.title
                          image:originalMenu.image
                     identifier:originalMenu.identifier
                        options:originalMenu.options
-                      children:@[ copyAction ]];
+                      children:children];
 }
 
 static void addOptionalAction(NSMutableArray<UIMenuElement *> *array, UIAction *_Nullable action)

package/ios/utils/ImageRequestHeaderUtils.h

@@ -0,0 +1,35 @@
+#pragma once
+
+#import <Foundation/Foundation.h>
+
+#ifdef __cplusplus
+#include <vector>
+
+template <typename T>
+static bool ENRMImageRequestHeadersChanged(const std::vector<T> &oldHeaders, const std::vector<T> &newHeaders)
+{
+  if (newHeaders.size() != oldHeaders.size()) {
+    return true;
+  }
+  for (size_t i = 0; i < newHeaders.size(); i++) {
+    if (newHeaders[i].name != oldHeaders[i].name || newHeaders[i].value != oldHeaders[i].value) {
+      return true;
+    }
+  }
+  return false;
+}
+
+template <typename T>
+static NSDictionary<NSString *, NSString *> *_Nullable ENRMImageRequestHeadersFromProps(const std::vector<T> &headers)
+{
+  if (headers.empty()) {
+    return nil;
+  }
+  NSMutableDictionary<NSString *, NSString *> *result = [NSMutableDictionary dictionaryWithCapacity:headers.size()];
+  for (const auto &header : headers) {
+    result[@(header.name.c_str())] = @(header.value.c_str());
+  }
+  return [result copy];
+}
+
+#endif

package/ios/utils/LastElementUtils.h

@@ -4,6 +4,7 @@
 NS_ASSUME_NONNULL_BEGIN
 
 static NSString *const CodeBlockAttributeName = @"CodeBlock";
+static NSString *const CodeBlockIndentAttributeName = @"CodeBlockIndent";
 
 /**
  * Returns YES when the last semantic block in the storage is a code block, ignoring any

package/ios/utils/ListMarkerDrawer.m

@@ -5,11 +5,7 @@
 #import "RenderContext.h"
 #import "StyleConfig.h"
 
-extern NSString *const ListDepthAttribute;
-extern NSString *const ListTypeAttribute;
-extern NSString *const ListItemNumberAttribute;
-extern NSString *const TaskItemAttribute;
-extern NSString *const TaskCheckedAttribute;
+extern NSString *const ListItemMarkerStartAttribute;
 
 @implementation ListMarkerDrawer {
   StyleConfig *_config;
@@ -44,13 +40,13 @@ extern NSString *const TaskCheckedAttribute;
                                  if (charRange.location == NSNotFound)
                                    return;
 
-                                 // 1. Fetch all attributes at once for efficiency
                                  NSDictionary *attrs = [storage attributesAtIndex:charRange.location
                                                                    effectiveRange:NULL];
-                                 if (!attrs[ListDepthAttribute])
+                                 NSArray *markers = attrs[ListItemMarkerStartAttribute];
+                                 if (![markers isKindOfClass:[NSArray class]] || markers.count == 0)
                                    return;
 
-                                 // 2. Identify the start of the paragraph
+                                 // Identify the start of the paragraph
                                  NSRange paraRange = [storage.string paragraphRangeForRange:charRange];
                                  if (charRange.location != paraRange.location ||
                                      [drawnParagraphs containsObject:@(paraRange.location)])
@@ -61,30 +57,28 @@ extern NSString *const TaskCheckedAttribute;
 
                                  CGPoint glyphLoc = [layoutManager locationForGlyphAtIndex:glyphRange.location];
                                  CGFloat baselineY = origin.y + rect.origin.y + glyphLoc.y;
-                                 CGFloat markerX;
-                                 if (isRTL) {
-                                   markerX = origin.x + usedRect.origin.x + usedRect.size.width + gap;
-                                 } else {
-                                   markerX = origin.x + usedRect.origin.x - gap;
-                                 }
-
-                                 // 4. Draw marker based on type
-                                 if ([attrs[TaskItemAttribute] boolValue]) {
-                                   UIFont *font = attrs[NSFontAttributeName] ?: [self defaultFont];
-                                   BOOL checked = [attrs[TaskCheckedAttribute] boolValue];
-                                   const CGFloat size = [_config taskListCheckboxSize];
-                                   CGFloat checkboxX = isRTL ? markerX + size / 2.0 : markerX - size / 2.0;
-                                   [self drawCheckboxAtX:checkboxX
-                                                 centerY:baselineY - (font.capHeight / 2.0)
-                                                 checked:checked];
-                                 } else if ([attrs[ListTypeAttribute] integerValue] == ListTypeUnordered) {
-                                   UIFont *font = attrs[NSFontAttributeName] ?: [self defaultFont];
-                                   NSInteger depth = [attrs[ListDepthAttribute] integerValue];
-                                   [self drawBulletAtX:markerX
-                                               centerY:baselineY - (font.xHeight + font.capHeight) / 4.0
-                                                 depth:depth];
-                                 } else {
-                                   [self drawOrderedMarkerAtX:markerX attrs:attrs baselineY:baselineY isRTL:isRTL];
+                                 UIFont *font = attrs[NSFontAttributeName] ?: [self defaultFont];
+
+                                 for (ENRMListMarkerDescriptor *marker in markers) {
+                                   CGFloat markerX = isRTL ? origin.x + container.size.width - marker.indent + gap
+                                                           : origin.x + marker.indent - gap;
+
+                                   if (marker.isTask) {
+                                     const CGFloat size = [_config taskListCheckboxSize];
+                                     CGFloat checkboxX = isRTL ? markerX + size / 2.0 : markerX - size / 2.0;
+                                     [self drawCheckboxAtX:checkboxX
+                                                   centerY:baselineY - (font.capHeight / 2.0)
+                                                   checked:marker.isChecked];
+                                   } else if (marker.listType == ListTypeUnordered) {
+                                     [self drawBulletAtX:markerX
+                                                 centerY:baselineY - (font.xHeight + font.capHeight) / 4.0
+                                                   depth:marker.depth];
+                                   } else {
+                                     [self drawOrderedMarkerAtX:markerX
+                                                         number:marker.number
+                                                      baselineY:baselineY
+                                                          isRTL:isRTL];
+                                   }
                                  }
                                }];
 }
@@ -167,17 +161,10 @@ extern NSString *const TaskCheckedAttribute;
                    y:y];
 }
 
-- (void)drawOrderedMarkerAtX:(CGFloat)boundaryX
-                       attrs:(NSDictionary *)attrs
-                   baselineY:(CGFloat)baselineY
-                       isRTL:(BOOL)isRTL
+- (void)drawOrderedMarkerAtX:(CGFloat)boundaryX number:(NSInteger)number baselineY:(CGFloat)baselineY isRTL:(BOOL)isRTL
 {
-  NSNumber *num = attrs[ListItemNumberAttribute];
-  if (!num)
-    return;
-
-  NSString *text = isRTL ? [NSString stringWithFormat:@".%ld", (long)num.integerValue]
-                         : [NSString stringWithFormat:@"%ld.", (long)num.integerValue];
+  NSString *text =
+      isRTL ? [NSString stringWithFormat:@".%ld", (long)number] : [NSString stringWithFormat:@"%ld.", (long)number];
   UIFont *font = [_config listMarkerFont] ?: [self defaultFont];
 
   NSDictionary *mAttrs = @{NSFontAttributeName : font, NSForegroundColorAttributeName : [_config listStyleMarkerColor]};

package/ios/utils/MarkdownASTSerializer.m

@@ -22,6 +22,10 @@ static void serializeNode(MarkdownASTNode *node, NSMutableString *buffer)
       break;
 
     case MarkdownNodeTypeLineBreak:
+      [buffer appendString:@"\\\n"];
+      break;
+
+    case MarkdownNodeTypeSoftBreak:
       [buffer appendString:@"\n"];
       break;
 

package/ios/utils/ParagraphStyleUtils.h

@@ -45,6 +45,11 @@ NSUInteger applyBlockSpacingBefore(NSMutableAttributedString *output, NSUInteger
 void applyBlockSpacingAfter(NSMutableAttributedString *output, CGFloat marginBottom);
 void applyLineHeight(NSMutableAttributedString *output, NSRange range, CGFloat lineHeight);
 void applyBaselineOffset(NSMutableAttributedString *output, NSRange range);
+
+/// True when the range contains a block (non-inline) image attachment. Lines holding
+/// such attachments must not be clamped by maximumLineHeight or the image box
+/// overflows the line and paints over surrounding content.
+BOOL ENRMRangeContainsBlockImage(NSAttributedString *output, NSRange range);
 void applyTextAlignment(NSMutableAttributedString *output, NSRange range, NSTextAlignment textAlign);
 NSTextAlignment textAlignmentFromString(NSString *textAlign);
 

package/ios/utils/ParagraphStyleUtils.m

@@ -1,5 +1,6 @@
 #import "ParagraphStyleUtils.h"
 #import "ENRMFeatureFlags.h"
+#import "ENRMImageAttachment.h"
 #import "LastElementUtils.h"
 #import <React/RCTI18nUtil.h>
 
@@ -246,6 +247,21 @@ void applyBlockSpacingAfter(NSMutableAttributedString *output, CGFloat marginBot
   [output addAttribute:NSParagraphStyleAttributeName value:spacerStyle range:NSMakeRange(spacerLocation, 1)];
 }
 
+BOOL ENRMRangeContainsBlockImage(NSAttributedString *output, NSRange range)
+{
+  __block BOOL found = NO;
+  [output enumerateAttribute:NSAttachmentAttributeName
+                     inRange:range
+                     options:0
+                  usingBlock:^(id value, __unused NSRange attrRange, BOOL *stop) {
+                    if ([value isKindOfClass:[ENRMImageAttachment class]] && !((ENRMImageAttachment *)value).isInline) {
+                      found = YES;
+                      *stop = YES;
+                    }
+                  }];
+  return found;
+}
+
 void applyLineHeight(NSMutableAttributedString *output, NSRange range, CGFloat lineHeight)
 {
   if (lineHeight <= 0) {
@@ -266,10 +282,12 @@ void applyLineHeight(NSMutableAttributedString *output, NSRange range, CGFloat l
                   }];
 #endif
 
+  BOOL hasBlockImage = ENRMRangeContainsBlockImage(output, range);
+
   NSMutableParagraphStyle *style = getOrCreateParagraphStyle(output, range.location);
 
   style.minimumLineHeight = lineHeight;
-  style.maximumLineHeight = hasMath ? 0 : lineHeight;
+  style.maximumLineHeight = (hasMath || hasBlockImage) ? 0 : lineHeight;
 
   [output addAttribute:NSParagraphStyleAttributeName value:style range:range];
 }
@@ -284,7 +302,8 @@ void applyBaselineOffset(NSMutableAttributedString *output, NSRange range)
     return;
   }
 
-  __block CGFloat maximumLineHeight = 0;
+  // Math paragraphs leave maximumLineHeight at 0, so fall back to minimumLineHeight.
+  __block CGFloat targetLineHeight = 0;
   [output enumerateAttribute:NSParagraphStyleAttributeName
                      inRange:range
                      options:NSAttributedStringEnumerationLongestEffectiveRangeNotRequired
@@ -292,29 +311,59 @@ void applyBaselineOffset(NSMutableAttributedString *output, NSRange range)
                     if (!paragraphStyle) {
                       return;
                     }
-                    maximumLineHeight = MAX(paragraphStyle.maximumLineHeight, maximumLineHeight);
+                    CGFloat clamp = MAX(paragraphStyle.maximumLineHeight, paragraphStyle.minimumLineHeight);
+                    targetLineHeight = MAX(clamp, targetLineHeight);
                   }];
 
-  if (maximumLineHeight <= 0) {
+  if (targetLineHeight <= 0) {
     return;
   }
 
-  __block CGFloat maximumFontLineHeight = 0;
-  [output enumerateAttribute:NSFontAttributeName
-                     inRange:range
-                     options:NSAttributedStringEnumerationLongestEffectiveRangeNotRequired
-                  usingBlock:^(UIFont *font, __unused NSRange subrange, __unused BOOL *stop) {
-                    if (!font) {
-                      return;
-                    }
-                    maximumFontLineHeight = MAX(UIFontLineHeight(font), maximumFontLineHeight);
-                  }];
+  // Center on real text; on a math-only line center the math box instead of its font.
+  __block CGFloat textLineHeight = 0;
+#if ENRICHED_MARKDOWN_MATH
+  __block BOOL hasMath = NO;
+#endif
+  [output enumerateAttributesInRange:range
+                             options:0
+                          usingBlock:^(NSDictionary<NSAttributedStringKey, id> *attrs, __unused NSRange subrange,
+                                       __unused BOOL *stop) {
+#if ENRICHED_MARKDOWN_MATH
+                            if ([attrs[NSAttachmentAttributeName] isKindOfClass:[ENRMMathInlineAttachment class]]) {
+                              hasMath = YES;
+                              return;
+                            }
+#endif
+                            UIFont *font = attrs[NSFontAttributeName];
+                            if (font) {
+                              textLineHeight = MAX(UIFontLineHeight(font), textLineHeight);
+                            }
+                          }];
+
+  CGFloat contentLineHeight = textLineHeight;
+
+#if ENRICHED_MARKDOWN_MATH
+  // Math only grows the content height, so measure it (parsing LaTeX) only when text
+  // alone wouldn't already fill the line.
+  if (hasMath && targetLineHeight > textLineHeight) {
+    __block CGFloat mathBoxHeight = 0;
+    [output enumerateAttribute:NSAttachmentAttributeName
+                       inRange:range
+                       options:0
+                    usingBlock:^(id value, __unused NSRange subrange, __unused BOOL *stop) {
+                      if ([value isKindOfClass:[ENRMMathInlineAttachment class]]) {
+                        mathBoxHeight = MAX(((ENRMMathInlineAttachment *)value).boxHeight, mathBoxHeight);
+                      }
+                    }];
+    contentLineHeight = MAX(textLineHeight, mathBoxHeight);
+  }
+#endif
 
-  if (maximumFontLineHeight <= 0 || maximumLineHeight < maximumFontLineHeight) {
+  if (contentLineHeight <= 0 || targetLineHeight <= contentLineHeight) {
     return;
   }
 
-  CGFloat baseLineOffset = (maximumLineHeight - maximumFontLineHeight) / 2.0;
+  CGFloat baseLineOffset = (targetLineHeight - contentLineHeight) / 2.0;
 
   [output enumerateAttribute:NSBaselineOffsetAttributeName
                      inRange:range
@@ -323,7 +372,18 @@ void applyBaselineOffset(NSMutableAttributedString *output, NSRange range)
                     if (existingOffset != nil) {
                       return;
                     }
-                    [output addAttribute:NSBaselineOffsetAttributeName value:@(baseLineOffset) range:subrange];
+                    [output enumerateAttribute:NSAttachmentAttributeName
+                                       inRange:subrange
+                                       options:0
+                                    usingBlock:^(id attachment, NSRange attachmentRange, BOOL *innerStop) {
+                                      if ([attachment isKindOfClass:[ENRMImageAttachment class]] &&
+                                          !((ENRMImageAttachment *)attachment).isInline) {
+                                        return;
+                                      }
+                                      [output addAttribute:NSBaselineOffsetAttributeName
+                                                     value:@(baseLineOffset)
+                                                     range:attachmentRange];
+                                    }];
                   }];
 }
 

package/ios/utils/RenderedMarkdownSegment.h

@@ -7,7 +7,12 @@
 
 NS_ASSUME_NONNULL_BEGIN
 
-typedef NS_ENUM(NSInteger, ENRMSegmentKind) { ENRMSegmentKindText, ENRMSegmentKindTable, ENRMSegmentKindMath };
+typedef NS_ENUM(NSInteger, ENRMSegmentKind) {
+  ENRMSegmentKindText,
+  ENRMSegmentKindTable,
+  ENRMSegmentKindMath,
+  ENRMSegmentKindCodeBlock
+};
 
 @interface ENRMTextSegment : NSObject
 @property (nonatomic, strong) NSArray<MarkdownASTNode *> *nodes;
@@ -24,15 +29,22 @@ typedef NS_ENUM(NSInteger, ENRMSegmentKind) { ENRMSegmentKindText, ENRMSegmentKi
 + (instancetype)segmentWithLatex:(NSString *)latex;
 @end
 
+@interface ENRMCodeBlockSegment : NSObject
+@property (nonatomic, strong) MarkdownASTNode *codeBlockNode;
++ (instancetype)segmentWithCodeBlockNode:(MarkdownASTNode *)node;
+@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;
+@property (nonatomic, strong, nullable) ENRMCodeBlockSegment *codeBlockSegment;
 + (instancetype)textSegmentWithResult:(ENRMRenderResult *)result signature:(uint64_t)signature;
 + (instancetype)tableSegmentWithSegment:(ENRMTableSegment *)segment signature:(uint64_t)signature;
 + (instancetype)mathSegmentWithSegment:(ENRMMathSegment *)segment signature:(uint64_t)signature;
++ (instancetype)codeBlockSegmentWithSegment:(ENRMCodeBlockSegment *)segment signature:(uint64_t)signature;
 @end
 
 #ifdef __cplusplus

package/ios/utils/RenderedMarkdownSegment.m

@@ -31,6 +31,16 @@
 }
 @end
 
+@implementation ENRMCodeBlockSegment
++ (instancetype)segmentWithCodeBlockNode:(MarkdownASTNode *)node
+{
+  NSParameterAssert(node != nil);
+  ENRMCodeBlockSegment *segment = [[ENRMCodeBlockSegment alloc] init];
+  segment.codeBlockNode = node;
+  return segment;
+}
+@end
+
 @implementation ENRMRenderedSegment
 + (instancetype)textSegmentWithResult:(ENRMRenderResult *)result signature:(uint64_t)signature
 {
@@ -61,6 +71,16 @@
   segment.signature = signature;
   return segment;
 }
+
++ (instancetype)codeBlockSegmentWithSegment:(ENRMCodeBlockSegment *)codeBlockSegment signature:(uint64_t)signature
+{
+  NSParameterAssert(codeBlockSegment != nil);
+  ENRMRenderedSegment *segment = [[ENRMRenderedSegment alloc] init];
+  segment.kind = ENRMSegmentKindCodeBlock;
+  segment.codeBlockSegment = codeBlockSegment;
+  segment.signature = signature;
+  return segment;
+}
 @end
 
 // FNV-1a 64-bit hash for segment signatures. Collisions are theoretically

package/ios/utils/SegmentRenderer.m

@@ -33,7 +33,13 @@ static NSArray *ENRMSplitASTIntoSegments(MarkdownASTNode *root)
 #endif
     }
 #endif
-    else {
+    else if (child.type == MarkdownNodeTypeCodeBlock) {
+      if (currentTextNodes.count > 0) {
+        [segments addObject:[ENRMTextSegment segmentWithNodes:[currentTextNodes copy]]];
+        [currentTextNodes removeAllObjects];
+      }
+      [segments addObject:[ENRMCodeBlockSegment segmentWithCodeBlockNode:child]];
+    } else {
       [currentTextNodes addObject:child];
     }
   }
@@ -53,9 +59,10 @@ NSArray<ENRMRenderedSegment *> *ENRMRenderSegmentsFromAST(MarkdownASTNode *ast,
   NSArray *segments = ENRMSplitASTIntoSegments(ast);
   NSMutableArray<ENRMRenderedSegment *> *renderedSegments = [NSMutableArray array];
 
-  static const uint64_t kTextKindSalt = 0x7465787400000000ULL;  // "text"
-  static const uint64_t kTableKindSalt = 0x7461626C00000000ULL; // "tabl"
-  static const uint64_t kMathKindSalt = 0x6D61746800000000ULL;  // "math"
+  static const uint64_t kTextKindSalt = 0x7465787400000000ULL;      // "text"
+  static const uint64_t kTableKindSalt = 0x7461626C00000000ULL;     // "tabl"
+  static const uint64_t kMathKindSalt = 0x6D61746800000000ULL;      // "math"
+  static const uint64_t kCodeBlockKindSalt = 0x63626C6B00000000ULL; // "cblk"
 
   for (id segment in segments) {
     if ([segment isKindOfClass:[ENRMTextSegment class]]) {
@@ -82,6 +89,12 @@ NSArray<ENRMRenderedSegment *> *ENRMRenderSegmentsFromAST(MarkdownASTNode *ast,
       [renderedSegments addObject:[ENRMRenderedSegment mathSegmentWithSegment:mathSegment signature:signature]];
     }
 #endif
+    else if ([segment isKindOfClass:[ENRMCodeBlockSegment class]]) {
+      ENRMCodeBlockSegment *codeBlockSegment = (ENRMCodeBlockSegment *)segment;
+      uint64_t signature = ENRMSignatureForNode(codeBlockSegment.codeBlockNode) ^ kCodeBlockKindSalt;
+      [renderedSegments addObject:[ENRMRenderedSegment codeBlockSegmentWithSegment:codeBlockSegment
+                                                                         signature:signature]];
+    }
   }
 
   return renderedSegments;

package/ios/utils/StreamingMarkdownFilter.h

@@ -9,11 +9,21 @@ typedef NS_ENUM(NSInteger, ENRMTableStreamingMode) {
   ENRMTableStreamingModeProgressive,
 };
 
+typedef NS_ENUM(NSInteger, ENRMCodeBlockStreamingMode) {
+  ENRMCodeBlockStreamingModeHidden = 0,
+  ENRMCodeBlockStreamingModeProgressive,
+};
+
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-NSString *ENRMRenderableMarkdownForStreaming(NSString *markdown, ENRMTableStreamingMode tableMode);
+// Filtered markdown for the current streaming tick. When non-NULL,
+// outEndsInsideOpenCodeFence reports whether the result ends inside a still-open
+// fenced code block (the trailing block whose chrome the renderer defers).
+NSString *ENRMRenderableMarkdownForStreaming(NSString *markdown, ENRMTableStreamingMode tableMode,
+                                             ENRMCodeBlockStreamingMode codeBlockMode,
+                                             BOOL *_Nullable outEndsInsideOpenCodeFence);
 
 #ifdef __cplusplus
 }