@eclosion-tech/react-native-yjs-text 0.1.0

package/ios/YjsTextView.swift

@@ -0,0 +1,464 @@
+import ExpoModulesCore
+import Foundation
+import UIKit
+
+/// Native editor view backing `<YTextInput>` on iOS.
+///
+/// The Expo Modules DSL requires our view to subclass `ExpoView` for prop /
+/// event wiring, so we make `ExpoView` the outer container and host a
+/// `UITextView` as a single full-bleed subview. Conceptually the user is
+/// editing the `UITextView` — the `ExpoView` is just a Yoga/Fabric-friendly
+/// shell.
+///
+/// All Y.Text ↔ UITextView translation is contained here:
+///   - JS pushes `runs` and `renderSpec` down → we build an `NSAttributedString`
+///   - JS pushes a `selection` and bumped `selectionVersion` → we update the caret
+///   - User types / pastes / deletes → `textView(_:shouldChangeTextIn:replacementText:)`
+///     fires a `replace`-shaped `onContentChange` event up
+///   - Selection moves → `textViewDidChangeSelection` fires `onNativeSelectionChange`
+///   - Focus changes → `textViewDidBeginEditing` / `textViewDidEndEditing` fire `onFocusChange`
+///
+/// Re-entrancy guard: when JS pushes runs down (in response to a remote edit
+/// it received), we temporarily set `suppressEdits` so the `shouldChangeTextIn`
+/// callback that fires while we mutate `attributedText` doesn't bounce back up
+/// to JS. The standard loop-breaking pattern, identical in shape to how
+/// `y-prosemirror` handles the same problem on web.
+public class YjsTextView: ExpoView {
+  // MARK: Props (set by Expo Modules DSL setters in YjsTextModule)
+
+  /// New runs from JS. We always rebuild on change — the runs setter is the
+  /// SOLE trigger for re-rendering text. We used to have a separate
+  /// `contentVersion` Int prop that bumped on every Y.Text change to *force*
+  /// a rebuild even when only attributes changed (the short-circuit on
+  /// `runs` setter compared plain text only). That two-prop design was
+  /// order-sensitive: Expo Modules / Fabric doesn't guarantee setter order
+  /// within a render batch, and alphabetical / generated ordering can put
+  /// `contentVersion` before `runs`. When that happened, the `contentVersion`
+  /// setter rebuilt from the *previous* runs and the subsequent `runs`
+  /// setter short-circuited — so every attribute toggle visibly lagged by
+  /// one update. Collapsing to a single trigger (and always rebuilding)
+  /// makes that race structurally impossible.
+  ///
+  /// Cost: builds an `NSAttributedString` and re-assigns
+  /// `textView.attributedText` on every runs prop change. For typed input
+  /// the JS observer short-circuits (ORIGIN_LOCAL_VIEW), so React doesn't
+  /// re-derive runs and the setter doesn't fire — so this isn't a per-
+  /// keystroke cost. For format / programmatic edits it's one rebuild per
+  /// toggle, which is what we want.
+  var runs: [YjsTextRunRecord] = [] {
+    didSet { applyRuns() }
+  }
+  var renderSpec: [String: YjsTextMarkStyleRecord] = [:] {
+    didSet { applyRuns() }
+  }
+  /// Latest selection bundle pushed from JS. We re-apply only when the
+  /// embedded `version` field changes (so a no-op re-render from React,
+  /// where the same selection prop reference is sent again, doesn't fight
+  /// the user's in-flight selection). See `YjsTextSelectionRecord` for why
+  /// this is a single bundled Record instead of two separate props.
+  var pendingSelection: YjsTextSelectionRecord? = nil {
+    didSet {
+      guard let next = pendingSelection else { return }
+      if next.version != lastAppliedSelectionVersion {
+        lastAppliedSelectionVersion = next.version
+        setSelection(from: next.from, to: next.to)
+      }
+    }
+  }
+  private var lastAppliedSelectionVersion: Int = -1
+  var editable: Bool = true {
+    didSet { textView.isEditable = editable }
+  }
+  var placeholder: String? = nil {
+    didSet { updatePlaceholderVisibility() }
+  }
+  var placeholderColor: UIColor? = UIColor(white: 0.6, alpha: 1.0) {
+    didSet { placeholderLabel.textColor = placeholderColor }
+  }
+  var baseFontSize: Double? = nil {
+    didSet { applyBaseFont(); applyRuns() }
+  }
+  var baseFontFamily: String? = nil {
+    didSet { applyBaseFont(); applyRuns() }
+  }
+  var baseColor: UIColor? = nil {
+    didSet { applyBaseFont(); applyRuns() }
+  }
+  var baseFontWeight: String? = nil {
+    didSet { applyBaseFont(); applyRuns() }
+  }
+  var baseFontStyle: String? = nil {
+    didSet { applyBaseFont(); applyRuns() }
+  }
+
+  // MARK: Events
+  //
+  // Expo's Swift `EventDispatcher` takes `[String: Any?]` payloads — the
+  // generic-payload form only exists in the Kotlin DSL. We build matching
+  // dictionaries at the dispatch sites; the JS side sees the same shape on
+  // both platforms.
+
+  let onContentChange = EventDispatcher()
+  let onNativeSelectionChange = EventDispatcher()
+  let onFocusChange = EventDispatcher()
+  // Reserved for v0.3 inline-embed taps; unused in v0.1 but declared so the
+  // Module DSL's `Events(...)` registration matches the iOS/Android contract.
+  let onMarkTap = EventDispatcher()
+
+  // MARK: Internal state
+
+  private let textView = UITextView()
+  private let placeholderLabel = UILabel()
+  /// True while we're applying a JS-driven change to `textView.attributedText`,
+  /// so the `shouldChangeTextIn` delegate doesn't echo the change back to JS.
+  private var suppressEdits: Bool = false
+  /// Same idea for selection: when JS pushes a selection down, we set this
+  /// during the `selectedRange = ...` write so the delegate doesn't echo.
+  private var suppressSelectionEvents: Bool = false
+
+  // MARK: Init
+
+  public required init(appContext: AppContext? = nil) {
+    super.init(appContext: appContext)
+    clipsToBounds = true
+    backgroundColor = .clear
+
+    textView.translatesAutoresizingMaskIntoConstraints = false
+    textView.backgroundColor = .clear
+    // Match Expo's default content insets to RN's TextInput rather than
+    // UITextView's chunky default (8/0/8/0).
+    textView.textContainerInset = UIEdgeInsets(top: 8, left: 0, bottom: 8, right: 0)
+    textView.textContainer.lineFragmentPadding = 0
+    textView.delegate = self
+    textView.adjustsFontForContentSizeCategory = true
+    addSubview(textView)
+
+    placeholderLabel.translatesAutoresizingMaskIntoConstraints = false
+    placeholderLabel.textColor = placeholderColor
+    placeholderLabel.numberOfLines = 0
+    placeholderLabel.isUserInteractionEnabled = false
+    addSubview(placeholderLabel)
+
+    NSLayoutConstraint.activate([
+      textView.topAnchor.constraint(equalTo: topAnchor),
+      textView.bottomAnchor.constraint(equalTo: bottomAnchor),
+      textView.leadingAnchor.constraint(equalTo: leadingAnchor),
+      textView.trailingAnchor.constraint(equalTo: trailingAnchor),
+      placeholderLabel.topAnchor.constraint(equalTo: topAnchor, constant: 8),
+      placeholderLabel.leadingAnchor.constraint(equalTo: leadingAnchor),
+      placeholderLabel.trailingAnchor.constraint(equalTo: trailingAnchor),
+    ])
+
+    applyBaseFont()
+    updatePlaceholderVisibility()
+  }
+
+  // MARK: Imperative
+
+  func focusInput() {
+    if !textView.isFirstResponder { _ = textView.becomeFirstResponder() }
+  }
+
+  func blurInput() {
+    if textView.isFirstResponder { _ = textView.resignFirstResponder() }
+  }
+
+  func isInputFocused() -> Bool {
+    textView.isFirstResponder
+  }
+
+  func setSelection(from: Int, to: Int) {
+    let utf16Length = (textView.attributedText.string as NSString).length
+    let clampedFrom = max(0, min(utf16Length, from))
+    let clampedTo = max(clampedFrom, min(utf16Length, to))
+    let range = NSRange(location: clampedFrom, length: clampedTo - clampedFrom)
+    suppressSelectionEvents = true
+    textView.selectedRange = range
+    suppressSelectionEvents = false
+  }
+
+  // MARK: Render
+
+  /// Currently-resolved baseline font for the editor, derived purely from the
+  /// base* props (not read back from `textView.font`).
+  ///
+  /// We compute this once per prop change and feed it into every run's
+  /// attribute build, instead of reading `textView.font` at render time.
+  /// Reading from `textView.font` is unsafe because UIKit can mutate it under
+  /// us (Dynamic Type swaps, the "Bold Text" accessibility setting silently
+  /// folding `.traitBold` into the system font, etc.). If we used a mutated
+  /// `textView.font` as the seed, every run's traits would inherit the
+  /// mutation and the whole editor would render bold/italic on top of
+  /// whatever the marks themselves request. Caching `baseFontResolved`
+  /// breaks that loop.
+  private var baseFontResolved: UIFont = UIFont.systemFont(ofSize: 16)
+
+  private func applyBaseFont() {
+    // We discard `needsObliqueness` here: the textView's baseline `.font`
+    // doesn't carry per-character attributes, so obliqueness for the
+    // baseline can't be expressed at this level. The base case where it
+    // matters (italic baseline) is rare in practice — consumers nearly
+    // always leave fontStyle off the editor's outer style and apply
+    // italic via a mark. If they do want italic baseline + custom weight,
+    // they should set a font family that natively has the variant.
+    let (resolved, _) = makeFont(
+      family: baseFontFamily,
+      size: CGFloat(baseFontSize ?? 16),
+      bold: baseFontWeight == "bold",
+      italic: baseFontStyle == "italic"
+    )
+    baseFontResolved = resolved
+    textView.font = resolved
+    textView.textColor = baseColor ?? .label
+    placeholderLabel.font = resolved
+  }
+
+  /// Build a `UIFont` for the given combination of family / size / bold /
+  /// italic, returning both the font and a flag indicating whether the
+  /// caller must apply an `NSAttributedString.Key.obliqueness` attribute as
+  /// a fallback to slant the glyphs.
+  ///
+  /// The obliqueness fallback exists because iOS's
+  /// `UIFontDescriptor.withSymbolicTraits` on the system font's descriptor
+  /// is unreliable for **combined** bold+italic resolution: it returns a
+  /// non-nil italic descriptor, but `UIFont(descriptor:size:)` then resolves
+  /// to a font that has `.traitItalic` but has **lost** the bold weight
+  /// (because the symbolic-traits round-trip drops the `NSFontWeightTrait`
+  /// attribute). That produces the "bold disappears when italic is added"
+  /// symptom. We try multiple resolution paths and verify the result
+  /// actually carries both traits; if none does, we ship true bold + a
+  /// computational slant via `.obliqueness`, which is visually
+  /// indistinguishable from SF Pro Bold Italic for most rendering purposes.
+  private func makeFont(
+    family: String?,
+    size: CGFloat,
+    bold: Bool,
+    italic: Bool
+  ) -> (font: UIFont, needsObliqueness: Bool) {
+    if let family = family {
+      // Custom family: descriptor route is fine because the family resolves
+      // to a real font file that almost certainly carries its own bold /
+      // italic variants registered with the font system.
+      var traits: UIFontDescriptor.SymbolicTraits = []
+      if bold { traits.insert(.traitBold) }
+      if italic { traits.insert(.traitItalic) }
+      let baseDescriptor = UIFontDescriptor(name: family, size: size)
+      let descriptor: UIFontDescriptor
+      if traits.isEmpty {
+        descriptor = baseDescriptor
+      } else {
+        descriptor = baseDescriptor.withSymbolicTraits(traits) ?? baseDescriptor
+      }
+      return (UIFont(descriptor: descriptor, size: size), needsObliqueness: false)
+    }
+    // System font path — use the typed UIKit APIs.
+    switch (bold, italic) {
+    case (false, false):
+      return (UIFont.systemFont(ofSize: size), false)
+    case (true, false):
+      return (UIFont.systemFont(ofSize: size, weight: .bold), false)
+    case (false, true):
+      return (UIFont.italicSystemFont(ofSize: size), false)
+    case (true, true):
+      // Try in order: (1) symbolic [bold, italic] on the bare system
+      // descriptor, (2) symbolic .traitItalic on the bold-weighted
+      // descriptor. Verify each candidate actually carries BOTH traits
+      // before accepting — descriptor round-trips on iOS commonly drop
+      // either the bold weight or the italic trait and silently return a
+      // partial-match font.
+      let combinedCandidates: [UIFontDescriptor?] = [
+        UIFont.systemFont(ofSize: size).fontDescriptor.withSymbolicTraits([.traitBold, .traitItalic]),
+        UIFont.systemFont(ofSize: size, weight: .bold).fontDescriptor.withSymbolicTraits(.traitItalic),
+      ]
+      for case let descriptor? in combinedCandidates {
+        let candidate = UIFont(descriptor: descriptor, size: size)
+        let traits = candidate.fontDescriptor.symbolicTraits
+        if traits.contains(.traitBold) && traits.contains(.traitItalic) {
+          return (candidate, false)
+        }
+      }
+      // Neither descriptor route resolved a true bold-italic font. Fall
+      // back to true bold + an obliqueness slant applied as a string
+      // attribute by the caller.
+      return (UIFont.systemFont(ofSize: size, weight: .bold), needsObliqueness: true)
+    }
+  }
+
+  /// Rebuild and apply the attributed string. Called whenever `runs`,
+  /// `renderSpec`, or any base-style prop changes.
+  ///
+  /// No more `force` parameter / short-circuit: see the `runs` comment above
+  /// for why. React-side memoisation of `serializedRuns` means this only
+  /// fires when there's actually new data; redundant runs reapplies on
+  /// unrelated parent re-renders are prevented at the JS layer.
+  private func applyRuns() {
+    let newString = buildAttributedString()
+    let previousSelected = textView.selectedRange
+    // CRITICAL: we have to suppress *both* edit and selection events around
+    // the `attributedText = ...` assignment. UITextView resets `selectedRange`
+    // internally as part of assigning new attributed text, and that reset
+    // fires `textViewDidChangeSelection` with `{0, 0}`. If we let that bubble
+    // up to JS as an `onNativeSelectionChange`, the JS `selectionRef` gets
+    // overwritten with `{0, 0}` — so the next toolbar toggle reads a stale
+    // collapsed caret, drops into pending-mark mode, and visually does
+    // nothing. Suppressing both event channels here keeps JS's selection
+    // state aligned with what the user actually has selected.
+    suppressEdits = true
+    suppressSelectionEvents = true
+    textView.attributedText = newString
+    suppressSelectionEvents = false
+    suppressEdits = false
+
+    // Preserve caret across the assignment (UITextView resets selectedRange
+    // when attributedText is reassigned, so we restore explicitly).
+    let utf16Length = (newString.string as NSString).length
+    if previousSelected.location <= utf16Length {
+      let clampedEnd = min(utf16Length, previousSelected.location + previousSelected.length)
+      suppressSelectionEvents = true
+      textView.selectedRange = NSRange(
+        location: previousSelected.location,
+        length: clampedEnd - previousSelected.location
+      )
+      suppressSelectionEvents = false
+    }
+    updatePlaceholderVisibility()
+  }
+
+
+  private func buildAttributedString() -> NSAttributedString {
+    let result = NSMutableAttributedString()
+    let baseColorResolved = baseColor ?? .label
+    for run in runs {
+      let attrs = attributes(for: run, baseColor: baseColorResolved)
+      result.append(NSAttributedString(string: run.text, attributes: attrs))
+    }
+    return result
+  }
+
+  private func attributes(
+    for run: YjsTextRunRecord,
+    baseColor: UIColor
+  ) -> [NSAttributedString.Key: Any] {
+    var attrs: [NSAttributedString.Key: Any] = [:]
+    // CRITICAL: start each run from a CLEAN slate — base font traits and
+    // base props only, never from `textView.font` or some accumulated state.
+    // The previous design read `var traits = baseFont.fontDescriptor.symbolicTraits`
+    // off the live UITextView font, which UIKit can mutate (Dynamic Type,
+    // Bold Text accessibility setting, etc.) and then every run inherits
+    // that mutation, producing the "the entire editor is suddenly bold"
+    // symptom. Per-run we start from the JS prop values and OR in only the
+    // marks the run actually carries.
+    let baseFontBold = baseFontWeight == "bold"
+    let baseFontItalic = baseFontStyle == "italic"
+    var bold = baseFontBold
+    var italic = baseFontItalic
+    var familyOverride: String? = nil
+    var sizeOverride: CGFloat? = nil
+    var foreground = baseColor
+    var background: UIColor? = nil
+    var underline = false
+    var strike = false
+
+    let marks = parseMarks(run.marksJson)
+    for (markName, markValue) in marks {
+      // `null` / `NSNull` values are the "explicitly off" sentinel produced
+      // by the insert path's `computeInsertAttrs` when a mark was toggled
+      // off via pending overlays. Treat them as "mark not present" rather
+      // than "mark present with no attrs". Without this, typed text after
+      // a pending-mark-off toggle re-applies the mark's style.
+      if markValue is NSNull { continue }
+      if let bool = markValue as? Bool, !bool { continue }
+      guard let style = renderSpec[markName] else { continue }
+      if style.fontWeight == "bold" { bold = true }
+      if style.fontStyle == "italic" { italic = true }
+      if let family = style.fontFamily { familyOverride = family }
+      if let size = style.fontSize { sizeOverride = CGFloat(size) }
+      if let color = style.color, let parsed = YjsTextColor.parse(color) {
+        foreground = parsed
+      }
+      if let bg = style.backgroundColor, let parsed = YjsTextColor.parse(bg) {
+        background = parsed
+      }
+      if let decoration = style.textDecorationLine {
+        if decoration.contains("underline") { underline = true }
+        if decoration.contains("line-through") { strike = true }
+      }
+    }
+
+    let size = sizeOverride ?? CGFloat(baseFontSize ?? 16)
+    let family = familyOverride ?? baseFontFamily
+    let (font, needsObliqueness) = makeFont(family: family, size: size, bold: bold, italic: italic)
+
+    attrs[.font] = font
+    attrs[.foregroundColor] = foreground
+    if needsObliqueness {
+      // True bold-italic SF Pro wasn't available via the descriptor route;
+      // ship a computational slant so the glyphs still look italic while
+      // preserving the bold weight. 0.2 corresponds to ~12° which is the
+      // visual slope of SF Pro Italic at body sizes.
+      attrs[.obliqueness] = 0.2
+    }
+    if let bg = background { attrs[.backgroundColor] = bg }
+    if underline { attrs[.underlineStyle] = NSUnderlineStyle.single.rawValue }
+    if strike { attrs[.strikethroughStyle] = NSUnderlineStyle.single.rawValue }
+    return attrs
+  }
+
+  private func parseMarks(_ json: String) -> [String: Any] {
+    guard let data = json.data(using: .utf8) else { return [:] }
+    let object = try? JSONSerialization.jsonObject(with: data, options: [])
+    return (object as? [String: Any]) ?? [:]
+  }
+
+  private func updatePlaceholderVisibility() {
+    let isEmpty = textView.attributedText.length == 0
+    placeholderLabel.text = placeholder
+    placeholderLabel.isHidden = !isEmpty || (placeholder?.isEmpty ?? true)
+  }
+}
+
+// MARK: - UITextViewDelegate
+
+extension YjsTextView: UITextViewDelegate {
+  public func textView(
+    _ textView: UITextView,
+    shouldChangeTextIn range: NSRange,
+    replacementText text: String
+  ) -> Bool {
+    if suppressEdits { return true }
+    // Forward as a `replace` edit. Note: NSRange uses UTF-16 code units,
+    // which is the same encoding Y.Text offsets use, so no conversion needed.
+    onContentChange([
+      "type": "replace",
+      "from": range.location,
+      "to": range.location + range.length,
+      "text": text,
+    ])
+    // Returning `true` lets UITextView apply the change immediately so the
+    // user sees their typing without a JS round-trip. JS catches up with the
+    // Y.Text mutation; the resulting observe event is skipped (ORIGIN_LOCAL_VIEW)
+    // so we don't double-apply.
+    return true
+  }
+
+  public func textViewDidChange(_ textView: UITextView) {
+    updatePlaceholderVisibility()
+  }
+
+  public func textViewDidChangeSelection(_ textView: UITextView) {
+    if suppressSelectionEvents { return }
+    let range = textView.selectedRange
+    onNativeSelectionChange([
+      "from": range.location,
+      "to": range.location + range.length,
+    ])
+  }
+
+  public func textViewDidBeginEditing(_ textView: UITextView) {
+    onFocusChange(["focused": true])
+  }
+
+  public func textViewDidEndEditing(_ textView: UITextView) {
+    onFocusChange(["focused": false])
+  }
+}

