react-native-jet-markdown 0.2.2 → 0.2.3-beta.1

package/ios/views/JMDBlockStackView.m

@@ -10,58 +10,81 @@
   CGFloat _gap;
 }
 
+// Rebinds in place: a subview of the right kind at the same index is
+// reused, anything else is replaced. List recycling rebinds whole trees, so
+// the common case (same block kinds, different content) allocates nothing.
 - (void)setBlocks:(NSArray<JMDMeasuredBlock *> *)blocks gap:(CGFloat)gap {
   _measured = blocks;
   _gap = gap;
 
-  for (UIView *subview in [self.subviews copy]) {
-    [subview removeFromSuperview];
+  NSArray<UIView *> *existing = self.subviews;
+  for (NSUInteger i = 0; i < blocks.count; i++) {
+    UIView *old = i < existing.count ? existing[i] : nil;
+    UIView *view = [self bindView:old to:blocks[i]];
+    if (view != old) {
+      [old removeFromSuperview];
+      [self insertSubview:view atIndex:i];
+    }
   }
-  for (JMDMeasuredBlock *measured in blocks) {
-    [self addSubview:[self createViewFor:measured]];
+  for (NSUInteger i = blocks.count; i < existing.count; i++) {
+    [existing[i] removeFromSuperview];
   }
   [self setNeedsLayout];
 }
 
-- (UIView *)createViewFor:(JMDMeasuredBlock *)measured {
+- (UIView *)bindView:(nullable UIView *)old to:(JMDMeasuredBlock *)measured {
   switch (measured.block.kind) {
     case JMDBlockKindText: {
-      JMDBlockTextView *view = [[JMDBlockTextView alloc] initWithFrame:CGRectZero];
+      JMDBlockTextView *view = [old isKindOfClass:JMDBlockTextView.class]
+          ? (JMDBlockTextView *)old
+          : [[JMDBlockTextView alloc] initWithFrame:CGRectZero];
       view.host = self.host;
       view.spoilerColor = measured.block.spoilerColor;
       view.spoilerRadius = measured.block.spoilerRadius;
       view.spoilerContinuous = measured.block.spoilerContinuous;
-      view.attributedText = measured.block.attributedText;
+      [view bindTextStorage:measured.textStorage];
       return view;
     }
     case JMDBlockKindCode: {
-      JMDCodeBlockView *view = [[JMDCodeBlockView alloc] initWithFrame:CGRectZero];
+      JMDCodeBlockView *view = [old isKindOfClass:JMDCodeBlockView.class]
+          ? (JMDCodeBlockView *)old
+          : [[JMDCodeBlockView alloc] initWithFrame:CGRectZero];
       [view bind:measured];
       return view;
     }
     case JMDBlockKindQuote: {
-      JMDQuoteView *view = [[JMDQuoteView alloc] initWithFrame:CGRectZero];
+      JMDQuoteView *view = [old isKindOfClass:JMDQuoteView.class]
+          ? (JMDQuoteView *)old
+          : [[JMDQuoteView alloc] initWithFrame:CGRectZero];
       [view bind:measured gap:_gap host:self.host];
       return view;
     }
     case JMDBlockKindList: {
-      JMDListBlockView *view = [[JMDListBlockView alloc] initWithFrame:CGRectZero];
+      JMDListBlockView *view = [old isKindOfClass:JMDListBlockView.class]
+          ? (JMDListBlockView *)old
+          : [[JMDListBlockView alloc] initWithFrame:CGRectZero];
       [view bind:measured gap:_gap host:self.host];
       return view;
     }
     case JMDBlockKindDivider: {
-      UIView *view = [[UIView alloc] initWithFrame:CGRectZero];
+      UIView *view = (old != nil && old.class == UIView.class)
+          ? old
+          : [[UIView alloc] initWithFrame:CGRectZero];
       view.backgroundColor = measured.block.dividerColor;
       return view;
     }
     case JMDBlockKindImage: {
-      JMDImageView *view = [[JMDImageView alloc] initWithFrame:CGRectZero];
+      JMDImageView *view = [old isKindOfClass:JMDImageView.class]
+          ? (JMDImageView *)old
+          : [[JMDImageView alloc] initWithFrame:CGRectZero];
       view.host = self.host;
       [view bind:measured.block];
       return view;
     }
     case JMDBlockKindTable: {
-      JMDTableView *view = [[JMDTableView alloc] initWithFrame:CGRectZero];
+      JMDTableView *view = [old isKindOfClass:JMDTableView.class]
+          ? (JMDTableView *)old
+          : [[JMDTableView alloc] initWithFrame:CGRectZero];
       [view bind:measured host:self.host];
       return view;
     }
@@ -69,7 +92,6 @@
   return [[UIView alloc] initWithFrame:CGRectZero];
 }
 
-
 // Never the hit view itself: markdown touches belong to the host component
 // view; only nested scrollers (code blocks, tables) claim touches.
 - (UIView *)hitTest:(CGPoint)point withEvent:(UIEvent *)event {

package/ios/views/JMDBlockTextView.h

@@ -9,12 +9,17 @@ NS_ASSUME_NONNULL_BEGIN
 /// hit-tests links, mentions, and spoilers by character range.
 @interface JMDBlockTextView : UIView
 
-@property (nonatomic, copy, nullable) NSAttributedString *attributedText;
+/// The bound storage's contents (nil before bind).
+@property (nonatomic, readonly, nullable) NSAttributedString *attributedText;
 @property (nonatomic, weak, nullable) id<JMDMarkdownHost> host;
 @property (nonatomic, strong, nullable) UIColor *spoilerColor;
 @property (nonatomic, assign) CGFloat spoilerRadius;
 @property (nonatomic, assign) BOOL spoilerContinuous;
 
+/// Binds a measure-time TextKit stack (see JMDMeasuredBlock); the view
+/// draws with it and never lays text out itself.
+- (void)bindTextStorage:(NSTextStorage *)storage;
+
 /// Attributed-string attributes at a point in this view's coordinates;
 /// nil when the point is not on a glyph. Used by the host for hit testing.
 - (nullable NSDictionary *)attributesAtPoint:(CGPoint)point;

package/ios/views/JMDBlockTextView.m

@@ -3,10 +3,12 @@
 #import <CoreText/CoreText.h>
 
 @implementation JMDBlockTextView {
+  // Owned by the measured block and shared with every view bound to the
+  // same cached content (and the layout thread that built it), so it is
+  // never mutated here: spoiler hiding is a draw-time clip.
+  NSTextStorage *_textStorage;
   NSLayoutManager *_layoutManager;
   NSTextContainer *_textContainer;
-  NSTextStorage *_textStorage;
-  NSMutableSet<NSNumber *> *_hiddenSpoilers;
 }
 
 - (instancetype)initWithFrame:(CGRect)frame {
@@ -23,108 +25,82 @@
   return nil;
 }
 
-- (void)setAttributedText:(NSAttributedString *)attributedText {
-  if (![_attributedText isEqualToAttributedString:attributedText]) {
-    _attributedText = [attributedText copy];
-    _layoutManager = nil;
-    // The hiding state lives in the storage, which is rebuilt (with the
-    // original colors) alongside the layout manager.
-    [_hiddenSpoilers removeAllObjects];
+- (void)bindTextStorage:(NSTextStorage *)storage {
+  if (_textStorage != storage) {
+    _textStorage = storage;
+    _layoutManager = storage.layoutManagers.firstObject;
+    _textContainer = _layoutManager.textContainers.firstObject;
     self.isAccessibilityElement = YES;
-    self.accessibilityLabel = attributedText.string;
+    self.accessibilityLabel = storage.string;
     self.accessibilityTraits = UIAccessibilityTraitStaticText;
-    [self setNeedsDisplay];
   }
+  // Spoiler styling and host may change without the storage changing.
+  [self setNeedsDisplay];
 }
 
-// Lazy TextKit stack shared by drawing, overlay geometry, and hit-testing
-// (and configured identically to the measurer's) — one engine, so they can
-// never disagree about line positions.
-- (NSLayoutManager *)layoutManagerForBounds {
-  if (_layoutManager == nil && _attributedText != nil) {
-    _textStorage = [[NSTextStorage alloc] initWithAttributedString:_attributedText];
-    _layoutManager = [NSLayoutManager new];
-    _textContainer =
-        [[NSTextContainer alloc] initWithSize:CGSizeMake(self.bounds.size.width, CGFLOAT_MAX)];
-    _textContainer.lineFragmentPadding = 0;
-    [_layoutManager addTextContainer:_textContainer];
-    [_textStorage addLayoutManager:_layoutManager];
-  } else if (_textContainer != nil &&
-             _textContainer.size.width != self.bounds.size.width) {
-    _textContainer.size = CGSizeMake(self.bounds.size.width, CGFLOAT_MAX);
-  }
-  return _layoutManager;
+- (NSAttributedString *)attributedText {
+  return _textStorage;
 }
 
 - (void)drawRect:(CGRect)rect {
-  NSLayoutManager *layoutManager = [self layoutManagerForBounds];
-  if (layoutManager == nil) {
+  if (_layoutManager == nil || _textStorage.length == 0) {
     return;
   }
-  // One engine for everything: the same layout manager that positions the
-  // overlays also draws the glyphs. NSStringDrawing typesets separately and
-  // disagrees with NSLayoutManager about font leading under a lineHeight
-  // cap (fonts with a nonzero line gap drift ~gap pt per line), which
-  // misaligned overlays on wrapped lines.
-  [self syncSpoilerHiding:layoutManager];
-  [self drawRunBackgrounds:layoutManager];
-  const NSRange glyphRange =
-      [layoutManager glyphRangeForTextContainer:self->_textContainer];
-  [layoutManager drawBackgroundForGlyphRange:glyphRange atPoint:CGPointZero];
-  [layoutManager drawGlyphsForGlyphRange:glyphRange atPoint:CGPointZero];
-  [self drawSpoilerCovers:layoutManager];
+  // One engine for everything: the layout manager that measured the block
+  // also positions the overlays and draws the glyphs. NSStringDrawing
+  // typesets separately and disagrees with NSLayoutManager about font
+  // leading under a lineHeight cap (fonts with a nonzero line gap drift
+  // ~gap pt per line), which misaligned overlays on wrapped lines.
+  const NSRange glyphRange = [_layoutManager glyphRangeForTextContainer:_textContainer];
+  [self drawRunBackgrounds];
+  CGContextRef context = UIGraphicsGetCurrentContext();
+  CGContextSaveGState(context);
+  [self clipHiddenSpoilers:context];
+  [_layoutManager drawBackgroundForGlyphRange:glyphRange atPoint:CGPointZero];
+  [_layoutManager drawGlyphsForGlyphRange:glyphRange atPoint:CGPointZero];
+  CGContextRestoreGState(context);
+  [self drawSpoilerCovers];
 }
 
-// Unrevealed spoiler text draws fully transparent — the cover hugs the
-// text, so glyphs would leak around it if drawn. Colors mutate on the
-// shared storage (color-only edits don't reflow); originals restore from
-// the immutable _attributedText on reveal.
-- (void)syncSpoilerHiding:(NSLayoutManager *)layoutManager {
-  if (self.host == nil || _attributedText.length == 0 || _textStorage == nil) {
+// Unrevealed spoiler text is hidden by clipping its line-box slices out of
+// the glyph draw (the cover hugs the text, so glyphs would leak around it).
+// Purely draw-time, per-view state; the shared storage stays untouched.
+- (void)clipHiddenSpoilers:(CGContextRef)context {
+  if (self.host == nil) {
     return;
   }
-  if (_hiddenSpoilers == nil) {
-    _hiddenSpoilers = [NSMutableSet new];
-  }
-  [_textStorage beginEditing];
-  [_attributedText
+  CGMutablePathRef hidden = CGPathCreateMutable();
+  __block BOOL any = NO;
+  [_textStorage
       enumerateAttribute:JMDSpoilerIDAttributeName
-                 inRange:NSMakeRange(0, _attributedText.length)
+                 inRange:NSMakeRange(0, _textStorage.length)
                  options:0
               usingBlock:^(NSNumber *spoilerId, NSRange range, BOOL *stop) {
-                if (spoilerId == nil) {
-                  return;
-                }
-                const BOOL shouldHide =
-                    ![self.host isSpoilerRevealed:spoilerId.integerValue];
-                const BOOL isHidden =
-                    [self->_hiddenSpoilers containsObject:spoilerId];
-                if (shouldHide == isHidden) {
+                if (spoilerId == nil ||
+                    [self.host isSpoilerRevealed:spoilerId.integerValue]) {
                   return;
                 }
-                if (shouldHide) {
-                  [self->_textStorage addAttributes:@{
-                    NSForegroundColorAttributeName : UIColor.clearColor,
-                    NSUnderlineColorAttributeName : UIColor.clearColor,
-                    NSStrikethroughColorAttributeName : UIColor.clearColor,
-                  }
-                                              range:range];
-                  [self->_hiddenSpoilers addObject:spoilerId];
-                } else {
-                  [self->_attributedText
-                      enumerateAttributesInRange:range
-                                         options:0
-                                      usingBlock:^(NSDictionary *attrs,
-                                                   NSRange subRange,
-                                                   BOOL *stopInner) {
-                                        [self->_textStorage
-                                            setAttributes:attrs
-                                                    range:subRange];
-                                      }];
-                  [self->_hiddenSpoilers removeObject:spoilerId];
-                }
+                const NSRange glyphs =
+                    [self->_layoutManager glyphRangeForCharacterRange:range
+                                                 actualCharacterRange:nil];
+                [self->_layoutManager
+                    enumerateEnclosingRectsForGlyphRange:glyphs
+                                withinSelectedGlyphRange:NSMakeRange(NSNotFound, 0)
+                                         inTextContainer:self->_textContainer
+                                              usingBlock:^(CGRect rect, BOOL *stopInner) {
+                                                // Padded past side bearings
+                                                // and italic overhang.
+                                                CGPathAddRect(hidden, NULL,
+                                                              CGRectInset(rect, -2, 0));
+                                                any = YES;
+                                              }];
               }];
-  [_textStorage endEditing];
+  if (any) {
+    CGContextAddRect(context, self.bounds);
+    CGContextAddPath(context, hidden);
+    CGContextEOClip(context);
+  }
+  CGPathRelease(hidden);
 }
 
 // A chip inside an unrevealed spoiler would peek around the cover.
@@ -133,7 +109,7 @@
     return NO;
   }
   __block BOOL hidden = NO;
-  [_attributedText
+  [_textStorage
       enumerateAttribute:JMDSpoilerIDAttributeName
                  inRange:range
                  options:0
@@ -200,49 +176,45 @@ static const CGFloat JMDInkPad = 2;
 // Per-line overlay rects for a character range. Whitespace-only segments
 // have no ink and produce no rect.
 - (NSArray<NSValue *> *)inkRectsForRange:(NSRange)range
-                           layoutManager:(NSLayoutManager *)layoutManager
                                  padLeft:(CGFloat)padLeft
                                 padRight:(CGFloat)padRight {
   CGContextRef context = UIGraphicsGetCurrentContext();
   // CTLineGetImageBounds reports bounds relative to the context's current
-  // text position, and NSStringDrawing leaves it wherever the last drawn
-  // line ended.
+  // text position.
   CGContextSetTextPosition(context, 0, 0);
   const CGFloat maxWidth = self.bounds.size.width;
   const CGFloat maxHeight = self.bounds.size.height;
   const NSRange glyphRange =
-      [layoutManager glyphRangeForCharacterRange:range actualCharacterRange:nil];
+      [_layoutManager glyphRangeForCharacterRange:range actualCharacterRange:nil];
   NSMutableArray<NSValue *> *lineRects = [NSMutableArray new];
   NSUInteger glyphIndex = glyphRange.location;
   while (glyphIndex < NSMaxRange(glyphRange)) {
     NSRange lineGlyphRange;
     const CGRect fragment =
-        [layoutManager lineFragmentRectForGlyphAtIndex:glyphIndex
-                                        effectiveRange:&lineGlyphRange];
+        [_layoutManager lineFragmentRectForGlyphAtIndex:glyphIndex
+                                         effectiveRange:&lineGlyphRange];
     const NSRange lineRange = NSIntersectionRange(lineGlyphRange, glyphRange);
     if (lineRange.length == 0) {
       break;
     }
     const NSRange charRange =
-        [layoutManager characterRangeForGlyphRange:lineRange actualGlyphRange:nil];
+        [_layoutManager characterRangeForGlyphRange:lineRange actualGlyphRange:nil];
     const CGPoint startLocation =
-        [layoutManager locationForGlyphAtIndex:lineRange.location];
+        [_layoutManager locationForGlyphAtIndex:lineRange.location];
     // The typesetter already folds NSBaselineOffset (lineHeight centering,
     // sup/sub shifts) into the glyph location.
     const CGFloat baselineY = fragment.origin.y + startLocation.y;
     const CGFloat penX = fragment.origin.x + startLocation.x;
 
     CTLineRef line = CTLineCreateWithAttributedString(
-        (__bridge CFAttributedStringRef)[self->_attributedText
-            attributedSubstringFromRange:charRange]);
+        (__bridge CFAttributedStringRef)[_textStorage attributedSubstringFromRange:charRange]);
     const CGRect ink = CTLineGetImageBounds(line, context);
     CFRelease(line);
     if (!CGRectIsNull(ink) && ink.size.width > 0) {
-      UIFont *font =
-          [self->_attributedText attribute:NSFontAttributeName
-                                   atIndex:charRange.location
-                            effectiveRange:nil]
-              ?: [UIFont systemFontOfSize:UIFont.systemFontSize];
+      UIFont *font = [_textStorage attribute:NSFontAttributeName
+                                     atIndex:charRange.location
+                              effectiveRange:nil]
+          ?: [UIFont systemFontOfSize:UIFont.systemFontSize];
       const CGFloat top = MAX(baselineY - font.capHeight - JMDInkPad, 0);
       const CGFloat bottom =
           MIN(baselineY - font.descender + JMDInkPad, maxHeight);
@@ -261,15 +233,11 @@ static const CGFloat JMDInkPad = 2;
 }
 
 // Run background chips (inlineCode/link/mention and plain highlights),
-// drawn UNDER the text; enumerates the display copy so chips hidden with
-// their spoiler don't draw.
-- (void)drawRunBackgrounds:(NSLayoutManager *)layoutManager {
-  if (_attributedText.length == 0) {
-    return;
-  }
-  [_attributedText
+// drawn UNDER the text; chips hidden with their spoiler don't draw.
+- (void)drawRunBackgrounds {
+  [_textStorage
       enumerateAttribute:JMDRunBackgroundAttributeName
-                 inRange:NSMakeRange(0, _attributedText.length)
+                 inRange:NSMakeRange(0, _textStorage.length)
                  options:0
               usingBlock:^(JMDRunBackground *chip, NSRange range, BOOL *stop) {
                 if (chip == nil || [self isRangeInsideHiddenSpoiler:range]) {
@@ -277,7 +245,6 @@ static const CGFloat JMDInkPad = 2;
                 }
                 NSArray<NSValue *> *rects = [self
                     inkRectsForRange:range
-                       layoutManager:layoutManager
                              padLeft:chip.padLeft > 0 ? chip.padLeft : JMDInkPad
                             padRight:chip.padRight > 0 ? chip.padRight
                                                        : JMDInkPad];
@@ -289,16 +256,16 @@ static const CGFloat JMDInkPad = 2;
               }];
 }
 
-// Spoiler cover chips, drawn OVER the (transparent) text until revealed.
+// Spoiler cover chips, drawn OVER the (clipped-out) text until revealed.
 // Same ink geometry as the run backgrounds so covers and backgrounds look
 // identical.
-- (void)drawSpoilerCovers:(NSLayoutManager *)layoutManager {
-  if (_attributedText.length == 0 || self.host == nil) {
+- (void)drawSpoilerCovers {
+  if (self.host == nil) {
     return;
   }
-  [_attributedText
+  [_textStorage
       enumerateAttribute:JMDSpoilerIDAttributeName
-                 inRange:NSMakeRange(0, _attributedText.length)
+                 inRange:NSMakeRange(0, _textStorage.length)
                  options:0
               usingBlock:^(NSNumber *spoilerId, NSRange range, BOOL *stop) {
                 if (spoilerId == nil ||
@@ -306,10 +273,7 @@ static const CGFloat JMDInkPad = 2;
                   return;
                 }
                 NSArray<NSValue *> *rects =
-                    [self inkRectsForRange:range
-                             layoutManager:layoutManager
-                                   padLeft:JMDInkPad
-                                  padRight:JMDInkPad];
+                    [self inkRectsForRange:range padLeft:JMDInkPad padRight:JMDInkPad];
                 [self.spoilerColor ?: UIColor.darkGrayColor setFill];
                 for (NSValue *value in rects) {
                   [JMDChipPath(value.CGRectValue, self.spoilerRadius,
@@ -319,22 +283,21 @@ static const CGFloat JMDInkPad = 2;
 }
 
 - (nullable NSDictionary *)attributesAtPoint:(CGPoint)point {
-  NSLayoutManager *layoutManager = [self layoutManagerForBounds];
-  if (layoutManager == nil || _attributedText.length == 0) {
+  if (_layoutManager == nil || _textStorage.length == 0) {
     return nil;
   }
-  const NSUInteger glyphIndex = [layoutManager glyphIndexForPoint:point
-                                                  inTextContainer:_textContainer];
-  const CGRect glyphRect = [layoutManager boundingRectForGlyphRange:NSMakeRange(glyphIndex, 1)
-                                                    inTextContainer:_textContainer];
+  const NSUInteger glyphIndex = [_layoutManager glyphIndexForPoint:point
+                                                   inTextContainer:_textContainer];
+  const CGRect glyphRect = [_layoutManager boundingRectForGlyphRange:NSMakeRange(glyphIndex, 1)
+                                                     inTextContainer:_textContainer];
   if (!CGRectContainsPoint(CGRectInset(glyphRect, -8, -4), point)) {
     return nil;
   }
-  const NSUInteger charIndex = [layoutManager characterIndexForGlyphAtIndex:glyphIndex];
-  if (charIndex >= _attributedText.length) {
+  const NSUInteger charIndex = [_layoutManager characterIndexForGlyphAtIndex:glyphIndex];
+  if (charIndex >= _textStorage.length) {
     return nil;
   }
-  return [_attributedText attributesAtIndex:charIndex effectiveRange:nil];
+  return [_textStorage attributesAtIndex:charIndex effectiveRange:nil];
 }
 
 @end

package/ios/views/JMDBoxViews.m

@@ -203,7 +203,7 @@ static void JMDApplyBox(UIView *view, JMDLayoutStyle *style) {
     [self addSubview:_scroller];
   }
   JMDApplyBox(self, measured.block.layoutStyle);
-  _text.attributedText = measured.block.attributedText;
+  [_text bindTextStorage:measured.textStorage];
   [self setNeedsLayout];
 }
 
@@ -238,19 +238,22 @@ static void JMDApplyBox(UIView *view, JMDLayoutStyle *style) {
         host:(nullable id<JMDMarkdownHost>)host {
   _measured = measured;
   _gap = gap;
-  for (UIView *subview in [self.subviews copy]) {
-    [subview removeFromSuperview];
+  // Subviews are (marker, content) pairs; grow/shrink the pair list, then
+  // rebind every pair in place.
+  const NSUInteger needed = measured.block.rows.count * 2;
+  while (self.subviews.count > needed) {
+    [self.subviews.lastObject removeFromSuperview];
   }
-  JMDBlock *block = measured.block;
-  for (NSUInteger i = 0; i < block.rows.count; i++) {
-    JMDBlockTextView *marker = [[JMDBlockTextView alloc] initWithFrame:CGRectZero];
-    marker.attributedText = block.rows[i].marker;
-    [self addSubview:marker];
-
-    JMDBlockStackView *content = [[JMDBlockStackView alloc] initWithFrame:CGRectZero];
+  while (self.subviews.count < needed) {
+    [self addSubview:[[JMDBlockTextView alloc] initWithFrame:CGRectZero]];
+    [self addSubview:[[JMDBlockStackView alloc] initWithFrame:CGRectZero]];
+  }
+  for (NSUInteger i = 0; i < measured.block.rows.count; i++) {
+    JMDBlockTextView *marker = (JMDBlockTextView *)self.subviews[i * 2];
+    [marker bindTextStorage:measured.markerStorages[i]];
+    JMDBlockStackView *content = (JMDBlockStackView *)self.subviews[i * 2 + 1];
     content.host = host;
     [content setBlocks:measured.rowContents[i] gap:gap];
-    [self addSubview:content];
   }
   [self setNeedsLayout];
 }

package/ios/views/JMDTableView.m

@@ -22,16 +22,23 @@
 
 - (void)bind:(JMDMeasuredBlock *)measured host:(nullable id<JMDMarkdownHost>)host {
   _measured = measured;
-  for (UIView *subview in [self.subviews copy]) {
-    [subview removeFromSuperview];
+  // One text view per cell, row-major; grow/shrink then rebind in place.
+  NSUInteger needed = 0;
+  for (NSArray<NSTextStorage *> *row in measured.cellStorages) {
+    needed += row.count;
   }
-  JMDBlock *block = measured.block;
-  for (JMDTableRow *row in block.tableRows) {
-    for (NSAttributedString *cell in row.cells) {
-      JMDBlockTextView *view = [[JMDBlockTextView alloc] initWithFrame:CGRectZero];
+  while (self.subviews.count > needed) {
+    [self.subviews.lastObject removeFromSuperview];
+  }
+  while (self.subviews.count < needed) {
+    [self addSubview:[[JMDBlockTextView alloc] initWithFrame:CGRectZero]];
+  }
+  NSUInteger index = 0;
+  for (NSArray<NSTextStorage *> *row in measured.cellStorages) {
+    for (NSTextStorage *cell in row) {
+      JMDBlockTextView *view = (JMDBlockTextView *)self.subviews[index++];
       view.host = host;
-      view.attributedText = cell;
-      [self addSubview:view];
+      [view bindTextStorage:cell];
     }
   }
   [self setNeedsDisplay];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-jet-markdown",
-  "version": "0.2.2",
+  "version": "0.2.3-beta.1",
   "description": "High-performance native Markdown renderer for React Native",
   "keywords": [
     "react-native",
@@ -41,6 +41,7 @@
     "!android/gradlew",
     "!android/gradlew.bat",
     "!android/local.properties",
+    "!cpp/tests",
     "!**/__tests__",
     "!**/__fixtures__",
     "!**/__mocks__",