react-native-marcus 0.1.0

package/apple/MarkdownParser.swift

@@ -0,0 +1,200 @@
+import CxxStdlib
+import Foundation
+import MarkdownCxx
+
+/// Caches markdown ranges and keeps the parser off the main thread.
+///
+/// Running the worklet waits on the markdown runtime. Waiting for it on the main
+/// thread during a Yoga measure could outlast the watchdog, so callers on the
+/// main thread use `cachedRanges(forText:withParserId:)` and fall back to
+/// `warmCacheAsync(forText:withParserId:completion:)`.
+@objc public final class MarkdownParser: NSObject {
+
+  /// One shared instance, so the view layer and the shadow node's measure pass
+  /// hit the same cache. With an instance each, every keystroke was parsed
+  /// twice: once when the text view reformatted, and again when the shadow node
+  /// measured and found its own cache empty.
+  @objc public static let sharedParser = MarkdownParser()
+
+  private struct CacheEntry {
+    let text: String
+    let parserId: Int
+    let ranges: [MarcusRange]
+  }
+
+  /// One entry is not enough once the main thread is restricted to cached
+  /// ranges: two texts alternating (typing then undoing, or an input echoing
+  /// older text back) evict each other and the main thread never finds what it
+  /// needs. The cache is also shared by every markdown input on screen, so it
+  /// needs room for a few distinct texts -- still short enough to scan linearly,
+  /// and entries only hold range objects.
+  private static let cacheCapacity = 8
+
+  /// Serial on purpose: the markdown runtime runs one parse at a time anyway,
+  /// and serialising here avoids doing the same work twice.
+  private static let warmupQueue = DispatchQueue(
+    label: "app.getbullet.marcus.parser-cache-warmup",
+    qos: .userInitiated
+  )
+
+  /// Guards everything below, and is never held across a parse. Holding a lock
+  /// while waiting on the markdown runtime is what let a background parse block
+  /// the main thread until iOS killed the app.
+  private let lock = NSLock()
+
+  /// Newest entry first.
+  private var cache: [CacheEntry] = []
+
+  private var pendingText: String?
+  private var pendingParserId: NSNumber?
+  private var pendingCompletion: (() -> Void)?
+  private var warmupScheduled = false
+
+  // MARK: - Cache
+
+  /// Returns the ranges for (text, parserId) only if they are already cached.
+  /// Never runs the parser, so it is safe on the main thread.
+  @objc public func cachedRanges(
+    forText text: String,
+    withParserId parserId: NSNumber
+  ) -> [MarcusRange]? {
+    lock.lock()
+    defer { lock.unlock() }
+
+    guard
+      let index = cache.firstIndex(where: {
+        $0.parserId == parserId.intValue && $0.text == text
+      })
+    else { return nil }
+
+    guard index != 0 else { return cache[0].ranges }
+
+    // Promote, so text asked for repeatedly is not the next evicted.
+    let entry = cache.remove(at: index)
+    cache.insert(entry, at: 0)
+    return entry.ranges
+  }
+
+  private func store(
+    _ ranges: [MarcusRange],
+    forText text: String,
+    parserId: NSNumber
+  ) {
+    lock.lock()
+    defer { lock.unlock() }
+
+    cache.removeAll { $0.parserId == parserId.intValue && $0.text == text }
+    cache.insert(
+      CacheEntry(text: text, parserId: parserId.intValue, ranges: ranges),
+      at: 0
+    )
+    if cache.count > Self.cacheCapacity {
+      cache.removeLast(cache.count - Self.cacheCapacity)
+    }
+  }
+
+  // MARK: - Parsing
+
+  /// Returns cached ranges when there are any, otherwise parses and caches.
+  /// Never call this from the main thread on a layout path.
+  @objc public func parse(_ text: String, withParserId parserId: NSNumber)
+    -> [MarcusRange]
+  {
+    if let cached = cachedRanges(forText: text, withParserId: parserId) {
+      return cached
+    }
+
+    // Deliberately parsed with no lock held. Two threads may parse the same text
+    // concurrently, which is harmless -- they produce the same result.
+    let ranges = parseUncached(text, parserId: parserId)
+    store(ranges, forText: text, parserId: parserId)
+    return ranges
+  }
+
+  private func parseUncached(_ text: String, parserId: NSNumber)
+    -> [MarcusRange]
+  {
+    // `utf16.count` is the unit the worklet reports range offsets in.
+    let result = bulletpoint.marcus.parseMarkdown(
+      std.string(text),
+      text.utf16.count,
+      Int32(parserId.intValue)
+    )
+
+    let schemaError = String(result.schemaError)
+    if !schemaError.isEmpty {
+      markdownLogWarn(
+        "[react-native-marcus] Incorrect schema of worklet parser output: \(schemaError)"
+      )
+    }
+
+    return result.ranges.map { range in
+      MarcusRange(
+        type: String(range.type),
+        range: NSRange(location: Int(range.start), length: Int(range.length)),
+        depth: UInt(range.depth)
+      )
+    }
+  }
+
+  // MARK: - Background warm-up
+
+  /// Parses on a background queue and caches the result, so the caller never
+  /// waits on the markdown runtime.
+  ///
+  /// Only the newest request survives: a later call replaces one that is still
+  /// queued. A parse already in flight cannot be cancelled, but the newest text
+  /// is picked up as soon as it finishes.
+  ///
+  /// `completion` runs on the background queue once the ranges are cached, and
+  /// is skipped when a newer request replaced this one -- that request reports
+  /// instead.
+  @objc public func warmCacheAsync(
+    forText text: String,
+    withParserId parserId: NSNumber,
+    completion: (() -> Void)?
+  ) {
+    lock.lock()
+    // Keep only the newest request, so stale text can never win over newer text.
+    // The replaced completion goes with it; the newer request reports instead.
+    pendingText = text
+    pendingParserId = parserId
+    pendingCompletion = completion
+    let alreadyScheduled = warmupScheduled
+    warmupScheduled = true
+    lock.unlock()
+
+    // A drain loop is already running and will pick this up.
+    guard !alreadyScheduled else { return }
+
+    Self.warmupQueue.async { [weak self] in
+      self?.drainPendingWarmups()
+    }
+  }
+
+  private func drainPendingWarmups() {
+    while true {
+      lock.lock()
+      guard let text = pendingText, let parserId = pendingParserId else {
+        warmupScheduled = false
+        lock.unlock()
+        return
+      }
+      let completion = pendingCompletion
+      pendingText = nil
+      pendingParserId = nil
+      pendingCompletion = nil
+      lock.unlock()
+
+      _ = parse(text, withParserId: parserId)
+
+      lock.lock()
+      let superseded = pendingText != nil
+      lock.unlock()
+
+      if !superseded {
+        completion?()
+      }
+    }
+  }
+}

