react-native-jet-markdown 0.2.0-beta.7

package/ios/render/JMDContentCache.h

@@ -0,0 +1,17 @@
+#import <Foundation/Foundation.h>
+
+#import "JMDRenderedContent.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// Shared parse/render cache. The Fabric measurer populates it on the layout
+/// thread; the mounted view reads the same entry on the main thread.
+@interface JMDContentCache : NSObject
+
++ (JMDRenderedContent *)contentForMarkdown:(NSString *)markdown
+                                stylesJson:(NSString *)stylesJson
+                                 fontScale:(CGFloat)fontScale;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/render/JMDContentCache.mm

@@ -0,0 +1,42 @@
+#import "JMDContentCache.h"
+
+#import "../style/JMDStyleConfig.h"
+#import "JMDBlockRenderer.h"
+
+@implementation JMDContentCache
+
++ (JMDRenderedContent *)contentForMarkdown:(NSString *)markdown
+                                stylesJson:(NSString *)stylesJson
+                                 fontScale:(CGFloat)fontScale {
+  static NSCache<NSString *, JMDRenderedContent *> *cache;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    cache = [NSCache new];
+    cache.countLimit = 64;
+  });
+
+  // Full contents, not hashes: CFString's hash samples at most 96
+  // characters, so distinct long documents collide and would render each
+  // other's content. NSCache copies nothing — the key strings are shared.
+  NSString *key = [NSString stringWithFormat:@"%@\x1f%@\x1f%.3f",
+                                             markdown,
+                                             stylesJson,
+                                             fontScale];
+  JMDRenderedContent *cached = [cache objectForKey:key];
+  if (cached != nil) {
+    return cached;
+  }
+
+  JMDStyleConfig *styles = [JMDStyleConfig configWithJson:stylesJson];
+  NSArray<JMDBlock *> *blocks = [JMDBlockRenderer renderMarkdown:markdown
+                                                          styles:styles
+                                                       fontScale:fontScale];
+  JMDRenderedContent *content = [[JMDRenderedContent alloc] initWithBlocks:blocks
+                                                                       gap:styles.gap
+                                                                topPadding:styles.paddingTop
+                                                             bottomPadding:styles.paddingBottom];
+  [cache setObject:content forKey:key];
+  return content;
+}
+
+@end

package/ios/render/JMDRenderedContent.h

@@ -0,0 +1,35 @@
+#import <UIKit/UIKit.h>
+
+#import "JMDBlock.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface JMDWidthLayout : NSObject
+@property (nonatomic, strong) NSArray<JMDMeasuredBlock *> *measured;
+@property (nonatomic, assign) CGFloat totalHeight;
+@end
+
+/// Parsed + rendered markdown block tree, shared between the Fabric measurer
+/// (layout thread) and the mounted view (main thread). Per-width layout
+/// results are cached.
+@interface JMDRenderedContent : NSObject
+
+@property (nonatomic, readonly) CGFloat gap;
+
+- (instancetype)initWithBlocks:(NSArray<JMDBlock *> *)blocks
+                           gap:(CGFloat)gap
+                    topPadding:(CGFloat)topPadding
+                 bottomPadding:(CGFloat)bottomPadding;
+
+/// imageSizes: url -> @[@(width), @(height)] in points (dp).
++ (NSString *)keyForImageSizes:
+    (nullable NSDictionary<NSString *, NSArray<NSNumber *> *> *)imageSizes;
+
+- (JMDWidthLayout *)layoutForWidth:(CGFloat)width
+                        imageSizes:(nullable NSDictionary<NSString *, NSArray<NSNumber *> *> *)imageSizes;
+
++ (CGFloat)stackHeight:(NSArray<JMDMeasuredBlock *> *)children gap:(CGFloat)gap;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/render/JMDRenderedContent.mm

