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

package/ios/views/ENRMMathContainerView.m

@@ -5,6 +5,7 @@
 #include <TargetConditionals.h>
 
 #if ENRICHED_MARKDOWN_MATH
+#import "ENRMMathFallback.h"
 #import "PasteboardUtils.h"
 #if __has_include("ReactNativeEnrichedMarkdown-Swift.h")
 #import "ReactNativeEnrichedMarkdown-Swift.h"
@@ -20,14 +21,21 @@
 
 @interface ENRMRaTeXCanvasView : RCTUIView
 @property (nonatomic, strong, nullable) ENRMRaTeXRenderResult *renderResult;
+// Visible-source fallback when RaTeX cannot parse the block, drawn wrapped;
+// see ENRMMathFallback.h.
+@property (nonatomic, strong, nullable) NSAttributedString *fallbackSource;
 @end
 
 @implementation ENRMRaTeXCanvasView
 
 - (void)drawRect:(CGRect)rect
 {
-  if (!_renderResult)
+  if (!_renderResult) {
+    if (_fallbackSource) {
+      [_fallbackSource drawWithRect:self.bounds options:NSStringDrawingUsesLineFragmentOrigin context:nil];
+    }
     return;
+  }
   CGContextRef ctx = UIGraphicsGetCurrentContext();
   if (!ctx)
     return;
@@ -98,6 +106,7 @@
                                                    color:config.mathColor
                                                     bold:ENRMMathFontWeightIsBold(config.mathFontWeight)];
   _mathView.renderResult = result;
+  _mathView.fallbackSource = result ? nil : ENRMMathFallbackString(latex, @"$$", config.mathFontSize, config.mathColor);
 
   CGFloat padding = config.mathPadding;
   _mathView.frame = CGRectMake(padding, padding, ceil(result.width), ceil(result.totalHeight));