package/apple/MarkdownSwiftInterop.h

@@ -0,0 +1,23 @@
+#pragma once
+
+// Single entry point for Objective-C++ code that needs the Swift half of the
+// module.
+//
+// The generated Swift interface header references Objective-C types from other
+// modules without importing them, so those have to be in scope first. It also
+// lands in a different place depending on how the pod is linked: inside the
+// framework with use_frameworks!, and in the target's DerivedSources otherwise.
+
+#import <React/RCTBackedTextInputDelegate.h>
+#import <React/RCTUITextField.h>
+#import <React/RCTUITextView.h>
+
+#import <RNMarcus/MarcusRange.h>
+#import <RNMarcus/RCTMarcusStyle.h>
+#import <RNMarcus/RCTMarcusUtils.h>
+
+#if __has_include(<RNMarcus/RNMarcus-Swift.h>)
+#import <RNMarcus/RNMarcus-Swift.h>
+#else
+#import "RNMarcus-Swift.h"
+#endif

package/apple/MarkdownTextBackground.swift

@@ -0,0 +1,17 @@
+import UIKit
+
+/// The rounded background drawn behind a mention.
+///
+/// Stored as an attributed-string attribute value under
+/// `.marcusTextBackground`, so it stays an object rather than a struct.
+final class MarkdownTextBackground: NSObject {
+  var color: UIColor = .clear
+  var borderRadius: CGFloat = 0
+}
+
+/// A `MarkdownTextBackground` paired with the range it applies to. Only ever a
+/// local pairing while drawing, never stored in an attributed string.
+struct MarkdownTextBackgroundWithRange {
+  let textBackground: MarkdownTextBackground
+  let range: NSRange
+}