@@ -0,0 +1,274 @@
+#import "JMDRenderedContent.h"
+
+#include <vector>
+
+@implementation JMDWidthLayout
+@end
+
+@implementation JMDRenderedContent {
+  NSArray<JMDBlock *> *_blocks;
+  CGFloat _topPadding;
+  CGFloat _bottomPadding;
+  NSMutableDictionary<NSString *, JMDWidthLayout *> *_layoutCache;
+}
+
+- (instancetype)initWithBlocks:(NSArray<JMDBlock *> *)blocks
+                           gap:(CGFloat)gap
+                    topPadding:(CGFloat)topPadding
+                 bottomPadding:(CGFloat)bottomPadding {
+  if (self = [super init]) {
+    _blocks = [blocks copy];
+    _gap = gap;
+    _topPadding = topPadding;
+    _bottomPadding = bottomPadding;
+    _layoutCache = [NSMutableDictionary new];
+  }
+  return self;
+}
+
++ (CGFloat)stackHeight:(NSArray<JMDMeasuredBlock *> *)children gap:(CGFloat)gap {
+  CGFloat height = 0;
+  for (NSUInteger i = 0; i < children.count; i++) {
+    height += children[i].height;
+    if (i + 1 < children.count) {
+      height += gap;
+    }
+  }
+  return height;
+}
+
+// NSDictionary.hash is just the entry COUNT — size changes that keep the
+// count would collide. Key on the sorted contents instead.
++ (NSString *)keyForImageSizes:
+    (nullable NSDictionary<NSString *, NSArray<NSNumber *> *> *)imageSizes {
+  if (imageSizes.count == 0) {
+    return @"";
+  }
+  NSMutableString *out = [NSMutableString string];
+  for (NSString *url in
+       [imageSizes.allKeys sortedArrayUsingSelector:@selector(compare:)]) {
+    NSArray<NSNumber *> *size = imageSizes[url];
+    [out appendFormat:@"%@\x1e%@x%@\x1f", url, size.firstObject, size.lastObject];
+  }
+  return out;
+}
+
+- (JMDWidthLayout *)layoutForWidth:(CGFloat)width
+                        imageSizes:(nullable NSDictionary<NSString *, NSArray<NSNumber *> *> *)imageSizes {
+  NSString *key = [NSString stringWithFormat:@"%.1f|%@",
+                                             width,
+                                             [JMDRenderedContent keyForImageSizes:imageSizes]];
+  @synchronized(self) {
+    JMDWidthLayout *cached = _layoutCache[key];
+    if (cached != nil) {
+      return cached;
+    }
+  }
+
+  NSMutableArray<JMDMeasuredBlock *> *measured = [NSMutableArray arrayWithCapacity:_blocks.count];
+  for (JMDBlock *block in _blocks) {
+    [measured addObject:[self measureBlock:block width:width imageSizes:imageSizes]];
+  }
+
+  JMDWidthLayout *layout = [JMDWidthLayout new];
+  layout.measured = measured;
+  layout.totalHeight =
+      [JMDRenderedContent stackHeight:measured gap:_gap] + _topPadding + _bottomPadding;
+
+  @synchronized(self) {
+    if (_layoutCache.count > 4) {
+      [_layoutCache removeAllObjects];
+    }
+    _layoutCache[key] = layout;
+  }
+  return layout;
+}
+
+- (CGSize)textSize:(NSAttributedString *)text width:(CGFloat)width {
+  // Measured with TextKit, not NSStringDrawing: boundingRect stops at the
+  // last line's drawn descent, dropping the bottom of the final line box
+  // under a custom lineHeight. The full box keeps overlays (spoiler covers,
+  // run background chips) from being clipped at the view's bottom edge and
+  // matches how RN's <Text> and the Android renderer measure.
+  NSTextStorage *storage = [[NSTextStorage alloc] initWithAttributedString:text];
+  NSLayoutManager *layoutManager = [NSLayoutManager new];
+  NSTextContainer *container = [[NSTextContainer alloc]
+      initWithSize:CGSizeMake(MIN(width, (CGFloat)1e6), CGFLOAT_MAX)];
+  container.lineFragmentPadding = 0;
+  [layoutManager addTextContainer:container];
+  [storage addLayoutManager:layoutManager];
+  [layoutManager ensureLayoutForTextContainer:container];
+  const CGRect used = [layoutManager usedRectForTextContainer:container];
+  return CGSizeMake(ceil(used.size.width), ceil(used.size.height));
+}
+
+- (JMDMeasuredBlock *)measureBlock:(JMDBlock *)block
+                             width:(CGFloat)width
+                        imageSizes:(nullable NSDictionary<NSString *, NSArray<NSNumber *> *> *)imageSizes {
+  JMDMeasuredBlock *measured = [JMDMeasuredBlock new];
+  measured.block = block;
+  measured.contentWidth = width;
+
+  switch (block.kind) {
+    case JMDBlockKindText: {
+      const CGSize size = [self textSize:block.attributedText width:width];
+      measured.height = size.height;
+      measured.textHeight = size.height;
+      break;
+    }
+    case JMDBlockKindCode: {
+      const CGSize size = [self textSize:block.attributedText width:CGFLOAT_MAX];
+      measured.contentWidth = size.width;
+      measured.textHeight = size.height;
+      measured.height =
+          size.height + block.layoutStyle.paddingTop + block.layoutStyle.paddingBottom;
+      break;
+    }
+    case JMDBlockKindQuote: {
+      const CGFloat innerWidth = MAX(width - block.layoutStyle.horizontalInset, 1);
+      NSMutableArray<JMDMeasuredBlock *> *children =
+          [NSMutableArray arrayWithCapacity:block.children.count];
+      for (JMDBlock *child in block.children) {
+        [children addObject:[self measureBlock:child width:innerWidth imageSizes:imageSizes]];
+      }
+      measured.children = children;
+      measured.height = [JMDRenderedContent stackHeight:children gap:_gap] +
+          block.layoutStyle.verticalInset;
+      break;
+    }
+    case JMDBlockKindList: {
+      const CGFloat contentX =
+          block.listMarginLeft + block.markerMarginLeft + block.markerWidth;
+      const CGFloat contentWidth = MAX(width - contentX, 1);
+      measured.contentWidth = contentWidth;
+      NSMutableArray<NSNumber *> *markerHeights = [NSMutableArray new];
+      NSMutableArray<NSArray<JMDMeasuredBlock *> *> *rowContents = [NSMutableArray new];
+      CGFloat height = 0;
+      for (NSUInteger i = 0; i < block.rows.count; i++) {
+        JMDListRow *row = block.rows[i];
+        const CGSize markerSize = [self textSize:row.marker width:block.markerWidth];
+        NSMutableArray<JMDMeasuredBlock *> *content = [NSMutableArray new];
+        for (JMDBlock *child in row.content) {
+          [content addObject:[self measureBlock:child width:contentWidth imageSizes:imageSizes]];
+        }
+        [markerHeights addObject:@(markerSize.height)];
+        [rowContents addObject:content];
+        height += MAX(markerSize.height, [JMDRenderedContent stackHeight:content gap:_gap]);
+        if (i + 1 < block.rows.count) {
+          height += _gap / 2;
+        }
+      }
+      measured.markerHeights = markerHeights;
+      measured.rowContents = rowContents;
+      measured.height = height;
+      break;
+    }
+    case JMDBlockKindDivider:
+      measured.height = block.dividerThickness;
+      break;
+    case JMDBlockKindTable: {
+      // Intelligent column widths: natural (unwrapped) width per column,
+      // clamped to [min, max]; surplus distributed proportionally when the
+      // table fits, horizontal scroll when it does not.
+      NSUInteger columnCount = 0;
+      for (JMDTableRow *row in block.tableRows) {
+        columnCount = MAX(columnCount, row.cells.count);
+      }
+      if (columnCount == 0) {
+        measured.height = 0;
+        break;
+      }
+
+      std::vector<CGFloat> natural(columnCount, 0);
+      for (JMDTableRow *row in block.tableRows) {
+        const UIEdgeInsets pad = row.isHeader ? block.headerCellPadding : block.cellPadding;
+        const CGFloat cellPadH = pad.left + pad.right;
+        for (NSUInteger column = 0; column < row.cells.count; column++) {
+          const CGFloat desired =
+              [self textSize:row.cells[column] width:CGFLOAT_MAX].width + cellPadH;
+          natural[column] = MAX(natural[column], desired);
+        }
+      }
+
+      std::vector<CGFloat> columnWidths(columnCount, 0);
+      CGFloat total = 0;
+      CGFloat naturalTotal = 0;
+      const CGFloat maxColumnWidth =
+          block.maxColumnWidth > 0 ? block.maxColumnWidth : CGFLOAT_MAX;
+      for (NSUInteger i = 0; i < columnCount; i++) {
+        columnWidths[i] = MIN(MAX(natural[i], block.minColumnWidth), maxColumnWidth);
+        total += columnWidths[i];
+        naturalTotal += natural[i];
+      }
+      const CGFloat availableWidth = width - block.layoutStyle.horizontalInset;
+      if (total < availableWidth && naturalTotal > 0) {
+        const CGFloat surplus = availableWidth - total;
+        for (NSUInteger i = 0; i < columnCount; i++) {
+          columnWidths[i] += surplus * (natural[i] / naturalTotal);
+        }
+      }
+
+      NSMutableArray<NSNumber *> *rowHeights = [NSMutableArray new];
+      CGFloat contentHeight = 0;
+      for (JMDTableRow *row in block.tableRows) {
+        JMDLayoutStyle *rowStyle = row.isHeader ? block.headerRowStyle : block.bodyRowStyle;
+        const UIEdgeInsets pad = row.isHeader ? block.headerCellPadding : block.cellPadding;
+        const CGFloat cellPadH = pad.left + pad.right;
+        const CGFloat cellPadV = pad.top + pad.bottom;
+        const CGFloat rowExtra = rowStyle.borderTopWidth + rowStyle.borderBottomWidth;
+        CGFloat rowHeight = 0;
+        for (NSUInteger column = 0; column < row.cells.count; column++) {
+          const CGFloat cellWidth = MAX(columnWidths[column] - cellPadH, 1);
+          rowHeight = MAX(rowHeight, [self textSize:row.cells[column] width:cellWidth].height);
+        }
+        rowHeight += cellPadV + rowExtra;
+        [rowHeights addObject:@(rowHeight)];
+        contentHeight += rowHeight;
+      }
+
+      NSMutableArray<NSNumber *> *widths = [NSMutableArray new];
+      CGFloat contentWidth = 0;
+      for (NSUInteger i = 0; i < columnCount; i++) {
+        [widths addObject:@(columnWidths[i])];
+        contentWidth += columnWidths[i];
+      }
+
+      measured.columnWidths = widths;
+      measured.rowHeights = rowHeights;
+      measured.contentWidth = contentWidth;
+      measured.height = contentHeight + block.layoutStyle.verticalInset;
+      break;
+    }
+    case JMDBlockKindImage: {
+      NSArray<NSNumber *> *known = block.imageUrl != nil ? imageSizes[block.imageUrl] : nil;
+      CGFloat displayH;
+      CGFloat displayW;
+      if (known.count == 2 && known[0].doubleValue > 0 && known[1].doubleValue > 0) {
+        const CGFloat intrinsicW = known[0].doubleValue;
+        const CGFloat intrinsicH = known[1].doubleValue;
+        const CGFloat scale = MIN(width / intrinsicW, 1.0);
+        displayH = intrinsicH * scale;
+        if (block.imageHeight > 0) {
+          displayH = block.imageHeight;
+        }
+        if (block.imageMaxHeight > 0) {
+          displayH = MIN(displayH, block.imageMaxHeight);
+        }
+        displayW = MIN(intrinsicW * displayH / intrinsicH, width);
+      } else {
+        // Full-width placeholder until the intrinsic size is known.
+        displayH = block.imageHeight > 0 ? block.imageHeight : block.imagePlaceholder;
+        if (block.imageMaxHeight > 0) {
+          displayH = MIN(displayH, block.imageMaxHeight);
+        }
+        displayW = width;
+      }
+      measured.height = displayH;
+      measured.contentWidth = displayW;
+      break;
+    }
+  }
+  return measured;
+}
+
+@end

