@mathers101/react-native-render-rich-text 0.0.0-stage → 0.1.10

package/ios/internals/MeasurementCache.h

@@ -0,0 +1,308 @@
+#pragma once
+
+#include <CoreGraphics/CGBase.h>
+#include <React/RCTUtils.h>
+#include <list>
+#include <mutex>
+#include <react/renderer/graphics/Float.h>
+#include <string>
+#include <tuple>
+#include <unordered_map>
+
+namespace facebook::react {
+
+struct HashUtils {
+
+  static inline size_t combine(size_t h, size_t v)
+  {
+    return h ^ (v + 0x9e3779b97f4a7c15ULL + (h << 6) + (h >> 2));
+  }
+
+  template <typename T> static inline void hash_one(size_t &seed, const T &v)
+  {
+    seed = combine(seed, std::hash<T>{}(v));
+  }
+};
+
+enum class TiptapFlavor : uint8_t {
+  CommonMark = 0,
+  GitHub = 1,
+};
+
+struct MeasurementCacheKey {
+  std::string tiptap;
+  CGFloat maxWidth;
+  bool allowTrailingMargin;
+  bool allowFontScaling;
+  double maxFontSizeMultiplier;
+  bool md4cFlagsUnderline;
+  bool md4cFlagsSuperscript;
+  bool md4cFlagsSubscript;
+  bool md4cFlagsHighlight;
+  bool md4cFlagsLatexMath;
+  bool md4cFlagsHardSoftBreaks;
+  bool md4cFlagsPreserveBlankLines;
+  bool md4cFlagsAdmonitions;
+  size_t styleFingerprint;
+  size_t linkPillContentFingerprint;
+  // Code blocks the user wrapped (view state, not props); 0 when none.
+  size_t wrappedCodeBlocksFingerprint;
+  CGFloat fontScale;
+  TiptapFlavor flavor;
+  std::string lineBreakStrategyIOS;
+  std::string writingDirection;
+  int numberOfLines;
+  std::string ellipsizeMode;
+  std::string linkRegexKey;
+  std::string inlineCodeLinkRegexKey;
+
+  bool operator==(const MeasurementCacheKey &other) const
+  {
+    return std::tie(tiptap, maxWidth, allowTrailingMargin, allowFontScaling, maxFontSizeMultiplier,
+                    md4cFlagsUnderline, md4cFlagsSuperscript, md4cFlagsSubscript, md4cFlagsHighlight,
+                    md4cFlagsLatexMath, md4cFlagsHardSoftBreaks, md4cFlagsPreserveBlankLines, md4cFlagsAdmonitions,
+                    styleFingerprint, linkPillContentFingerprint, wrappedCodeBlocksFingerprint, fontScale, flavor,
+                    lineBreakStrategyIOS, writingDirection, numberOfLines, ellipsizeMode, linkRegexKey,
+                    inlineCodeLinkRegexKey) ==
+           std::tie(other.tiptap, other.maxWidth, other.allowTrailingMargin, other.allowFontScaling,
+                    other.maxFontSizeMultiplier, other.md4cFlagsUnderline, other.md4cFlagsSuperscript,
+                    other.md4cFlagsSubscript, other.md4cFlagsHighlight, other.md4cFlagsLatexMath,
+                    other.md4cFlagsHardSoftBreaks, other.md4cFlagsPreserveBlankLines, other.md4cFlagsAdmonitions,
+                    other.styleFingerprint, other.linkPillContentFingerprint, other.wrappedCodeBlocksFingerprint,
+                    other.fontScale, other.flavor, other.lineBreakStrategyIOS, other.writingDirection,
+                    other.numberOfLines, other.ellipsizeMode, other.linkRegexKey, other.inlineCodeLinkRegexKey);
+  }
+};
+
+struct MeasurementCacheKeyHash {
+  size_t operator()(const MeasurementCacheKey &key) const
+  {
+    size_t h = 0;
+    HashUtils::hash_one(h, key.tiptap);
+    HashUtils::hash_one(h, key.maxWidth);
+    HashUtils::hash_one(h, key.allowTrailingMargin);
+    HashUtils::hash_one(h, key.allowFontScaling);
+    HashUtils::hash_one(h, key.maxFontSizeMultiplier);
+    HashUtils::hash_one(h, key.md4cFlagsUnderline);
+    HashUtils::hash_one(h, key.md4cFlagsSuperscript);
+    HashUtils::hash_one(h, key.md4cFlagsSubscript);
+    HashUtils::hash_one(h, key.md4cFlagsHighlight);
+    HashUtils::hash_one(h, key.md4cFlagsLatexMath);
+    HashUtils::hash_one(h, key.md4cFlagsHardSoftBreaks);
+    HashUtils::hash_one(h, key.md4cFlagsPreserveBlankLines);
+    HashUtils::hash_one(h, key.md4cFlagsAdmonitions);
+    HashUtils::hash_one(h, key.styleFingerprint);
+    HashUtils::hash_one(h, key.linkPillContentFingerprint);
+    HashUtils::hash_one(h, key.wrappedCodeBlocksFingerprint);
+    HashUtils::hash_one(h, key.fontScale);
+    HashUtils::hash_one(h, static_cast<uint8_t>(key.flavor));
+    HashUtils::hash_one(h, key.lineBreakStrategyIOS);
+    HashUtils::hash_one(h, key.writingDirection);
+    HashUtils::hash_one(h, key.numberOfLines);
+    HashUtils::hash_one(h, key.ellipsizeMode);
+    HashUtils::hash_one(h, key.linkRegexKey);
+    HashUtils::hash_one(h, key.inlineCodeLinkRegexKey);
+    return h;
+  }
+};
+
+struct CachedSize {
+  CGFloat width;
+  CGFloat height;
+};
+
+template <typename StyleStruct> inline size_t computeStyleFingerprint(const StyleStruct &s)
+{
+  size_t h = 0;
+  auto hashFields = [&](auto... args) { (HashUtils::hash_one(h, args), ...); };
+
+  auto hashTextLayout = [&](const auto &item) {
+    hashFields(item.fontFamily, item.fontSize, item.fontWeight, item.marginTop, item.marginBottom, item.lineHeight);
+  };
+
+  // Block Elements
+  hashTextLayout(s.paragraph);
+  hashFields(s.paragraph.textAlign);
+  hashTextLayout(s.h1);
+  hashFields(s.h1.textAlign);
+  hashTextLayout(s.h2);
+  hashFields(s.h2.textAlign);
+  hashTextLayout(s.h3);
+  hashFields(s.h3.textAlign);
+  hashTextLayout(s.h4);
+  hashFields(s.h4.textAlign);
+  hashTextLayout(s.h5);
+  hashFields(s.h5.textAlign);
+  hashTextLayout(s.h6);
+  hashFields(s.h6.textAlign);
+
+  hashTextLayout(s.blockquote);
+  hashFields(s.blockquote.borderWidth, s.blockquote.gapWidth, s.blockquote.padding, s.blockquote.borderRadius);
+
+  hashTextLayout(s.list);
+  hashFields(s.list.bulletSize, s.list.markerMinWidth, s.list.markerFontWeight, s.list.gapWidth, s.list.marginLeft,
+             s.list.itemSpacing);
+
+  // Code & Inlines
+  hashFields(s.codeBlock.fontFamily, s.codeBlock.fontSize, s.codeBlock.fontWeight, s.codeBlock.marginTop,
+             s.codeBlock.marginBottom, s.codeBlock.lineHeight, s.codeBlock.padding, s.codeBlock.borderRadius,
+             s.codeBlock.borderWidth);
+  hashFields(s.code.fontFamily, s.code.fontSize);
+  hashFields(s.link.fontFamily, s.strong.fontFamily, s.strong.fontWeight, s.em.fontFamily, s.em.fontStyle);
+  // Variants change link metrics: a font family, or a pill box around the label.
+  for (const auto &variant : s.linkVariants) {
+    hashFields(variant.pattern, variant.fontFamily, variant.pill.enabled, variant.pill.label, variant.pill.iconUri,
+               variant.pill.paddingHorizontal, variant.pill.paddingVertical, variant.pill.lineHeight,
+               variant.pill.borderWidth, variant.pill.maxWidth);
+  }
+  hashFields(s.highlight.backgroundColor, s.highlight.color);
+
+  // Visual/Spacing Elements
+  hashFields(s.image.height, s.image.maxHeight, s.image.aspectRatio, s.image.marginTop, s.image.marginBottom);
+  hashFields(s.video.marginTop, s.video.marginBottom, s.video.borderRadius, s.video.aspectRatio,
+             s.video.backgroundColor);
+  hashFields(s.inlineImage.size);
+  hashFields(s.thematicBreak.height, s.thematicBreak.marginTop, s.thematicBreak.marginBottom);
+
+  // Complex Components
+  hashTextLayout(s.table);
+  hashFields(s.table.headerFontFamily, s.table.cellPaddingHorizontal, s.table.cellPaddingVertical, s.table.borderWidth,
+             s.table.borderRadius, s.table.horizontalOverflow);
+  hashFields(s.math.fontSize, s.math.padding, s.math.marginTop, s.math.marginBottom, s.math.textAlign);
+  hashFields(s.taskList.checkboxSize, s.taskList.checkboxBorderRadius);
+
+  return h;
+}
+
+// Pill labels and icons (the `linkPillContent` prop) change link widths.
+template <typename ContentVector> inline size_t computeLinkPillContentFingerprint(const ContentVector &content)
+{
+  size_t h = 0;
+  for (const auto &entry : content) {
+    HashUtils::hash_one(h, entry.url);
+    HashUtils::hash_one(h, entry.label);
+    HashUtils::hash_one(h, entry.iconUri);
+  }
+  return h;
+}
+
+template <typename RegexProps> inline std::string buildLinkRecognitionCacheKey(const RegexProps &props)
+{
+  std::string key;
+  key += props.caseInsensitive ? '1' : '0';
+  key += props.dotAll ? '1' : '0';
+  key += props.isDisabled ? '1' : '0';
+  key += props.isDefault ? '1' : '0';
+  return key + props.pattern;
+}
+
+template <typename PropsType>
+inline MeasurementCacheKey buildMeasurementCacheKey(const PropsType &props, CGFloat maxWidth, CGFloat fontScale,
+                                                    TiptapFlavor flavor, size_t wrappedCodeBlocksFingerprint = 0)
+{
+  return MeasurementCacheKey{
+      .tiptap = props.document,
+      .maxWidth = maxWidth,
+      .allowTrailingMargin = props.allowTrailingMargin,
+      .allowFontScaling = props.allowFontScaling,
+      .maxFontSizeMultiplier = props.maxFontSizeMultiplier,
+      .md4cFlagsUnderline = props.md4cFlags.underline,
+      .md4cFlagsSuperscript = props.md4cFlags.superscript,
+      .md4cFlagsSubscript = props.md4cFlags.subscript,
+      .md4cFlagsHighlight = props.md4cFlags.highlight,
+      .md4cFlagsLatexMath = props.md4cFlags.latexMath,
+      .md4cFlagsHardSoftBreaks = props.md4cFlags.hardSoftBreaks,
+      .md4cFlagsPreserveBlankLines = props.md4cFlags.preserveBlankLines,
+      .md4cFlagsAdmonitions = props.md4cFlags.admonitions,
+      .styleFingerprint = computeStyleFingerprint(props.tiptapStyle),
+      .linkPillContentFingerprint = computeLinkPillContentFingerprint(props.linkPillContent),
+      .wrappedCodeBlocksFingerprint = wrappedCodeBlocksFingerprint,
+      .fontScale = fontScale,
+      .flavor = flavor,
+      .lineBreakStrategyIOS = props.lineBreakStrategyIOS,
+      .writingDirection = props.writingDirection,
+      .numberOfLines = props.numberOfLines,
+      .ellipsizeMode = props.ellipsizeMode,
+      .linkRegexKey = buildLinkRecognitionCacheKey(props.linkRecognition.text),
+      .inlineCodeLinkRegexKey = buildLinkRecognitionCacheKey(props.linkRecognition.inlineCode),
+  };
+}
+
+/**
+ * Thread-safe global measurement cache using an LRU (Least Recently Used) strategy.
+ * This ensures O(1) lookups while automatically discarding the oldest entries.
+ */
+class MeasurementCache {
+public:
+  struct CacheEntry {
+    MeasurementCacheKey key;
+    CachedSize size;
+  };
+
+  static MeasurementCache &shared()
+  {
+    static MeasurementCache instance;
+    return instance;
+  }
+
+  bool get(const MeasurementCacheKey &key, CachedSize &outSize)
+  {
+    std::lock_guard<std::mutex> lock(mutex_);
+
+    auto it = map_.find(key);
+    if (it == map_.end()) {
+      return false;
+    }
+
+    list_.splice(list_.begin(), list_, it->second);
+
+    outSize = it->second->size;
+    return true;
+  }
+
+  void set(const MeasurementCacheKey &key, CachedSize size)
+  {
+    std::lock_guard<std::mutex> lock(mutex_);
+
+    auto it = map_.find(key);
+    if (it != map_.end()) {
+      it->second->size = size;
+      list_.splice(list_.begin(), list_, it->second);
+      return;
+    }
+
+    list_.push_front({key, size});
+    map_[key] = list_.begin();
+
+    if (map_.size() > kMaxEntries) {
+      auto &lastEntry = list_.back();
+      map_.erase(lastEntry.key);
+      list_.pop_back();
+    }
+  }
+
+  void removeMatchingTiptap(const std::string &tiptap)
+  {
+    std::lock_guard<std::mutex> lock(mutex_);
+
+    for (auto it = list_.begin(); it != list_.end();) {
+      if (it->key.tiptap == tiptap) {
+        map_.erase(it->key);
+        it = list_.erase(it);
+      } else {
+        ++it;
+      }
+    }
+  }
+
+private:
+  MeasurementCache() = default;
+
+  static constexpr size_t kMaxEntries = 512;
+  mutable std::mutex mutex_;
+
+  std::list<CacheEntry> list_;
+  std::unordered_map<MeasurementCacheKey, std::list<CacheEntry>::iterator, MeasurementCacheKeyHash> map_;
+};
+
+} // namespace facebook::react