package/apple/MarkdownTextFieldObserver.swift

@@ -0,0 +1,90 @@
+import React
+import UIKit
+
+/// Keeps a single-line text field formatted. Unlike the multiline case there is
+/// no text storage to hook, so this reacts to control events and KVO instead and
+/// rewrites `attributedText` in place.
+@objc public final class MarkdownTextFieldObserver: NSObject {
+
+  // Strong on purpose -- see MarkdownTextStorageDelegate.
+  private let textField: RCTUITextField
+  private let markdownUtils: RCTMarcusUtils
+
+  /// Guards against the KVO observer re-entering while we assign `attributedText`.
+  private var active = true
+
+  @objc public init(textField: RCTUITextField, markdownUtils: RCTMarcusUtils)
+  {
+    self.textField = textField
+    self.markdownUtils = markdownUtils
+    super.init()
+  }
+
+  public override func observeValue(
+    forKeyPath keyPath: String?,
+    of object: Any?,
+    change: [NSKeyValueChangeKey: Any]?,
+    context: UnsafeMutableRawPointer?
+  ) {
+    guard active, keyPath == "text" || keyPath == "attributedText" else {
+      return
+    }
+    applyMarkdownFormatting()
+  }
+
+  @objc public func textFieldDidChange(_ textField: UITextField) {
+    applyMarkdownFormatting()
+  }
+
+  @objc public func textFieldDidEndEditing(_ textField: UITextField) {
+    // Stops iOS underlining the whole field on blur when the text ends with a
+    // link: `defaultTextAttributes` does not carry NSUnderline yet at this
+    // point, so pushing a fresh value forces it to be picked up. The setter
+    // compares deeply, so the value has to actually differ each time -- hence
+    // the counter.
+    var defaultTextAttributes = self.textField.defaultTextAttributes ?? [:]
+    defaultTextAttributes[Self.forceUpdateAttributeName] =
+      Self.nextForceUpdateToken()
+    self.textField.defaultTextAttributes = defaultTextAttributes
+
+    applyMarkdownFormatting()
+  }
+
+  private static let forceUpdateAttributeName = NSAttributedString.Key(
+    "RCTMarcusForceUpdate"
+  )
+  private static var forceUpdateCounter: UInt = 0
+
+  private static func nextForceUpdateToken() -> NSNumber {
+    defer { forceUpdateCounter &+= 1 }
+    return NSNumber(value: forceUpdateCounter)
+  }
+
+  private func applyMarkdownFormatting() {
+    // Skip during multi-stage input (e.g. Japanese kana conversion), otherwise
+    // rewriting the text breaks the input method's internal state.
+    guard textField.markedTextRange == nil else { return }
+
+    guard
+      let attributedText = textField.attributedText?.mutableCopy()
+        as? NSMutableAttributedString
+    else { return }
+
+    markdownUtils.applyMarkdownFormatting(
+      attributedText,
+      withDefaultTextAttributes: textField.defaultTextAttributes ?? [:]
+    )
+
+    let selectedTextRange = textField.selectedTextRange
+
+    active = false
+    textField.attributedText = attributedText
+    active = true
+
+    textField.setSelectedTextRange(selectedTextRange, notifyDelegate: false)
+
+    // Prevents underline flicker while typing when the previous text ends with
+    // a link.
+    textField.typingAttributes = textField.defaultTextAttributes
+  }
+}

package/apple/MarkdownTextLayoutFragment.swift