package/ios/style/JMDFontScale.h

@@ -0,0 +1,33 @@
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// The Dynamic Type multiplier for the current content size category, using
+/// React Native's own category table (RCTAccessibilityManager) so heights
+/// measured with LayoutContext::fontSizeMultiplier match what the host
+/// views render.
+static inline CGFloat JMDFontSizeMultiplier(void) {
+  static NSDictionary<UIContentSizeCategory, NSNumber *> *table;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    table = @{
+      UIContentSizeCategoryExtraSmall : @0.823,
+      UIContentSizeCategorySmall : @0.882,
+      UIContentSizeCategoryMedium : @0.941,
+      UIContentSizeCategoryLarge : @1.0,
+      UIContentSizeCategoryExtraLarge : @1.118,
+      UIContentSizeCategoryExtraExtraLarge : @1.235,
+      UIContentSizeCategoryExtraExtraExtraLarge : @1.353,
+      UIContentSizeCategoryAccessibilityMedium : @1.786,
+      UIContentSizeCategoryAccessibilityLarge : @2.143,
+      UIContentSizeCategoryAccessibilityExtraLarge : @2.643,
+      UIContentSizeCategoryAccessibilityExtraExtraLarge : @3.143,
+      UIContentSizeCategoryAccessibilityExtraExtraExtraLarge : @3.571,
+    };
+  });
+  NSNumber *value =
+      table[UIApplication.sharedApplication.preferredContentSizeCategory];
+  return value != nil ? value.doubleValue : 1.0;
+}
+
+NS_ASSUME_NONNULL_END