package/ios/internals/ShadowMeasurementUtils.h

@@ -0,0 +1,145 @@
+#pragma once
+
+#include "MeasurementCache.h"
+#import <Foundation/Foundation.h>
+#import <React/RCTUtils.h>
+#include <algorithm>
+#include <cmath>
+#include <react/renderer/core/LayoutConstraints.h>
+#include <react/renderer/core/LayoutContext.h>
+#include <react/utils/ManagedObjectWrapper.h>
+
+namespace facebook::react {
+
+// Threading contract (issue #550): measureContent may run on any thread while
+// RN holds commit locks that main-thread committers (e.g. Reanimated) also
+// acquire — with `preventShadowTreeCommitExhaustion`, the JS thread re-runs
+// layout under `revisionMutexRecursive_` after 3 failed optimistic commits.
+// Any dispatch_sync to main from this path can therefore deadlock: JS waits
+// for main, main waits for the mutex JS holds (watchdog kill 0x8BADF00D).
+// Nothing in the measurement path may wait on the main thread.
+// EnrichedTiptapText and EnrichedTiptap both measure view-free
+// (ENRMViewFreeMeasurement.h) and comply fully. The one known remaining
+// violation is the text input's own measureContent
+// (EnrichedTiptapTextInputShadowNode.mm), which measures live editable
+// UITextView state and needs its own strategy.
+
+/**
+ * Font scale (Dynamic Type multiplier) for measurement, without touching the
+ * main thread.
+ *
+ * Reads `LayoutContext::fontSizeMultiplier` instead of calling
+ * `RCTFontSizeMultiplier()` (a UIKit read that previously forced a
+ * dispatch_sync to main on every measure — a deadlock window under the locked
+ * commit fallback, see the contract above). RN maintains the multiplier for
+ * us: `RCTFabricSurface::_updateLayoutContext` sets it on main from
+ * `RCTFontSizeMultiplier()` and re-runs `constraintLayout` whenever
+ * `UIContentSizeCategoryDidChangeNotification` fires, so every Dynamic Type
+ * change re-measures with the fresh value. This is the same source
+ * `ParagraphShadowNode` uses for core text. A measure racing a Dynamic Type
+ * change at worst caches under the outgoing scale, which is never read again
+ * once the re-layout lands.
+ */
+static inline CGFloat ENRMFontScaleForMeasurement(bool allowFontScaling, const LayoutContext &layoutContext)
+{
+  return allowFontScaling ? layoutContext.fontSizeMultiplier : 1.0;
+}
+
+static inline Size ENRMClampMeasuredSize(CGSize size, const LayoutConstraints &layoutConstraints)
+{
+  Float clampedWidth = std::max((Float)size.width, layoutConstraints.minimumSize.width);
+  clampedWidth = std::min(clampedWidth, layoutConstraints.maximumSize.width);
+  Float clampedHeight = std::max((Float)size.height, layoutConstraints.minimumSize.height);
+  if (std::isfinite(layoutConstraints.maximumSize.height)) {
+    clampedHeight = std::min(clampedHeight, layoutConstraints.maximumSize.height);
+  }
+  return {clampedWidth, clampedHeight};
+}
+
+template <typename PropsT>
+static inline bool ENRMPropsNeedExactStreamingMeasurement(const PropsT &oldProps, const PropsT &newProps)
+{
+  return oldProps.streamingAnimation != newProps.streamingAnimation ||
+         oldProps.allowFontScaling != newProps.allowFontScaling ||
+         oldProps.maxFontSizeMultiplier != newProps.maxFontSizeMultiplier ||
+         oldProps.allowTrailingMargin != newProps.allowTrailingMargin ||
+         oldProps.md4cFlags.underline != newProps.md4cFlags.underline ||
+         oldProps.md4cFlags.superscript != newProps.md4cFlags.superscript ||
+         oldProps.md4cFlags.subscript != newProps.md4cFlags.subscript ||
+         oldProps.md4cFlags.latexMath != newProps.md4cFlags.latexMath ||
+         oldProps.md4cFlags.highlight != newProps.md4cFlags.highlight ||
+         oldProps.md4cFlags.hardSoftBreaks != newProps.md4cFlags.hardSoftBreaks ||
+         oldProps.md4cFlags.preserveBlankLines != newProps.md4cFlags.preserveBlankLines ||
+         oldProps.isGFM != newProps.isGFM || oldProps.md4cFlags.admonitions != newProps.md4cFlags.admonitions ||
+         computeStyleFingerprint(oldProps.tiptapStyle) != computeStyleFingerprint(newProps.tiptapStyle);
+}
+
+/**
+ * Shared measureContent implementation for the tiptap component views.
+ *
+ * Owns the thread-safe layers — the streaming fast path (lock-free
+ * `ENRMAtomicSize` mailbox published by `updateLayoutMetrics:`), the
+ * LRU measurement cache, and the `layoutContext`-sourced font scale — then
+ * delegates cache misses to `measureUncached`, through which both components
+ * plug their view-free pipeline (`ENRMMeasureTiptapViewFree` /
+ * `ENRMMeasureSegmentedTiptapViewFree`); the resolved view is still handed
+ * to the block for strategies that can use it. `fontScale` handed to the
+ * block is the real multiplier even when streaming skips the cache —
+ * rendering must always use it. `wrappedCodeBlocksFingerprint` folds view
+ * state outside the props that changes the size (code blocks the user wrapped)
+ * into the cache key.
+ */
+template <typename PropsT, typename ViewT>
+static inline Size
+ENRMMeasureTiptapContent(const PropsT &typedProps, const std::shared_ptr<void> &componentViewRef, int receivedCounter,
+                           int &lastExactMeasurementCounter, CGSize &lastExactMeasurementSize, TiptapFlavor flavor,
+                           const LayoutContext &layoutContext, const LayoutConstraints &layoutConstraints,
+                           CGSize (^measureUncached)(ViewT *view, CGFloat maxWidth, CGFloat fontScale),
+                           size_t wrappedCodeBlocksFingerprint = 0)
+{
+  CGFloat maxWidth = layoutConstraints.maximumSize.width;
+
+  RCTInternalGenericWeakWrapper *weakWrapper = (RCTInternalGenericWeakWrapper *)unwrapManagedObject(componentViewRef);
+  ViewT *view = weakWrapper ? (ViewT *)weakWrapper.object : nil;
+
+  // Streaming fast path. Yoga re-measures several times per pass; the first call
+  // bumps lastExactMeasurementCounter, the rest land here. Return the freshly
+  // measured size, not the view's mailbox — mid-pass the frame isn't committed,
+  // so the mailbox is a generation stale and would freeze the height.
+  if (typedProps.streamingAnimation && view && receivedCounter <= lastExactMeasurementCounter) {
+    if (lastExactMeasurementSize.width > 0 && lastExactMeasurementSize.height > 0) {
+      return ENRMClampMeasuredSize(lastExactMeasurementSize, layoutConstraints);
+    }
+    CGSize currentSize = [view lastCommittedLayoutSize];
+    if (currentSize.width > 0 && currentSize.height > 0) {
+      return ENRMClampMeasuredSize(currentSize, layoutConstraints);
+    }
+  }
+
+  const bool shouldUseMeasurementCache = !typedProps.streamingAnimation;
+  CGFloat fontScale = ENRMFontScaleForMeasurement(typedProps.allowFontScaling, layoutContext);
+
+  if (shouldUseMeasurementCache && !typedProps.document.empty()) {
+    auto cacheKey = buildMeasurementCacheKey(typedProps, maxWidth, fontScale, flavor, wrappedCodeBlocksFingerprint);
+    CachedSize cached;
+    if (MeasurementCache::shared().get(cacheKey, cached)) {
+      return ENRMClampMeasuredSize(CGSizeMake(cached.width, cached.height), layoutConstraints);
+    }
+  }
+
+  CGSize size = measureUncached(view, maxWidth, fontScale);
+
+  if (shouldUseMeasurementCache && !typedProps.document.empty()) {
+    auto cacheKey = buildMeasurementCacheKey(typedProps, maxWidth, fontScale, flavor, wrappedCodeBlocksFingerprint);
+    MeasurementCache::shared().set(cacheKey, {size.width, size.height});
+  }
+
+  if (typedProps.streamingAnimation) {
+    lastExactMeasurementCounter = receivedCounter;
+    lastExactMeasurementSize = size;
+  }
+
+  return ENRMClampMeasuredSize(size, layoutConstraints);
+}
+
+} // namespace facebook::react