package/package.json

@@ -0,0 +1,124 @@
+{
+  "name": "@eclosion-tech/react-native-yjs-text",
+  "version": "0.1.0",
+  "description": "Native React Native rich text editor backed by Y.Text — no WebView, no contenteditable",
+  "main": "build/index.js",
+  "types": "build/index.d.ts",
+  "scripts": {
+    "build": "node internal/module_scripts/build.js",
+    "clean": "node internal/module_scripts/clean.js",
+    "lint": "eslint src/",
+    "test": "node internal/module_scripts/test.js",
+    "prepare": "node internal/module_scripts/prepare.js",
+    "open:ios": "node internal/module_scripts/open-ios.js",
+    "open:android": "node internal/module_scripts/open-android.js",
+    "example:ios": "pnpm --filter react-native-yjs-text-example exec expo run:ios",
+    "example:android": "pnpm --filter react-native-yjs-text-example exec expo run:android",
+    "example:start": "pnpm --filter react-native-yjs-text-example exec expo start",
+    "example-bare:ios": "pnpm --filter react-native-yjs-text-example-bare exec react-native run-ios",
+    "example-bare:android": "pnpm --filter react-native-yjs-text-example-bare exec react-native run-android",
+    "example-bare:start": "pnpm --filter react-native-yjs-text-example-bare exec react-native start"
+  },
+  "keywords": [
+    "react-native",
+    "expo",
+    "react-native-yjs-text",
+    "yjs",
+    "y-text",
+    "rich-text",
+    "rich-text-editor",
+    "crdt",
+    "collaborative",
+    "text-editor",
+    "native"
+  ],
+  "repository": "https://github.com/eclosion-tech/react-native-yjs-text",
+  "bugs": {
+    "url": "https://github.com/eclosion-tech/react-native-yjs-text/issues"
+  },
+  "author": "Eclosion Technologies <hello@eclosion.tech> (https://eclosion.tech)",
+  "license": "MIT",
+  "homepage": "https://github.com/eclosion-tech/react-native-yjs-text#readme",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "build",
+    "src",
+    "!src/__tests__",
+    "ios",
+    "!ios/Pods",
+    "!ios/build",
+    "!ios/**/*.xcworkspace",
+    "!ios/**/*.xcodeproj",
+    "android/src",
+    "android/build.gradle",
+    "expo-module.config.json",
+    "SPEC.md",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "devDependencies": {
+    "@babel/core": "^7.26.0",
+    "@babel/preset-env": "^7.26.0",
+    "@babel/preset-typescript": "^7.26.0",
+    "@testing-library/react": "^16.3.2",
+    "@types/jest": "^29.2.1",
+    "@types/react": "~19.1.1",
+    "babel-jest": "^29.7.0",
+    "babel-preset-expo": "~55.0.8",
+    "eslint": "~9.39.4",
+    "eslint-config-universe": "^15.0.3",
+    "expo": "^56.0.3",
+    "jest": "^29.7.0",
+    "jest-environment-jsdom": "^30.4.1",
+    "prettier": "^3.0.0",
+    "react": "19.2.3",
+    "react-dom": "^19.2.3",
+    "react-native": "0.82.1",
+    "react-test-renderer": "^19.2.6",
+    "typescript": "^5.9.2",
+    "yjs": "^13.6.27"
+  },
+  "jest": {
+    "testEnvironment": "jsdom",
+    "roots": [
+      "<rootDir>/src"
+    ],
+    "transform": {
+      "^.+\\.(ts|tsx|js|jsx)$": [
+        "babel-jest",
+        {
+          "presets": [
+            [
+              "@babel/preset-env",
+              {
+                "targets": {
+                  "node": "current"
+                }
+              }
+            ],
+            [
+              "@babel/preset-react",
+              {
+                "runtime": "automatic"
+              }
+            ],
+            "@babel/preset-typescript"
+          ]
+        }
+      ]
+    },
+    "testMatch": [
+      "<rootDir>/src/**/*.test.ts",
+      "<rootDir>/src/**/*.test.tsx"
+    ]
+  },
+  "peerDependencies": {
+    "expo": "*",
+    "react": "*",
+    "react-native": "*",
+    "yjs": "^13.6.0"
+  }
+}