package/ios/style/JMDLayoutStyle.h

@@ -0,0 +1,37 @@
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// One element's box style from stylesJson (point values).
+@interface JMDLayoutStyle : NSObject
+
+@property (nonatomic, readonly, nullable) UIColor *backgroundColor;
+@property (nonatomic, readonly) CGFloat paddingLeft;
+@property (nonatomic, readonly) CGFloat paddingRight;
+@property (nonatomic, readonly) CGFloat paddingTop;
+@property (nonatomic, readonly) CGFloat paddingBottom;
+@property (nonatomic, readonly) CGFloat borderRadius;
+@property (nonatomic, readonly) BOOL continuousCorners;
+@property (nonatomic, readonly, nullable) UIColor *borderLeftColor;
+@property (nonatomic, readonly) CGFloat borderLeftWidth;
+@property (nonatomic, readonly, nullable) UIColor *borderRightColor;
+@property (nonatomic, readonly) CGFloat borderRightWidth;
+@property (nonatomic, readonly, nullable) UIColor *borderTopColor;
+@property (nonatomic, readonly) CGFloat borderTopWidth;
+@property (nonatomic, readonly, nullable) UIColor *borderBottomColor;
+@property (nonatomic, readonly) CGFloat borderBottomWidth;
+
+@property (nonatomic, readonly) CGFloat horizontalInset;
+@property (nonatomic, readonly) CGFloat verticalInset;
+
++ (instancetype)fromJson:(nullable NSDictionary *)json defaults:(nullable JMDLayoutStyle *)defaults;
+
++ (instancetype)defaultsWithBackground:(nullable UIColor *)background
+                               padding:(UIEdgeInsets)padding
+                          borderRadius:(CGFloat)radius
+                       borderLeftColor:(nullable UIColor *)borderLeftColor
+                       borderLeftWidth:(CGFloat)borderLeftWidth;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/style/JMDLayoutStyle.mm