package/ios/parser/ENRMTextLinkAttributes.h

@@ -0,0 +1,7 @@
+#pragma once
+
+#import <Foundation/Foundation.h>
+
+// Rendering metadata only. Copy reconstruction retains the source semantics.
+static NSString *const ENRMRecognizedLinkAttributeName = @"ENRMRecognizedLink";
+static NSString *const ENRMRecognizedLinkOriginalUnderlineAttributeName = @"ENRMRecognizedLinkOriginalUnderline";

package/ios/parser/ENRMTiptapParser.h

@@ -0,0 +1,33 @@
+#import "TiptapASTNode.h"
+#import <Foundation/Foundation.h>
+
+@interface ENRMMd4cFlags : NSObject <NSCopying>
+
+@property (nonatomic, assign) BOOL underline;
+@property (nonatomic, assign) BOOL latexMath;
+@property (nonatomic, assign) BOOL superscript;
+@property (nonatomic, assign) BOOL subscript;
+@property (nonatomic, assign) BOOL highlight;
+@property (nonatomic, assign) BOOL hardSoftBreaks;
+@property (nonatomic, assign) BOOL preserveBlankLines;
+@property (nonatomic, assign) BOOL admonitions;
+
++ (instancetype)defaultFlags;
+
+@end
+
+@class ENRMLinkRegexConfig;
+
+@interface ENRMTiptapParser : NSObject
+
+- (TiptapASTNode *)parseTiptap:(NSString *)tiptap;
+- (TiptapASTNode *)parseTiptap:(NSString *)tiptap flags:(ENRMMd4cFlags *)flags;
+- (TiptapASTNode *)parseTiptap:(NSString *)tiptap flags:(ENRMMd4cFlags *)flags isGFM:(BOOL)isGFM;
+// Recognition runs before returning the AST to renderers and measurement.
+- (TiptapASTNode *)parseTiptap:(NSString *)tiptap
+                             flags:(ENRMMd4cFlags *)flags
+                             isGFM:(BOOL)isGFM
+                         linkRegex:(ENRMLinkRegexConfig *)linkRegex
+               inlineCodeLinkRegex:(ENRMLinkRegexConfig *)inlineCodeLinkRegex;
+
+@end