@@ -0,0 +1,205 @@
+import UIKit
+
+/// Draws the parts of markdown rendering that plain attributed-string attributes
+/// can't express: blockquote ribbons down the left edge, and rounded background
+/// pills behind mentions.
+///
+/// Only constructed by `MarkdownTextLayoutManagerDelegate`, so it stays internal
+/// to the Swift half of the module.
+final class MarkdownTextLayoutFragment: NSTextLayoutFragment {
+
+  var markdownStyle: RCTMarcusStyle?
+  var depth: Int = 0
+  /// Distance from the paragraph's left edge to the blockquote's own box:
+  /// whatever containers nesting outside it indent by, plus the room left for a
+  /// list marker drawn in front of the ribbons.
+  var outerIndent: CGFloat = 0
+  var mentions: [MarkdownTextBackgroundWithRange] = []
+
+  // MARK: - NSTextLayoutFragment
+
+  override var renderingSurfaceBounds: CGRect {
+    guard depth > 0 else { return super.renderingSurfaceBounds }
+    return boundingRect.union(super.renderingSurfaceBounds)
+  }
+
+  override func draw(at point: CGPoint, in context: CGContext) {
+    guard !textLineFragments.isEmpty else {
+      super.draw(at: point, in: context)
+      return
+    }
+
+    drawBlockquoteRibbons()
+    drawMentions()
+
+    super.draw(at: point, in: context)
+  }
+
+  // MARK: - Custom elements
+
+  private func drawBlockquoteRibbons() {
+    guard depth > 0, let style = markdownStyle else { return }
+
+    let borderWidth = style.blockquoteBorderWidth
+    let shift =
+      style.blockquoteMarginLeft + borderWidth + style.blockquotePaddingLeft
+
+    style.blockquoteBorderColor.setFill()
+
+    let bounds = boundingRect
+    for level in 0..<depth {
+      let x = bounds.origin.x + CGFloat(level) * shift
+      UIRectFill(
+        CGRect(
+          x: x,
+          y: bounds.origin.y,
+          width: borderWidth,
+          height: bounds.size.height
+        )
+      )
+    }
+  }
+
+  private func drawMentions() {
+    guard !mentions.isEmpty else { return }
+
+    let isSingleline = textLineFragments.count == 1
+
+    // Carried across line fragments: mentions are ordered, so each line resumes
+    // scanning where the previous one left off rather than restarting.
+    var mentionIndex = 0
+
+    for lineFragment in textLineFragments {
+      let lineRange = lineFragment.characterRange
+      if lineRange.length == 0 { continue }
+
+      let lineBounds = lineFragment.typographicBounds
+      // Absolute index into the source string, not a fragment-relative offset.
+      let lineEndLocation = lineFragment.locationForCharacter(
+        at: NSMaxRange(lineRange)
+      )
+
+      while mentionIndex < mentions.count,
+        NSMaxRange(mentions[mentionIndex].range) <= lineRange.location
+      {
+        mentionIndex += 1
+      }
+
+      for i in mentionIndex..<mentions.count {
+        let mention = mentions[i]
+        if mention.range.location >= NSMaxRange(lineRange) { break }
+
+        // Soft wrapping can split a mention across line fragments, so only the
+        // part falling on this line is drawn here; the corners are rounded on
+        // whichever side actually terminates the mention.
+        let intersection = NSIntersectionRange(lineRange, mention.range)
+        let startLocation = lineFragment.locationForCharacter(
+          at: intersection.location
+        )
+
+        // Singleline: the mention starts off screen, nothing to draw. Only
+        // happens while the text input is unfocused.
+        if isSingleline, startLocation.x == 0, intersection.location > 0 {
+          continue
+        }
+
+        var endLocation = lineFragment.locationForCharacter(
+          at: intersection.location + intersection.length
+        )
+
+        // Singleline: the mention is only partially visible -- it either starts
+        // mid-line or at the very beginning of the line.
+        if isSingleline,
+          startLocation.x > endLocation.x
+            || (startLocation.x == endLocation.x && intersection.location == 0)
+        {
+          endLocation = lineEndLocation
+        }
+
+        guard
+          let font = lineFragment.attributedString.attribute(
+            .font,
+            at: intersection.location,
+            effectiveRange: nil
+          ) as? UIFont
+        else { continue }
+
+        let backgroundRect = CGRect(
+          x: lineBounds.origin.x + startLocation.x,
+          y: lineBounds.origin.y + startLocation.y - font.ascender,
+          width: endLocation.x - startLocation.x,
+          height: font.lineHeight
+        )
+
+        var corners: UIRectCorner = []
+        if intersection.location == mention.range.location {
+          corners.insert([.topLeft, .bottomLeft])
+        }
+        if NSMaxRange(intersection) == NSMaxRange(mention.range) {
+          corners.insert([.topRight, .bottomRight])
+        }
+
+        let radius = mention.textBackground.borderRadius
+        let path =
+          corners.isEmpty
+          ? UIBezierPath(rect: backgroundRect)
+          : UIBezierPath(
+            roundedRect: backgroundRect,
+            byRoundingCorners: corners,
+            cornerRadii: CGSize(width: radius, height: radius)
+          )
+
+        mention.textBackground.color.setFill()
+        path.fill()
+      }
+    }
+  }
+
+  // MARK: - Helpers
+
+  /// The strip to the left of the text that the blockquote ribbons occupy.
+  private var boundingRect: CGRect {
+    var bounds = CGRect.null
+    for lineFragment in textLineFragments
+    where lineFragment.characterRange.length != 0 {
+      bounds =
+        bounds.isNull
+        ? lineFragment.typographicBounds
+        : bounds.union(lineFragment.typographicBounds)
+    }
+
+    // A null rect has an infinite origin; offsetting it would yield an
+    // infinite rendering surface rather than an empty one.
+    guard !bounds.isNull, let style = markdownStyle else { return bounds }
+
+    let borderWidth = style.blockquoteBorderWidth
+    let shift =
+      style.blockquoteMarginLeft + borderWidth + style.blockquotePaddingLeft
+
+    // The ribbons sit at a fixed offset from the paragraph's own left edge,
+    // which is the text origin less however far this line is indented. Walking
+    // back from the text by the quote's own indent instead would move the bar
+    // whenever the line's indent changes -- a list nested inside the quote adds
+    // some, a marker drawn in front of the ribbon takes some away -- and split
+    // the bar between the lines of one quote.
+    let indent =
+      firstLineParagraphStyle?.firstLineHeadIndent ?? shift * CGFloat(depth)
+
+    bounds.origin.x -= indent - (outerIndent + style.blockquoteMarginLeft)
+    bounds.size.width = borderWidth + shift * CGFloat(depth - 1)
+    return bounds
+  }
+
+  /// Paragraph style of the fragment's first non-empty line.
+  private var firstLineParagraphStyle: NSParagraphStyle? {
+    for lineFragment in textLineFragments
+    where lineFragment.characterRange.length != 0 {
+      return lineFragment.attributedString.attribute(
+        .paragraphStyle,
+        at: lineFragment.characterRange.location,
+        effectiveRange: nil
+      ) as? NSParagraphStyle
+    }
+    return nil
+  }
+}