@@ -0,0 +1,68 @@
+#import "JMDLayoutStyle.h"
+
+#import "JMDTextStyle.h"
+
+@implementation JMDLayoutStyle
+
++ (instancetype)defaultsWithBackground:(nullable UIColor *)background
+                               padding:(UIEdgeInsets)padding
+                          borderRadius:(CGFloat)radius
+                       borderLeftColor:(nullable UIColor *)borderLeftColor
+                       borderLeftWidth:(CGFloat)borderLeftWidth {
+  JMDLayoutStyle *style = [JMDLayoutStyle new];
+  style->_backgroundColor = background;
+  style->_paddingLeft = padding.left;
+  style->_paddingRight = padding.right;
+  style->_paddingTop = padding.top;
+  style->_paddingBottom = padding.bottom;
+  style->_borderRadius = radius;
+  style->_borderLeftColor = borderLeftColor;
+  style->_borderLeftWidth = borderLeftWidth;
+  return style;
+}
+
++ (instancetype)fromJson:(nullable NSDictionary *)json defaults:(nullable JMDLayoutStyle *)defaults {
+  JMDLayoutStyle *base = defaults ?: [JMDLayoutStyle new];
+  if (![json isKindOfClass:[NSDictionary class]]) {
+    return base;
+  }
+
+  JMDLayoutStyle *style = [JMDLayoutStyle new];
+  auto number = [json](NSString *key, CGFloat fallback) -> CGFloat {
+    NSNumber *value = [json[key] isKindOfClass:[NSNumber class]] ? json[key] : nil;
+    return value != nil ? value.doubleValue : fallback;
+  };
+  auto color = [json](NSString *key, UIColor *fallback) -> UIColor * {
+    UIColor *value = [JMDTextStyle colorFromJson:json[key]];
+    return value ?: fallback;
+  };
+
+  style->_backgroundColor = color(@"backgroundColor", base.backgroundColor);
+  style->_paddingLeft = number(@"paddingLeft", base.paddingLeft);
+  style->_paddingRight = number(@"paddingRight", base.paddingRight);
+  style->_paddingTop = number(@"paddingTop", base.paddingTop);
+  style->_paddingBottom = number(@"paddingBottom", base.paddingBottom);
+  style->_borderRadius = number(@"borderRadius", base.borderRadius);
+  style->_continuousCorners =
+      [json[@"borderCurve"] isKindOfClass:[NSString class]] &&
+      [json[@"borderCurve"] isEqualToString:@"continuous"];
+  style->_borderLeftColor = color(@"borderLeftColor", base.borderLeftColor);
+  style->_borderLeftWidth = number(@"borderLeftWidth", base.borderLeftWidth);
+  style->_borderRightColor = color(@"borderRightColor", base.borderRightColor);
+  style->_borderRightWidth = number(@"borderRightWidth", base.borderRightWidth);
+  style->_borderTopColor = color(@"borderTopColor", base.borderTopColor);
+  style->_borderTopWidth = number(@"borderTopWidth", base.borderTopWidth);
+  style->_borderBottomColor = color(@"borderBottomColor", base.borderBottomColor);
+  style->_borderBottomWidth = number(@"borderBottomWidth", base.borderBottomWidth);
+  return style;
+}
+
+- (CGFloat)horizontalInset {
+  return _paddingLeft + _paddingRight + _borderLeftWidth + _borderRightWidth;
+}
+
+- (CGFloat)verticalInset {
+  return _paddingTop + _paddingBottom + _borderTopWidth + _borderBottomWidth;
+}
+
+@end