package/ios/parser/ENRMTiptapParser.mm

@@ -0,0 +1,73 @@
+#import "ENRMTiptapParser.h"
+#import "ENRMLinkRegexConfig.h"
+#import "TiptapASTNode.h"
+
+extern TiptapASTNode *parseTiptapWithCppParser(NSString *tiptap, ENRMMd4cFlags *flags, BOOL isGFM);
+extern TiptapASTNode *parseTiptapWithCppParser(NSString *tiptap, ENRMMd4cFlags *flags, BOOL isGFM,
+                                                   ENRMLinkRegexConfig *textRegex, ENRMLinkRegexConfig *codeRegex);
+
+@implementation ENRMMd4cFlags
+
+- (instancetype)init
+{
+  if (self = [super init]) {
+    _underline = NO;
+    _latexMath = YES;
+    _superscript = NO;
+    _subscript = NO;
+    _highlight = NO;
+    _hardSoftBreaks = NO;
+    _preserveBlankLines = NO;
+    _admonitions = YES;
+  }
+  return self;
+}
+
++ (instancetype)defaultFlags
+{
+  return [[ENRMMd4cFlags alloc] init];
+}
+
+- (id)copyWithZone:(NSZone *)zone
+{
+  ENRMMd4cFlags *copy = [[ENRMMd4cFlags allocWithZone:zone] init];
+  copy.underline = self.underline;
+  copy.latexMath = self.latexMath;
+  copy.superscript = self.superscript;
+  copy.subscript = self.subscript;
+  copy.highlight = self.highlight;
+  copy.hardSoftBreaks = self.hardSoftBreaks;
+  copy.preserveBlankLines = self.preserveBlankLines;
+  copy.admonitions = self.admonitions;
+  return copy;
+}
+
+@end
+
+@implementation ENRMTiptapParser
+
+- (TiptapASTNode *)parseTiptap:(NSString *)tiptap
+{
+  return [self parseTiptap:tiptap flags:[ENRMMd4cFlags defaultFlags]];
+}
+
+- (TiptapASTNode *)parseTiptap:(NSString *)tiptap flags:(ENRMMd4cFlags *)flags
+{
+  return [self parseTiptap:tiptap flags:flags isGFM:YES];
+}
+
+- (TiptapASTNode *)parseTiptap:(NSString *)tiptap flags:(ENRMMd4cFlags *)flags isGFM:(BOOL)isGFM
+{
+  return parseTiptapWithCppParser(tiptap, flags, isGFM);
+}
+
+- (TiptapASTNode *)parseTiptap:(NSString *)tiptap
+                             flags:(ENRMMd4cFlags *)flags
+                             isGFM:(BOOL)isGFM
+                         linkRegex:(ENRMLinkRegexConfig *)linkRegex
+               inlineCodeLinkRegex:(ENRMLinkRegexConfig *)inlineCodeLinkRegex
+{
+  return parseTiptapWithCppParser(tiptap, flags, isGFM, linkRegex, inlineCodeLinkRegex);
+}
+
+@end