package/apple/MarkdownTextLayoutManagerDelegate.swift

@@ -0,0 +1,84 @@
+import UIKit
+
+/// Vends a `MarkdownTextLayoutFragment` for paragraphs that carry markdown
+/// attributes needing custom drawing, and a plain fragment for everything else.
+@objc
+public final class MarkdownTextLayoutManagerDelegate: NSObject,
+  NSTextLayoutManagerDelegate
+{
+
+  private let textStorage: NSTextStorage
+  private let markdownUtils: RCTMarcusUtils
+
+  @objc public init(textStorage: NSTextStorage, markdownUtils: RCTMarcusUtils)
+  {
+    self.textStorage = textStorage
+    self.markdownUtils = markdownUtils
+    super.init()
+  }
+
+  public func textLayoutManager(
+    _ textLayoutManager: NSTextLayoutManager,
+    textLayoutFragmentFor location: NSTextLocation,
+    in textElement: NSTextElement
+  ) -> NSTextLayoutFragment {
+    let plain = {
+      NSTextLayoutFragment(
+        textElement: textElement,
+        range: textElement.elementRange
+      )
+    }
+
+    let index = textLayoutManager.offset(
+      from: textLayoutManager.documentRange.location,
+      to: location
+    )
+    guard index < textStorage.length else { return plain() }
+
+    let depth =
+      textStorage.attribute(
+        .marcusBlockquoteDepth,
+        at: index,
+        effectiveRange: nil
+      ) as? NSNumber
+    let outerIndent =
+      textStorage.attribute(
+        .marcusBlockquoteIndent,
+        at: index,
+        effectiveRange: nil
+      ) as? NSNumber
+
+    guard let paragraph = textElement as? NSTextParagraph else {
+      return plain()
+    }
+    let attributedString = paragraph.attributedString
+
+    var mentions: [MarkdownTextBackgroundWithRange] = []
+    attributedString.enumerateAttribute(
+      .marcusTextBackground,
+      in: NSRange(location: 0, length: attributedString.length)
+    ) { value, range, _ in
+      guard let textBackground = value as? MarkdownTextBackground else {
+        return
+      }
+      mentions.append(
+        MarkdownTextBackgroundWithRange(
+          textBackground: textBackground,
+          range: range
+        )
+      )
+    }
+
+    guard depth != nil || !mentions.isEmpty else { return plain() }
+
+    let fragment = MarkdownTextLayoutFragment(
+      textElement: textElement,
+      range: textElement.elementRange
+    )
+    fragment.markdownStyle = markdownUtils.markdownStyle
+    fragment.depth = depth?.intValue ?? 0
+    fragment.outerIndent = CGFloat(outerIndent?.doubleValue ?? 0)
+    fragment.mentions = mentions
+    return fragment
+  }
+}