package/ios/style/JMDStyleConfig.h

@@ -0,0 +1,39 @@
+#import <UIKit/UIKit.h>
+
+#import "JMDTextStyle.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface JMDMentionVariant : NSObject
+@property (nonatomic, readonly) NSRegularExpression *pattern;
+@property (nonatomic, readonly, nullable) JMDTextStyle *style;
+@end
+
+/// Parsed stylesJson with cached instances per JSON string.
+@interface JMDStyleConfig : NSObject
+
+@property (nonatomic, readonly) CGFloat gap;
+@property (nonatomic, readonly) CGFloat paddingLeft;
+@property (nonatomic, readonly) CGFloat paddingRight;
+@property (nonatomic, readonly) CGFloat paddingTop;
+@property (nonatomic, readonly) CGFloat paddingBottom;
+@property (nonatomic, readonly, nullable) UIColor *backgroundColor;
+
+/// Ordered longest-pattern-first; a link whose URL matches becomes a mention.
+@property (nonatomic, readonly) NSArray<JMDMentionVariant *> *mentionVariants;
+
++ (instancetype)configWithJson:(NSString *)json;
+
+/// Raw JSON section for an element key (layout parsing).
+- (nullable NSDictionary *)rawSectionFor:(NSString *)key;
+
+/// User style for an element key (paragraph, h1..h6, bold, italic,
+/// strikethrough, link, mention, inlineCode, superscript, subscript,
+/// listItem, tableCell, codeBlock, blockQuote). Nil when not provided.
+- (nullable JMDTextStyle *)textStyleFor:(NSString *)key;
+
+/// Built-in default font size for a heading level 1-6 or body text (0).
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/style/JMDStyleConfig.mm