@@ -117,6 +126,11 @@
 - (UIContextMenuConfiguration *)contextMenuInteraction:(UIContextMenuInteraction *)interaction
                         configurationForMenuAtLocation:(CGPoint)location
 {
+  // Returning nil is the UIKit-sanctioned way to suppress a context menu.
+  if (self.contextMenuHidden) {
+    return nil;
+  }
+
   return [UIContextMenuConfiguration
       configurationWithIdentifier:nil
                   previewProvider:nil
@@ -141,6 +155,12 @@
 #if TARGET_OS_OSX
 - (NSMenu *)menuForEvent:(NSEvent *)event
 {
+  // This override never falls through to [super menuForEvent:], so nil fully
+  // suppresses the menu rather than restoring the AppKit default.
+  if (self.contextMenuHidden) {
+    return nil;
+  }
+
   NSMenu *menu = [[NSMenu alloc] initWithTitle:@""];
   [menu addItem:ENRMCreateMenuItem(self.copyLabel, ^{ [self copyLatexToPasteboard]; })];
   [menu addItem:ENRMCreateMenuItem(self.copyAsMarkdownLabel, ^{ [self copyMarkdownToPasteboard]; })];
@@ -166,9 +186,40 @@
 - (CGFloat)measureHeight:(CGFloat)maxWidth
 {
   CGFloat padding = self.config.mathPadding;
+  if (!_mathView.renderResult && _mathView.fallbackSource) {
+    CGFloat available = MAX(maxWidth - padding * 2, 1);
+    CGRect bounds = [_mathView.fallbackSource boundingRectWithSize:CGSizeMake(available, CGFLOAT_MAX)
+                                                           options:NSStringDrawingUsesLineFragmentOrigin
+                                                           context:nil];
+    return ceil(bounds.size.height) + padding * 2;
+  }
   return [self mathViewIntrinsicSize].height + padding * 2;
 }
 
++ (CGFloat)measureHeightForLatex:(NSString *)latex config:(StyleConfig *)config maxWidth:(CGFloat)maxWidth
+{
+  CGFloat padding = config.mathPadding;
+
+  ENRMRaTeXRenderResult *result = [ENRMRaTeXBridge parse:latex
+                                             displayMode:YES
+                                                fontSize:config.mathFontSize
+                                                   color:config.mathColor
+                                                    bold:ENRMMathFontWeightIsBold(config.mathFontWeight)];
+  if (result) {
+    return ceil(result.totalHeight) + padding * 2;
+  }
+
+  NSAttributedString *fallbackSource = ENRMMathFallbackString(latex, @"$$", config.mathFontSize, config.mathColor);
+  if (!fallbackSource) {
+    return 0;
+  }
+  CGFloat available = MAX(maxWidth - padding * 2, 1);
+  CGRect bounds = [fallbackSource boundingRectWithSize:CGSizeMake(available, CGFLOAT_MAX)
+                                               options:NSStringDrawingUsesLineFragmentOrigin
+                                               context:nil];
+  return ceil(bounds.size.height) + padding * 2;
+}
+
 - (CGFloat)alignedOriginXForWidth:(CGFloat)formulaWidth inBounds:(CGFloat)boundsWidth padding:(CGFloat)padding
 {
   CGFloat available = boundsWidth - padding * 2;
@@ -188,6 +239,25 @@
   [super layoutSubviews];
 
   CGFloat padding = self.config.mathPadding;
+
+  if (!_mathView.renderResult && _mathView.fallbackSource) {
+    // Fallback source fills the available width and wraps; no horizontal scroll.
+#if !TARGET_OS_OSX
+    _scrollView.frame = self.bounds;
+    _scrollView.contentSize = self.bounds.size;
+    _scrollView.contentOffset = CGPointZero;
+    _scrollView.scrollEnabled = NO;
+#endif
+    _mathView.frame = CGRectMake(padding, padding, MAX(self.bounds.size.width - padding * 2, 1),
+                                 MAX(self.bounds.size.height - padding * 2, 1));
+#if !TARGET_OS_OSX
+    [_mathView setNeedsDisplay];
+#else
+    [_mathView setNeedsDisplay:YES];
+#endif
+    return;
+  }
+
   CGSize intrinsicSize = [self mathViewIntrinsicSize];
   CGFloat contentWidth = intrinsicSize.width + padding * 2;
   CGFloat contentHeight = self.bounds.size.height;

package/ios/views/TableContainerView.h

@@ -18,6 +18,20 @@ typedef void (^TableLinkPressBlock)(NSString *url);
 
 - (CGFloat)measureHeight:(CGFloat)maxWidth;
 
+/// View-free table height for shadow-node measurement (issue #550): renders
+/// the cells' attributed strings and runs the same column/row layout the view
+/// runs in `applyTableNode:`/`computeLayout` — shared statics, so measured and
+/// rendered heights cannot drift — without creating any view. Safe on any
+/// thread; the iOS counterpart of Android's
+/// `TableContainerView.measureTableNodeHeight`. Table height is intrinsic
+/// (content-sized columns, horizontal scroll), so no maxWidth parameter.
++ (CGFloat)measureHeightForTableNode:(MarkdownASTNode *)tableNode
+                              config:(StyleConfig *)config
+                    allowFontScaling:(BOOL)allowFontScaling
+               maxFontSizeMultiplier:(CGFloat)maxFontSizeMultiplier
+                writingDirectionMode:(ENRMWritingDirectionMode)writingDirectionMode
+             resolvedLayoutDirection:(NSWritingDirection)resolvedLayoutDirection;
+
 @property (nonatomic, strong) StyleConfig *config;
 
 @property (nonatomic, assign) BOOL allowFontScaling;
@@ -38,6 +52,10 @@ typedef void (^TableLinkPressBlock)(NSString *url);
 @property (nonatomic, copy, nullable, getter=menuCopyLabel) NSString *copyLabel;
 @property (nonatomic, copy, nullable, getter=menuCopyAsMarkdownLabel) NSString *copyAsMarkdownLabel;
 
+/// Suppresses the long-press copy menu on this block. Mirrors the
+/// `contextMenuHidden` prop; selection and link handling are unaffected.
+@property (nonatomic, assign) BOOL contextMenuHidden;
+
 @property (nonatomic, readonly) NSUInteger rowCount;
 
 - (void)animateNewRowsFromPreviousCount:(NSUInteger)previousRowCount duration:(NSTimeInterval)duration;

package/ios/views/TableContainerView.m

@@ -28,6 +28,184 @@
 @implementation TableCellData
 @end
 
+// Cell rendering and layout are view-free statics so the instance path
+// (applyTableNode:/computeLayout) and the shadow-measurement class method
+// (+measureHeightForTableNode:...) share one implementation and cannot drift
+// (issue #550).
+
+static NSTextAlignment ENRMTableTextAlignmentFromString(NSString *align)
+{
+  if ([align isEqualToString:@"center"])
+    return NSTextAlignmentCenter;
+  if ([align isEqualToString:@"right"])
+    return NSTextAlignmentRight;
+  return NSTextAlignmentLeft;
+}
+
+static NSString *ENRMTablePlainTextFromNode(MarkdownASTNode *node)
+{
+  if (!node)
+    return @"";
+  NSMutableString *buffer = [node.content mutableCopy] ?: [NSMutableString string];
+  for (MarkdownASTNode *child in node.children) {
+    [buffer appendString:ENRMTablePlainTextFromNode(child)];
+  }
+  return [buffer copy];
+}
+
+static StyleConfig *ENRMTableCellConfig(StyleConfig *config, BOOL isHeader)
+{
+  StyleConfig *cellConfig = [config copy];
+
+  [cellConfig setParagraphFontSize:config.tableFontSize];
+  NSString *headerFamily =
+      config.tableHeaderFontFamily.length > 0 ? config.tableHeaderFontFamily : config.tableFontFamily;
+  [cellConfig setParagraphFontFamily:isHeader ? headerFamily : config.tableFontFamily];
+  [cellConfig setParagraphFontWeight:isHeader ? @"bold" : config.tableFontWeight];
+  [cellConfig setParagraphColor:isHeader ? config.tableHeaderTextColor : config.tableColor];
+  [cellConfig setParagraphLineHeight:config.tableLineHeight];
+
+  [cellConfig setParagraphMarginTop:0];
+  [cellConfig setParagraphMarginBottom:0];
+
+  return cellConfig;
+}
+
+static NSMutableAttributedString *ENRMTableRenderCellNode(MarkdownASTNode *cellNode, StyleConfig *cellConfig,
+                                                          NSTextAlignment alignment, BOOL allowFontScaling,
+                                                          CGFloat maxFontSizeMultiplier,
+                                                          ENRMWritingDirectionMode writingDirectionMode,
+                                                          NSWritingDirection resolvedLayoutDirection)
+{
+  MarkdownASTNode *temporaryRoot = [[MarkdownASTNode alloc] initWithType:MarkdownNodeTypeDocument];
+  for (MarkdownASTNode *child in cellNode.children) {
+    [temporaryRoot addChild:child];
+  }
+
+  AttributedRenderer *renderer = [[AttributedRenderer alloc] initWithConfig:cellConfig];
+  RenderContext *context = [RenderContext new];
+  context.allowFontScaling = allowFontScaling;
+  context.maxFontSizeMultiplier = maxFontSizeMultiplier;
+
+  NSMutableAttributedString *attributedText = [renderer renderRoot:temporaryRoot context:context];
+
+  [context applyLinkAttributesToString:attributedText];
+
+  ENRMApplyWritingDirectionMode(attributedText, writingDirectionMode, resolvedLayoutDirection);
+
+  if (alignment != NSTextAlignmentLeft && attributedText.length > 0) {
+    NSRange fullRange = NSMakeRange(0, attributedText.length);
+    [attributedText
+        enumerateAttribute:NSParagraphStyleAttributeName
+                   inRange:fullRange
+                   options:0
+                usingBlock:^(NSParagraphStyle *paragraphStyle, NSRange range, BOOL *stop) {
+                  NSMutableParagraphStyle *mutableStyle =
+                      paragraphStyle ? [paragraphStyle mutableCopy] : [[NSMutableParagraphStyle alloc] init];
+                  mutableStyle.alignment = alignment;
+                  [attributedText addAttribute:NSParagraphStyleAttributeName value:mutableStyle range:range];
+                }];
+  }
+
+  return attributedText;
+}
+
+static NSArray<NSArray<TableCellData *> *> *ENRMTableBuildRows(MarkdownASTNode *tableNode, StyleConfig *config,
+                                                               BOOL allowFontScaling, CGFloat maxFontSizeMultiplier,
+                                                               ENRMWritingDirectionMode writingDirectionMode,
+                                                               NSWritingDirection resolvedLayoutDirection,
+                                                               NSUInteger *outColCount)
+{
+  StyleConfig *headerCellConfig = ENRMTableCellConfig(config, YES);
+  StyleConfig *bodyCellConfig = ENRMTableCellConfig(config, NO);
+
+  NSMutableArray *allRows = [NSMutableArray array];
+  NSUInteger colCount = 0;
+
+  for (MarkdownASTNode *section in tableNode.children) {
+    BOOL isSectionHead = (section.type == MarkdownNodeTypeTableHead);
+
+    for (MarkdownASTNode *rowNode in section.children) {
+      if (rowNode.type != MarkdownNodeTypeTableRow)
+        continue;
+
+      NSMutableArray<TableCellData *> *rowCells = [NSMutableArray array];
+      for (MarkdownASTNode *cellNode in rowNode.children) {
+        TableCellData *cell = [[TableCellData alloc] init];
+        cell.isHeader = isSectionHead || (cellNode.type == MarkdownNodeTypeTableHeaderCell);
+        cell.alignment = ENRMTableTextAlignmentFromString(cellNode.attributes[@"align"]);
+        cell.plainText = ENRMTablePlainTextFromNode(cellNode);
+        cell.markdownText = markdownFromASTNodeChildren(cellNode);
+
+        StyleConfig *cellConfig = cell.isHeader ? headerCellConfig : bodyCellConfig;
+        cell.attributedText =
+            ENRMTableRenderCellNode(cellNode, cellConfig, cell.alignment, allowFontScaling, maxFontSizeMultiplier,
+                                    writingDirectionMode, resolvedLayoutDirection);
+        [rowCells addObject:cell];
+      }
+      colCount = MAX(colCount, rowCells.count);
+      [allRows addObject:rowCells];
+    }
+  }
+
+  if (outColCount != NULL) {
+    *outColCount = colCount;
+  }
+  return [allRows copy];
+}
+
+static void ENRMTableComputeLayout(NSArray<NSArray<TableCellData *> *> *rows, NSUInteger colCount, StyleConfig *config,
+                                   CGFloat borderWidth, NSMutableArray<NSNumber *> *_Nullable *_Nullable outColWidths,
+                                   NSMutableArray<NSNumber *> *_Nullable *_Nullable outRowHeights,
+                                   CGFloat *_Nullable outTotalWidth, CGFloat *_Nullable outTotalHeight)
+{
+  // TODO: Consider making minColumnWidth / maxColumnWidth configurable via style props
+  const CGFloat minimumColumnWidth = 60.0;
+  const CGFloat maximumColumnWidth = 300.0;
+  const CGFloat horizontalPadding = config.tableCellPaddingHorizontal * 2;
+  const CGFloat verticalPadding = config.tableCellPaddingVertical * 2;
+
+  NSMutableArray<NSNumber *> *colWidths = [NSMutableArray arrayWithCapacity:colCount];
+  for (NSUInteger i = 0; i < colCount; i++)
+    [colWidths addObject:@0];
+
+  for (NSArray<TableCellData *> *row in rows) {
+    for (NSUInteger column = 0; column < row.count; column++) {
+      CGRect boundingRect = [row[column].attributedText
+          boundingRectWithSize:CGSizeMake(maximumColumnWidth, CGFLOAT_MAX)
+                       options:NSStringDrawingUsesLineFragmentOrigin | NSStringDrawingUsesFontLeading
+                       context:nil];
+      CGFloat width = MIN(MAX(ceil(boundingRect.size.width) + horizontalPadding, minimumColumnWidth),
+                          maximumColumnWidth + horizontalPadding);
+      if (width > [colWidths[column] doubleValue])
+        colWidths[column] = @(width);
+    }
+  }
+
+  NSMutableArray<NSNumber *> *rowHeights = [NSMutableArray arrayWithCapacity:rows.count];
+  for (NSArray<TableCellData *> *row in rows) {
+    CGFloat maxHeight = 0;
+    for (NSUInteger column = 0; column < row.count; column++) {
+      CGFloat availableWidth = [colWidths[column] doubleValue] - horizontalPadding;
+      CGRect boundingRect = [row[column].attributedText
+          boundingRectWithSize:CGSizeMake(availableWidth, CGFLOAT_MAX)
+                       options:NSStringDrawingUsesLineFragmentOrigin | NSStringDrawingUsesFontLeading
+                       context:nil];
+      maxHeight = MAX(maxHeight, ceil(boundingRect.size.height) + verticalPadding);
+    }
+    [rowHeights addObject:@(maxHeight)];
+  }
+
+  if (outColWidths != NULL)
+    *outColWidths = colWidths;
+  if (outRowHeights != NULL)
+    *outRowHeights = rowHeights;
+  if (outTotalWidth != NULL)
+    *outTotalWidth = [[colWidths valueForKeyPath:@"@sum.self"] doubleValue] + borderWidth;
+  if (outTotalHeight != NULL)
+    *outTotalHeight = [[rowHeights valueForKeyPath:@"@sum.self"] doubleValue] + borderWidth;
+}
+
 #if !TARGET_OS_OSX
 @interface TableContainerView () <UIContextMenuInteractionDelegate>
 @end
@@ -46,7 +224,6 @@
   NSMutableArray<NSNumber *> *_rowHeights;
   CGFloat _totalTableWidth;
   CGFloat _totalTableHeight;
-  CGFloat _borderWidth;
 
   NSString *_cachedMarkdown;
 
@@ -58,7 +235,6 @@
   self = [super initWithFrame:CGRectZero];
   if (self) {
     _config = config;
-    _borderWidth = config.tableBorderWidth;
     _allowFontScaling = YES;
     _maxFontSizeMultiplier = 0;
     _enableLinkPreview = YES;
@@ -88,11 +264,12 @@
   // a single drawRect: pass (no subview / layer compositing issues).
   ENRMTableGridView *gridView = [[ENRMTableGridView alloc] initWithFrame:CGRectZero];
   __weak TableContainerView *weakSelf = self;
-  gridView.menuProvider = ^NSMenu *
-  {
+  gridView.menuProvider = ^NSMenu * {
     TableContainerView *strongSelf = weakSelf;
     if (!strongSelf)
       return nil;
+    if (strongSelf.contextMenuHidden)
+      return nil;
     NSMenu *menu = [[NSMenu alloc] initWithTitle:@""];
     [menu addItem:ENRMCreateMenuItem(strongSelf.copyLabel, ^{ [strongSelf copyTableToPasteboard]; })];
     [menu addItem:ENRMCreateMenuItem(strongSelf.copyAsMarkdownLabel, ^{ [strongSelf copyMarkdownToPasteboard]; })];
@@ -120,74 +297,6 @@
 #endif
 }
 
-- (StyleConfig *)cellConfigForHeader:(BOOL)isHeader
-{
-  StyleConfig *cellConfig = [self.config copy];
-
-  [cellConfig setParagraphFontSize:self.config.tableFontSize];
-  NSString *headerFamily =
-      self.config.tableHeaderFontFamily.length > 0 ? self.config.tableHeaderFontFamily : self.config.tableFontFamily;
-  [cellConfig setParagraphFontFamily:isHeader ? headerFamily : self.config.tableFontFamily];
-  [cellConfig setParagraphFontWeight:isHeader ? @"bold" : self.config.tableFontWeight];
-  [cellConfig setParagraphColor:isHeader ? self.config.tableHeaderTextColor : self.config.tableColor];
-  [cellConfig setParagraphLineHeight:self.config.tableLineHeight];
-
-  [cellConfig setParagraphMarginTop:0];
-  [cellConfig setParagraphMarginBottom:0];
-
-  return cellConfig;
-}
-
-- (NSMutableAttributedString *)renderCellNode:(MarkdownASTNode *)cellNode
-                                     isHeader:(BOOL)isHeader
-                                   cellConfig:(StyleConfig *)cellConfig
-                                    alignment:(NSTextAlignment)alignment
-{
-
-  MarkdownASTNode *temporaryRoot = [[MarkdownASTNode alloc] initWithType:MarkdownNodeTypeDocument];
-  for (MarkdownASTNode *child in cellNode.children) {
-    [temporaryRoot addChild:child];
-  }
-
-  AttributedRenderer *renderer = [[AttributedRenderer alloc] initWithConfig:cellConfig];
-  RenderContext *context = [RenderContext new];
-  context.allowFontScaling = self.allowFontScaling;
-  context.maxFontSizeMultiplier = self.maxFontSizeMultiplier;
-
-  NSMutableAttributedString *attributedText = [renderer renderRoot:temporaryRoot context:context];
-
-  [context applyLinkAttributesToString:attributedText];
-
-  ENRMApplyWritingDirectionMode(attributedText, _writingDirectionMode, _resolvedLayoutDirection);
-
-  if (alignment != NSTextAlignmentLeft && attributedText.length > 0) {
-    NSRange fullRange = NSMakeRange(0, attributedText.length);
-    [attributedText
-        enumerateAttribute:NSParagraphStyleAttributeName
-                   inRange:fullRange
-                   options:0
-                usingBlock:^(NSParagraphStyle *paragraphStyle, NSRange range, BOOL *stop) {
-                  NSMutableParagraphStyle *mutableStyle =
-                      paragraphStyle ? [paragraphStyle mutableCopy] : [[NSMutableParagraphStyle alloc] init];
-                  mutableStyle.alignment = alignment;
-                  [attributedText addAttribute:NSParagraphStyleAttributeName value:mutableStyle range:range];
-                }];
-  }
-
-  return attributedText;
-}
-
-- (NSString *)extractPlainTextFromNode:(MarkdownASTNode *)node
-{
-  if (!node)
-    return @"";
-  NSMutableString *buffer = [node.content mutableCopy] ?: [NSMutableString string];
-  for (MarkdownASTNode *child in node.children) {
-    [buffer appendString:[self extractPlainTextFromNode:child]];
-  }
-  return [buffer copy];
-}
-
 - (NSUInteger)rowCount
 {
   return _rows.count;
@@ -212,96 +321,47 @@
 {
   [[_gridContainer subviews] makeObjectsPerformSelector:@selector(removeFromSuperview)];
 
-  StyleConfig *headerCellConfig = [self cellConfigForHeader:YES];
-  StyleConfig *bodyCellConfig = [self cellConfigForHeader:NO];
-
-  NSMutableArray *allRows = [NSMutableArray array];
-  _colCount = 0;
-
-  for (MarkdownASTNode *section in tableNode.children) {
-    BOOL isSectionHead = (section.type == MarkdownNodeTypeTableHead);
-
-    for (MarkdownASTNode *rowNode in section.children) {
-      if (rowNode.type != MarkdownNodeTypeTableRow)
-        continue;
-
-      NSMutableArray<TableCellData *> *rowCells = [NSMutableArray array];
-      for (MarkdownASTNode *cellNode in rowNode.children) {
-        TableCellData *cell = [[TableCellData alloc] init];
-        cell.isHeader = isSectionHead || (cellNode.type == MarkdownNodeTypeTableHeaderCell);
-        cell.alignment = [self textAlignmentFromString:cellNode.attributes[@"align"]];
-        cell.plainText = [self extractPlainTextFromNode:cellNode];
-        cell.markdownText = markdownFromASTNodeChildren(cellNode);
-
-        StyleConfig *cellConfig = cell.isHeader ? headerCellConfig : bodyCellConfig;
-        cell.attributedText = [self renderCellNode:cellNode
-                                          isHeader:cell.isHeader
-                                        cellConfig:cellConfig
-                                         alignment:cell.alignment];
-        [rowCells addObject:cell];
-      }
-      _colCount = MAX(_colCount, rowCells.count);
-      [allRows addObject:rowCells];
-    }
-  }
-
-  _rows = [allRows copy];
+  NSUInteger colCount = 0;
+  _rows = ENRMTableBuildRows(tableNode, self.config, self.allowFontScaling, self.maxFontSizeMultiplier,
+                             _writingDirectionMode, _resolvedLayoutDirection, &colCount);
+  _colCount = colCount;
   _cachedMarkdown = [self buildMarkdownFromRows];
   _cachedAccessibilityElements = nil;
   [self computeLayout];
   [self renderGrid];
 }
 
-- (NSTextAlignment)textAlignmentFromString:(NSString *)align
+- (void)computeLayout
 {
-  if ([align isEqualToString:@"center"])
-    return NSTextAlignmentCenter;
-  if ([align isEqualToString:@"right"])
-    return NSTextAlignmentRight;
-  return NSTextAlignmentLeft;
+  NSMutableArray<NSNumber *> *colWidths = nil;
+  NSMutableArray<NSNumber *> *rowHeights = nil;
+  CGFloat totalWidth = 0;
+  CGFloat totalHeight = 0;
+  ENRMTableComputeLayout(_rows, _colCount, self.config, self.config.tableBorderWidth, &colWidths, &rowHeights,
+                         &totalWidth, &totalHeight);
+  _colWidths = colWidths;
+  _rowHeights = rowHeights;
+  _totalTableWidth = totalWidth;
+  _totalTableHeight = totalHeight;
 }
 
-- (void)computeLayout
++ (CGFloat)measureHeightForTableNode:(MarkdownASTNode *)tableNode
+                              config:(StyleConfig *)config
+                    allowFontScaling:(BOOL)allowFontScaling
+               maxFontSizeMultiplier:(CGFloat)maxFontSizeMultiplier
+                writingDirectionMode:(ENRMWritingDirectionMode)writingDirectionMode
+             resolvedLayoutDirection:(NSWritingDirection)resolvedLayoutDirection
 {
-  // TODO: Consider making minColumnWidth / maxColumnWidth configurable via style props
-  const CGFloat minimumColumnWidth = 60.0;
-  const CGFloat maximumColumnWidth = 300.0;
-  const CGFloat horizontalPadding = self.config.tableCellPaddingHorizontal * 2;
-  const CGFloat verticalPadding = self.config.tableCellPaddingVertical * 2;
-
-  _colWidths = [NSMutableArray arrayWithCapacity:_colCount];
-  for (NSUInteger i = 0; i < _colCount; i++)
-    [_colWidths addObject:@0];
-
-  for (NSArray<TableCellData *> *row in _rows) {
-    for (NSUInteger column = 0; column < row.count; column++) {
-      CGRect boundingRect = [row[column].attributedText
-          boundingRectWithSize:CGSizeMake(maximumColumnWidth, CGFLOAT_MAX)
-                       options:NSStringDrawingUsesLineFragmentOrigin | NSStringDrawingUsesFontLeading
-                       context:nil];
-      CGFloat width = MIN(MAX(ceil(boundingRect.size.width) + horizontalPadding, minimumColumnWidth),
-                          maximumColumnWidth + horizontalPadding);
-      if (width > [_colWidths[column] doubleValue])
-        _colWidths[column] = @(width);
-    }
-  }
-
-  _rowHeights = [NSMutableArray arrayWithCapacity:_rows.count];
-  for (NSArray<TableCellData *> *row in _rows) {
-    CGFloat maxHeight = 0;
-    for (NSUInteger column = 0; column < row.count; column++) {
-      CGFloat availableWidth = [_colWidths[column] doubleValue] - horizontalPadding;
-      CGRect boundingRect = [row[column].attributedText
-          boundingRectWithSize:CGSizeMake(availableWidth, CGFLOAT_MAX)
-                       options:NSStringDrawingUsesLineFragmentOrigin | NSStringDrawingUsesFontLeading
-                       context:nil];
-      maxHeight = MAX(maxHeight, ceil(boundingRect.size.height) + verticalPadding);
-    }
-    [_rowHeights addObject:@(maxHeight)];
-  }
+  NSUInteger colCount = 0;
+  NSArray<NSArray<TableCellData *> *> *rows =
+      ENRMTableBuildRows(tableNode, config, allowFontScaling, maxFontSizeMultiplier, writingDirectionMode,
+                         resolvedLayoutDirection, &colCount);
+  if (rows.count == 0)
+    return 0;
 
-  _totalTableWidth = [[_colWidths valueForKeyPath:@"@sum.self"] doubleValue] + _borderWidth;
-  _totalTableHeight = [[_rowHeights valueForKeyPath:@"@sum.self"] doubleValue] + _borderWidth;
+  CGFloat totalHeight = 0;
+  ENRMTableComputeLayout(rows, colCount, config, config.tableBorderWidth, NULL, NULL, NULL, &totalHeight);
+  return totalHeight;
 }
 
 - (void)renderGrid
@@ -357,7 +417,7 @@
                columnWidths:_colWidths
                  rowHeights:_rowHeights
                 borderColor:self.config.tableBorderColor
-                borderWidth:_borderWidth
+                borderWidth:self.config.tableBorderWidth
       horizontalCellPadding:self.config.tableCellPaddingHorizontal
         verticalCellPadding:self.config.tableCellPaddingVertical
                cornerRadius:self.config.tableBorderRadius];
@@ -392,7 +452,7 @@
                columnWidths:_colWidths
                  rowHeights:_rowHeights
                 borderColor:self.config.tableBorderColor
-                borderWidth:_borderWidth
+                borderWidth:self.config.tableBorderWidth
       horizontalCellPadding:self.config.tableCellPaddingHorizontal
         verticalCellPadding:self.config.tableCellPaddingVertical
                cornerRadius:self.config.tableBorderRadius];
@@ -403,6 +463,11 @@
 - (UIContextMenuConfiguration *)contextMenuInteraction:(UIContextMenuInteraction *)interaction
                         configurationForMenuAtLocation:(CGPoint)location
 {
+  // Returning nil is the UIKit-sanctioned way to suppress a context menu.
+  if (self.contextMenuHidden) {
+    return nil;
+  }
+
   return [UIContextMenuConfiguration
       configurationWithIdentifier:nil
                   previewProvider:nil
@@ -550,19 +615,54 @@
   return _totalTableHeight;
 }
 
+- (CGFloat)alignOffsetForFreeSpace:(CGFloat)freeSpace
+{
+  if (freeSpace <= 0)
+    return 0;
+  NSString *align = self.config.tableAlign;
+  if ([align isEqualToString:@"center"])
+    return freeSpace / 2;
+  if ([align isEqualToString:@"right"])
+    return freeSpace;
+  return 0;
+}
+
 - (void)layoutSubviews
 {
   [super layoutSubviews];
   _scrollView.frame = self.bounds;
 #if !TARGET_OS_OSX
-  _scrollView.contentSize = CGSizeMake(MAX(_totalTableWidth, self.bounds.size.width), _totalTableHeight);
-  _scrollView.scrollEnabled = (_totalTableWidth > self.bounds.size.width);
-  _gridContainer.frame = CGRectMake(0, 0, _totalTableWidth, _totalTableHeight);
+  CGFloat overhang = MAX(self.config.tableHorizontalOverflow, 0);
+  CGFloat containerWidth = self.bounds.size.width;
+  BOOL tableOverflows = (overhang > 0 && _totalTableWidth > containerWidth);
+
+  if (tableOverflows) {
+    UIEdgeInsets inset = UIEdgeInsetsMake(0, overhang, 0, overhang);
+    if (!UIEdgeInsetsEqualToEdgeInsets(_scrollView.contentInset, inset)) {
+      _scrollView.contentInset = inset;
+      _scrollView.contentOffset = CGPointMake(-overhang, 0);
+    }
+    _scrollView.contentSize = CGSizeMake(_totalTableWidth, _totalTableHeight);
+    _scrollView.scrollEnabled = YES;
+    _gridContainer.frame = CGRectMake(0, 0, _totalTableWidth, _totalTableHeight);
+  } else {
+    CGFloat alignOffset = [self alignOffsetForFreeSpace:containerWidth - overhang * 2 - _totalTableWidth];
+    _scrollView.contentInset = UIEdgeInsetsZero;
+    _scrollView.contentOffset = CGPointZero;
+    _scrollView.contentSize = CGSizeMake(MAX(_totalTableWidth, containerWidth), _totalTableHeight);
+    _scrollView.scrollEnabled = (_totalTableWidth > containerWidth);
+    _gridContainer.frame = CGRectMake(overhang + alignOffset, 0, _totalTableWidth, _totalTableHeight);
+  }
 #else
-  // For NSScrollView+documentView, the scrollable content area is determined by
-  // the documentView's frame. No contentSize property to set.
-  if (_totalTableWidth > 0 && _totalTableHeight > 0) {
+  CGFloat overhang = MAX(self.config.tableHorizontalOverflow, 0);
+  CGFloat containerWidth = self.bounds.size.width;
+  BOOL tableOverflows = (overhang > 0 && _totalTableWidth > containerWidth);
+
+  if (tableOverflows) {
     _gridContainer.frame = CGRectMake(0, 0, _totalTableWidth, _totalTableHeight);
+  } else if (_totalTableWidth > 0 && _totalTableHeight > 0) {
+    CGFloat alignOffset = [self alignOffsetForFreeSpace:containerWidth - overhang * 2 - _totalTableWidth];
+    _gridContainer.frame = CGRectMake(overhang + alignOffset, 0, _totalTableWidth, _totalTableHeight);
   }
 #endif
 }

package/jest.d.ts

@@ -0,0 +1 @@
+export * from './src/jest';

package/jest.js

@@ -0,0 +1,5 @@
+'use strict';
+
+// Subpath entry for `require('react-native-enriched-markdown-scaffold/jest')`.
+// Re-exports the compiled mock (built from `src/jest` by react-native-builder-bob).
+module.exports = require('./lib/module/jest');