package/apple/MarkdownTextStorageDelegate.swift

@@ -0,0 +1,32 @@
+import React
+import UIKit
+
+/// Reformats the text view's storage after every edit.
+@objc
+public final class MarkdownTextStorageDelegate: NSObject, NSTextStorageDelegate
+{
+
+  // Strong on purpose, matching the Objective-C original. Making it weak would
+  // let the text view deallocate while this object is still installed as its
+  // storage delegate and while KVO observers are registered on it.
+  private let textView: RCTUITextView
+  private let markdownUtils: RCTMarcusUtils
+
+  @objc public init(textView: RCTUITextView, markdownUtils: RCTMarcusUtils) {
+    self.textView = textView
+    self.markdownUtils = markdownUtils
+    super.init()
+  }
+
+  public func textStorage(
+    _ textStorage: NSTextStorage,
+    didProcessEditing editedMask: NSTextStorage.EditActions,
+    range editedRange: NSRange,
+    changeInLength delta: Int
+  ) {
+    markdownUtils.applyMarkdownFormatting(
+      textStorage,
+      withDefaultTextAttributes: textView.defaultTextAttributes ?? [:]
+    )
+  }
+}

package/apple/MarkdownTextViewObserver.swift

@@ -0,0 +1,30 @@
+import React
+import UIKit
+
+/// Re-applies formatting when the text view's default text attributes change,
+/// which happens when style props such as colour or font size are updated.
+@objc public final class MarkdownTextViewObserver: NSObject {
+
+  // Strong on purpose -- see MarkdownTextStorageDelegate.
+  private let textView: RCTUITextView
+  private let markdownUtils: RCTMarcusUtils
+
+  @objc public init(textView: RCTUITextView, markdownUtils: RCTMarcusUtils) {
+    self.textView = textView
+    self.markdownUtils = markdownUtils
+    super.init()
+  }
+
+  public override func observeValue(
+    forKeyPath keyPath: String?,
+    of object: Any?,
+    change: [NSKeyValueChangeKey: Any]?,
+    context: UnsafeMutableRawPointer?
+  ) {
+    guard keyPath == "defaultTextAttributes" else { return }
+    // Round-tripping through textStorage re-triggers the storage delegate,
+    // which is what actually re-applies the formatting.
+    guard let attributedText = textView.attributedText else { return }
+    textView.textStorage.setAttributedString(attributedText)
+  }
+}