@@ -0,0 +1,111 @@
+#import "JMDStyleConfig.h"
+
+@implementation JMDMentionVariant
+
+- (instancetype)initWithPattern:(NSRegularExpression *)pattern
+                          style:(nullable JMDTextStyle *)style {
+  if (self = [super init]) {
+    _pattern = pattern;
+    _style = style;
+  }
+  return self;
+}
+
+@end
+
+@implementation JMDStyleConfig {
+  NSDictionary *_root;
+  NSMutableDictionary<NSString *, id> *_textStyles;
+}
+
++ (instancetype)configWithJson:(NSString *)json {
+  static NSCache<NSString *, JMDStyleConfig *> *cache;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    cache = [NSCache new];
+    cache.countLimit = 16;
+  });
+
+  NSString *key = json.length > 0 ? json : @"{}";
+  JMDStyleConfig *cached = [cache objectForKey:key];
+  if (cached != nil) {
+    return cached;
+  }
+  JMDStyleConfig *config = [[JMDStyleConfig alloc] initWithJson:key];
+  [cache setObject:config forKey:key];
+  return config;
+}
+
+- (instancetype)initWithJson:(NSString *)json {
+  if (self = [super init]) {
+    NSDictionary *root = nil;
+    NSData *data = [json dataUsingEncoding:NSUTF8StringEncoding];
+    if (data != nil) {
+      id parsed = [NSJSONSerialization JSONObjectWithData:data options:0 error:nil];
+      if ([parsed isKindOfClass:[NSDictionary class]]) {
+        root = parsed;
+      }
+    }
+    _root = root ?: @{};
+    _textStyles = [NSMutableDictionary new];
+
+    NSDictionary *main = [_root[@"main"] isKindOfClass:[NSDictionary class]] ? _root[@"main"] : @{};
+    // Container style-prop gap wins; the styles prop (defaultStyles.gap)
+    // supplies the themed value; unstyled floor is 0.
+    _gap = [self floatFrom:main key:@"gap"
+                  fallback:[self floatFrom:_root key:@"gap" fallback:0]];
+    _paddingLeft = [self floatFrom:main key:@"paddingLeft" fallback:0];
+    _paddingRight = [self floatFrom:main key:@"paddingRight" fallback:0];
+    _paddingTop = [self floatFrom:main key:@"paddingTop" fallback:0];
+    _paddingBottom = [self floatFrom:main key:@"paddingBottom" fallback:0];
+    _backgroundColor = [JMDTextStyle colorFromJson:main[@"backgroundColor"]];
+
+    NSMutableArray<JMDMentionVariant *> *variants = [NSMutableArray new];
+    NSDictionary *mention =
+        [_root[@"mention"] isKindOfClass:[NSDictionary class]] ? _root[@"mention"] : nil;
+    NSArray *variantPairs =
+        [mention[@"variants"] isKindOfClass:[NSArray class]] ? mention[@"variants"] : @[];
+    for (id pair in variantPairs) {
+      if (![pair isKindOfClass:[NSArray class]] || [pair count] != 2) {
+        continue;
+      }
+      NSString *patternString = [pair[0] isKindOfClass:[NSString class]] ? pair[0] : nil;
+      if (patternString == nil) {
+        continue;
+      }
+      NSRegularExpression *pattern =
+          [NSRegularExpression regularExpressionWithPattern:patternString options:0 error:nil];
+      if (pattern == nil) {
+        continue;
+      }
+      [variants addObject:[[JMDMentionVariant alloc]
+                              initWithPattern:pattern
+                                        style:[JMDTextStyle fromJson:pair[1]]]];
+    }
+    _mentionVariants = variants;
+  }
+  return self;
+}
+
+- (CGFloat)floatFrom:(NSDictionary *)dict key:(NSString *)key fallback:(CGFloat)fallback {
+  NSNumber *value = [dict[key] isKindOfClass:[NSNumber class]] ? dict[key] : nil;
+  return value != nil ? value.doubleValue : fallback;
+}
+
+- (nullable NSDictionary *)rawSectionFor:(NSString *)key {
+  return [_root[key] isKindOfClass:[NSDictionary class]] ? _root[key] : nil;
+}
+
+- (nullable JMDTextStyle *)textStyleFor:(NSString *)key {
+  @synchronized(self) {
+    id cached = _textStyles[key];
+    if (cached != nil) {
+      return cached == NSNull.null ? nil : cached;
+    }
+    JMDTextStyle *style = [JMDTextStyle fromJson:_root[key]];
+    _textStyles[key] = style ?: (id)NSNull.null;
+    return style;
+  }
+}
+
+@end

package/ios/style/JMDTextStyle.h

@@ -0,0 +1,25 @@
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// One element's text style as it arrived in stylesJson; nil fields inherit.
+@interface JMDTextStyle : NSObject
+
+@property (nonatomic, readonly, nullable) NSNumber *fontSize;
+@property (nonatomic, readonly, nullable) NSNumber *fontWeight; // 100-900
+@property (nonatomic, readonly, nullable) NSString *fontFamily;
+@property (nonatomic, readonly, nullable) NSNumber *lineHeight;
+@property (nonatomic, readonly, nullable) UIColor *color;
+@property (nonatomic, readonly, nullable) NSArray<NSString *> *fontVariant;
+@property (nonatomic, readonly, nullable) UIColor *textDecorationColor;
+@property (nonatomic, readonly, nullable) NSString *textDecorationLine;
+@property (nonatomic, readonly, nullable) NSString *textDecorationStyle;
+@property (nonatomic, readonly, nullable) UIColor *backgroundColor;
+
++ (nullable instancetype)fromJson:(nullable NSDictionary *)json;
+
++ (nullable UIColor *)colorFromJson:(nullable id)value;
+
+@end
+
+NS_ASSUME_NONNULL_END