package/ios/parser/TiptapASTNode.h

@@ -0,0 +1,57 @@
+#import <Foundation/Foundation.h>
+
+typedef NS_ENUM(NSInteger, TiptapNodeType) {
+  TiptapNodeTypeDocument,
+  TiptapNodeTypeParagraph,
+  TiptapNodeTypeText,
+  TiptapNodeTypeLink,
+  TiptapNodeTypeHeading,
+  TiptapNodeTypeLineBreak,
+  TiptapNodeTypeStrong,
+  TiptapNodeTypeEmphasis,
+  TiptapNodeTypeStrikethrough,
+  TiptapNodeTypeUnderline,
+  TiptapNodeTypeCode,
+  TiptapNodeTypeImage,
+  TiptapNodeTypeBlockquote,
+  TiptapNodeTypeUnorderedList,
+  TiptapNodeTypeOrderedList,
+  TiptapNodeTypeListItem,
+  TiptapNodeTypeCodeBlock,
+  TiptapNodeTypeThematicBreak,
+  TiptapNodeTypeTable,
+  TiptapNodeTypeTableHead,
+  TiptapNodeTypeTableBody,
+  TiptapNodeTypeTableRow,
+  TiptapNodeTypeTableHeaderCell,
+  TiptapNodeTypeTableCell,
+  TiptapNodeTypeLatexMathInline,
+  TiptapNodeTypeLatexMathDisplay,
+  TiptapNodeTypeSpoiler,
+  TiptapNodeTypeSuperscript,
+  TiptapNodeTypeSubscript,
+  TiptapNodeTypeHighlight,
+  TiptapNodeTypeSoftBreak,
+  TiptapNodeTypeBlankLine,
+  TiptapNodeTypeAdmonition,
+  TiptapNodeTypeVideo,
+  TiptapNodeTypeFactoid,
+  TiptapNodeTypeMention
+};
+
+@interface TiptapASTNode : NSObject
+
+@property (nonatomic, assign) TiptapNodeType type;
+@property (nonatomic, strong) NSString *content;
+@property (nonatomic, strong) NSMutableDictionary *attributes;
+@property (nonatomic, strong) NSMutableArray<TiptapASTNode *> *children;
+
+- (instancetype)initWithType:(TiptapNodeType)type;
+- (void)addChild:(TiptapASTNode *)child;
+- (void)setAttribute:(NSString *)key value:(NSString *)value;
+
+@end
+
+/// A node type that md4c emits as a standalone block stacked vertically,
+/// as opposed to an inline span.
+BOOL ENRMIsTopLevelBlockType(TiptapNodeType type);

package/ios/parser/TiptapASTNode.m

@@ -0,0 +1,52 @@
+#import "TiptapASTNode.h"
+
+@implementation TiptapASTNode
+
+- (instancetype)initWithType:(TiptapNodeType)type
+{
+  if (self = [super init]) {
+    _type = type;
+    _content = nil;
+    _attributes = [[NSMutableDictionary alloc] init];
+    _children = [[NSMutableArray alloc] init];
+  }
+  return self;
+}
+
+- (void)addChild:(TiptapASTNode *)child
+{
+  [_children addObject:child];
+}
+
+- (void)setAttribute:(NSString *)key value:(NSString *)value
+{
+  _attributes[key] = value;
+}
+
+- (NSString *)description
+{
+  return [NSString stringWithFormat:@"TiptapASTNode(type=%ld, content=%@, children=%lu)", (long)_type, _content,
+                                    (unsigned long)_children.count];
+}
+
+@end
+
+BOOL ENRMIsTopLevelBlockType(TiptapNodeType type)
+{
+  switch (type) {
+    case TiptapNodeTypeParagraph:
+    case TiptapNodeTypeHeading:
+    case TiptapNodeTypeCodeBlock:
+    case TiptapNodeTypeBlockquote:
+    case TiptapNodeTypeAdmonition:
+    case TiptapNodeTypeTable:
+    case TiptapNodeTypeUnorderedList:
+    case TiptapNodeTypeOrderedList:
+    case TiptapNodeTypeThematicBreak:
+    case TiptapNodeTypeBlankLine:
+    case TiptapNodeTypeLatexMathDisplay:
+      return YES;
+    default:
+      return NO;
+  }
+}