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

package/android/src/main/java/tech/eclosion/yjstext/YjsTextView.kt

@@ -0,0 +1,424 @@
+package tech.eclosion.yjstext
+
+import android.content.Context
+import android.graphics.Typeface
+import android.text.Editable
+import android.text.Spannable
+import android.text.SpannableStringBuilder
+import android.text.TextWatcher
+import android.text.style.AbsoluteSizeSpan
+import android.text.style.BackgroundColorSpan
+import android.text.style.ForegroundColorSpan
+import android.text.style.StrikethroughSpan
+import android.text.style.StyleSpan
+import android.text.style.TypefaceSpan
+import android.text.style.UnderlineSpan
+import android.util.TypedValue
+import android.view.Gravity
+import android.view.ViewGroup
+import android.view.inputmethod.InputMethodManager
+import android.widget.TextView
+import androidx.appcompat.widget.AppCompatEditText
+import expo.modules.kotlin.AppContext
+import expo.modules.kotlin.viewevent.EventDispatcher
+import expo.modules.kotlin.views.ExpoView
+import org.json.JSONObject
+
+/**
+ * Native editor view backing `<YTextInput>` on Android.
+ *
+ * Like the iOS counterpart, the Expo `View()` declaration needs the outer
+ * class to subclass `ExpoView` (a `LinearLayout` on Android), so we host an
+ * internal `AppCompatEditText` as the actual editable surface. All TextWatcher
+ * / focus / selection plumbing lives here.
+ *
+ * Edit capture uses a standard `TextWatcher`. `before/onTextChanged` deliver
+ * the changed range as `(start, before, count)` — we synthesise a `replace`
+ * edit `{from=start, to=start+before, text=s[start..start+count]}` and forward
+ * to JS. Less precise than iOS's `shouldChangeTextIn` (we can't intercept and
+ * reject), but sufficient for v0.1; full IME correctness via a custom
+ * `InputConnection` lands in v0.2 per the spec.
+ *
+ * Loop-breaking: when JS pushes runs down in response to a remote edit, we
+ * set `suppressEdits = true` for the duration of the programmatic
+ * `editText.text = ...` write so the TextWatcher doesn't bounce the change
+ * back up to JS.
+ */
+class YjsTextView(context: Context, appContext: AppContext) : ExpoView(context, appContext) {
+  // MARK: Props (matched to iOS / JS bridge contract by name)
+
+  /**
+   * Runs from JS. We always rebuild on change — `runs` 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` compared
+   * plain text only). That two-prop design was order-sensitive: Expo
+   * Modules / Fabric doesn't guarantee setter order, and `contentVersion`
+   * was sometimes applied before `runs` — so the version setter rebuilt
+   * from stale runs and the runs setter then short-circuited. Net result:
+   * every attribute toggle lagged by one update. Collapsing to a single
+   * trigger makes the race structurally impossible.
+   */
+  var runs: List<YjsTextRunRecord> = emptyList()
+    set(value) {
+      field = value
+      applyRuns()
+    }
+
+  var renderSpec: Map<String, YjsTextMarkStyleRecord> = emptyMap()
+    set(value) {
+      field = value
+      applyRuns()
+    }
+
+  /**
+   * Latest JS-pushed selection bundle. We re-apply only when the embedded
+   * `version` changes (so a no-op re-render where React sends the same
+   * object reference again doesn't fight the user's in-flight selection).
+   * See `YjsTextSelectionRecord` for why this is one bundled prop instead
+   * of two separate ones.
+   */
+  var pendingSelection: YjsTextSelectionRecord? = null
+    set(value) {
+      field = value
+      val next = value ?: return
+      if (next.version != lastAppliedSelectionVersion) {
+        lastAppliedSelectionVersion = next.version
+        setSelection(next.from, next.to)
+      }
+    }
+  private var lastAppliedSelectionVersion: Int = -1
+
+  var editable: Boolean = true
+    set(value) {
+      field = value
+      editText.isFocusable = value
+      editText.isFocusableInTouchMode = value
+      editText.isCursorVisible = value
+      editText.isEnabled = value
+    }
+
+  var placeholder: String? = null
+    set(value) {
+      field = value
+      editText.hint = value
+    }
+
+  var placeholderColor: Int? = null
+    set(value) {
+      field = value
+      if (value != null) editText.setHintTextColor(value)
+    }
+
+  var baseFontSize: Double? = null
+    set(value) {
+      field = value
+      applyBaseFont()
+      applyRuns()
+    }
+
+  var baseFontFamily: String? = null
+    set(value) {
+      field = value
+      applyBaseFont()
+      applyRuns()
+    }
+
+  var baseColor: Int? = null
+    set(value) {
+      field = value
+      if (value != null) editText.setTextColor(value)
+      applyRuns()
+    }
+
+  var baseFontWeight: String? = null
+    set(value) {
+      field = value
+      applyBaseFont()
+      applyRuns()
+    }
+
+  var baseFontStyle: String? = null
+    set(value) {
+      field = value
+      applyBaseFont()
+      applyRuns()
+    }
+
+  // MARK: Events
+
+  private val onContentChange by EventDispatcher<YjsTextContentChangePayload>()
+  private val onNativeSelectionChange by EventDispatcher<YjsTextSelectionEventPayload>()
+  private val onFocusChange by EventDispatcher<YjsTextFocusEventPayload>()
+
+  @Suppress("unused")
+  private val onMarkTap by EventDispatcher<YjsTextMarkTapPayload>()
+
+  // MARK: Internal state
+
+  internal val editText: HostEditText = HostEditText(context)
+  private var suppressEdits: Boolean = false
+  private var suppressSelectionEvents: Boolean = false
+
+  init {
+    orientation = VERTICAL
+    gravity = Gravity.TOP
+
+    editText.layoutParams = ViewGroup.LayoutParams(
+      ViewGroup.LayoutParams.MATCH_PARENT,
+      ViewGroup.LayoutParams.MATCH_PARENT
+    )
+    editText.background = null
+    editText.setPadding(0, 0, 0, 0)
+    editText.gravity = Gravity.TOP or Gravity.START
+    editText.includeFontPadding = false
+    editText.setHorizontallyScrolling(false)
+    editText.isVerticalScrollBarEnabled = false
+    editText.maxLines = Int.MAX_VALUE
+
+    editText.addTextChangedListener(EditWatcher())
+    editText.setOnFocusChangeListener { _, hasFocus ->
+      val payload = YjsTextFocusEventPayload().apply { focused = hasFocus }
+      onFocusChange(payload)
+    }
+    editText.selectionListener = { start, end ->
+      if (!suppressSelectionEvents) {
+        val payload = YjsTextSelectionEventPayload().apply {
+          from = start
+          to = end
+        }
+        onNativeSelectionChange(payload)
+      }
+    }
+
+    addView(editText)
+    applyBaseFont()
+  }
+
+  // MARK: Imperative
+
+  fun focusInput() {
+    editText.requestFocus()
+    val imm = context.getSystemService(Context.INPUT_METHOD_SERVICE) as? InputMethodManager
+    imm?.showSoftInput(editText, InputMethodManager.SHOW_IMPLICIT)
+  }
+
+  fun blurInput() {
+    val imm = context.getSystemService(Context.INPUT_METHOD_SERVICE) as? InputMethodManager
+    imm?.hideSoftInputFromWindow(editText.windowToken, 0)
+    editText.clearFocus()
+  }
+
+  fun isInputFocused(): Boolean = editText.isFocused
+
+  fun setSelection(from: Int, to: Int) {
+    val length = editText.text?.length ?: 0
+    val clampedFrom = from.coerceIn(0, length)
+    val clampedTo = to.coerceIn(clampedFrom, length)
+    suppressSelectionEvents = true
+    editText.setSelection(clampedFrom, clampedTo)
+    suppressSelectionEvents = false
+  }
+
+  // MARK: Render
+
+  private fun applyBaseFont() {
+    val size = (baseFontSize ?: 16.0).toFloat()
+    editText.textSize = size
+
+    val bold = baseFontWeight == "bold"
+    val italic = baseFontStyle == "italic"
+    val style = when {
+      bold && italic -> Typeface.BOLD_ITALIC
+      bold -> Typeface.BOLD
+      italic -> Typeface.ITALIC
+      else -> Typeface.NORMAL
+    }
+    val base = if (baseFontFamily != null) Typeface.create(baseFontFamily, style) else Typeface.defaultFromStyle(style)
+    editText.setTypeface(base, style)
+
+    baseColor?.let { editText.setTextColor(it) }
+  }
+
+  /**
+   * Rebuild and apply the spannable. Called whenever `runs`, `renderSpec`,
+   * or any base-style prop changes. No more `force` parameter / short-
+   * circuit: see the `runs` comment above for why.
+   */
+  private fun applyRuns() {
+    val newString = buildSpannableString()
+    val previousStart = editText.selectionStart.coerceAtLeast(0)
+    val previousEnd = editText.selectionEnd.coerceAtLeast(0)
+
+    // CRITICAL: suppress *both* TextWatcher and selection echoes around the
+    // `setText` call. `EditText.setText` resets the cursor to position 0 as
+    // part of replacing the underlying CharSequence, which triggers
+    // `onSelectionChanged(0, 0)`. If we let that fire `onNativeSelectionChange`
+    // to JS, the JS `selectionRef` is overwritten with `{0, 0}` and the next
+    // toolbar toggle reads a stale collapsed caret — drops into pending-mark
+    // mode and visually does nothing. See the matching iOS comment in
+    // `applyRunsIfNeeded` for the full story.
+    suppressEdits = true
+    suppressSelectionEvents = true
+    editText.setText(newString, TextView.BufferType.SPANNABLE)
+    suppressSelectionEvents = false
+    suppressEdits = false
+
+    val length = newString.length
+    val clampedStart = previousStart.coerceIn(0, length)
+    val clampedEnd = previousEnd.coerceIn(clampedStart, length)
+    suppressSelectionEvents = true
+    editText.setSelection(clampedStart, clampedEnd)
+    suppressSelectionEvents = false
+  }
+
+
+  private fun buildSpannableString(): SpannableStringBuilder {
+    val builder = SpannableStringBuilder()
+    var cursor = 0
+    for (run in runs) {
+      builder.append(run.text)
+      val runStart = cursor
+      val runEnd = cursor + run.text.length
+      cursor = runEnd
+      applyRunSpans(builder, run, runStart, runEnd)
+    }
+    return builder
+  }
+
+  private fun applyRunSpans(
+    builder: SpannableStringBuilder,
+    run: YjsTextRunRecord,
+    start: Int,
+    end: Int
+  ) {
+    if (start == end) return
+    val marks = parseMarks(run.marksJson)
+    var bold = false
+    var italic = false
+    var familyOverride: String? = null
+    var sizeOverride: Float? = null
+    var foreground: Int? = null
+    var background: Int? = null
+    var underline = false
+    var strike = false
+
+    for ((markName, markValue) in marks) {
+      // `null` / `false` mark values are the "explicitly off" sentinel
+      // produced by the insert path's `computeInsertAttrs` when a mark
+      // was toggled off via the pending overlay. Treat them as "mark
+      // absent" — without this, typed text after a pending-mark-off
+      // toggle would still get the mark's spans applied.
+      if (markValue == null || markValue == JSONObject.NULL) continue
+      if (markValue is Boolean && !markValue) continue
+      val style = renderSpec[markName] ?: continue
+      if (style.fontWeight == "bold") bold = true
+      if (style.fontStyle == "italic") italic = true
+      style.fontFamily?.let { familyOverride = it }
+      style.fontSize?.let { sizeOverride = it.toFloat() }
+      style.color?.let { YjsTextColor.parse(it)?.let { c -> foreground = c } }
+      style.backgroundColor?.let { YjsTextColor.parse(it)?.let { c -> background = c } }
+      style.textDecorationLine?.let { decoration ->
+        if (decoration.contains("underline")) underline = true
+        if (decoration.contains("line-through")) strike = true
+      }
+    }
+
+    val typefaceStyle = when {
+      bold && italic -> Typeface.BOLD_ITALIC
+      bold -> Typeface.BOLD
+      italic -> Typeface.ITALIC
+      else -> Typeface.NORMAL
+    }
+    if (typefaceStyle != Typeface.NORMAL) {
+      builder.setSpan(StyleSpan(typefaceStyle), start, end, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE)
+    }
+    familyOverride?.let {
+      builder.setSpan(TypefaceSpan(it), start, end, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE)
+    }
+    sizeOverride?.let {
+      // Treat the JS-side `fontSize` as SP (matches RN's TextStyle convention).
+      // `TypedValue.applyDimension(COMPLEX_UNIT_SP, ...)` respects user font
+      // scaling and supersedes the deprecated `DisplayMetrics.scaledDensity`.
+      val px = TypedValue.applyDimension(
+        TypedValue.COMPLEX_UNIT_SP,
+        it,
+        resources.displayMetrics
+      ).toInt()
+      builder.setSpan(AbsoluteSizeSpan(px), start, end, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE)
+    }
+    foreground?.let {
+      builder.setSpan(ForegroundColorSpan(it), start, end, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE)
+    }
+    background?.let {
+      builder.setSpan(BackgroundColorSpan(it), start, end, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE)
+    }
+    if (underline) {
+      builder.setSpan(UnderlineSpan(), start, end, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE)
+    }
+    if (strike) {
+      builder.setSpan(StrikethroughSpan(), start, end, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE)
+    }
+  }
+
+  private fun parseMarks(json: String): Map<String, Any?> {
+    if (json.isEmpty()) return emptyMap()
+    return try {
+      val obj = JSONObject(json)
+      val result = mutableMapOf<String, Any?>()
+      val keys = obj.keys()
+      while (keys.hasNext()) {
+        val key = keys.next()
+        result[key] = obj.opt(key)
+      }
+      result
+    } catch (_: Throwable) {
+      emptyMap()
+    }
+  }
+
+  // MARK: TextWatcher
+
+  private inner class EditWatcher : TextWatcher {
+    /// The `(start, before)` range captured before the change is applied,
+    /// stashed so onTextChanged can construct the `replace` payload using both
+    /// the old and new state. Both fields filled in in beforeTextChanged.
+    private var pendingFrom: Int = 0
+    private var pendingTo: Int = 0
+
+    override fun beforeTextChanged(s: CharSequence?, start: Int, count: Int, after: Int) {
+      if (suppressEdits) return
+      pendingFrom = start
+      pendingTo = start + count
+    }
+
+    override fun onTextChanged(s: CharSequence?, start: Int, before: Int, count: Int) {
+      if (suppressEdits || s == null) return
+      val insertedText = if (count > 0) s.subSequence(start, start + count).toString() else ""
+      val payload = YjsTextContentChangePayload().apply {
+        type = "replace"
+        from = pendingFrom
+        to = pendingTo
+        text = insertedText
+      }
+      onContentChange(payload)
+    }
+
+    override fun afterTextChanged(s: Editable?) { /* no-op */ }
+  }
+
+  /**
+   * Internal `AppCompatEditText` subclass that exposes selection changes via
+   * a typed Kotlin lambda. `onSelectionChanged` is `protected` on the parent
+   * so we can't observe it externally without subclassing.
+   */
+  internal class HostEditText(context: Context) : AppCompatEditText(context) {
+    /** Invoked on every selection change, including programmatic ones. */
+    var selectionListener: ((start: Int, end: Int) -> Unit)? = null
+
+    override fun onSelectionChanged(selStart: Int, selEnd: Int) {
+      super.onSelectionChanged(selStart, selEnd)
+      selectionListener?.invoke(selStart, selEnd)
+    }
+  }
+}

package/build/YTextInput.d.ts

@@ -0,0 +1,23 @@
+import * as React from 'react';
+import type { YTextInputProps } from './types';
+/**
+ * Editable inline rich-text view backed by a Y.Text shared type.
+ *
+ * Mounts a native `UITextView` (iOS) or `AppCompatEditText` (Android), keeps it
+ * in sync with the Y.Text both ways:
+ *
+ *  - User edits captured on the native side flow up as `replace` deltas,
+ *    applied to the Y.Text inside a transaction tagged `ORIGIN_LOCAL_VIEW`.
+ *    The component's own Y.Text observer skips re-rendering for these — the
+ *    view already has the change locally.
+ *
+ *  - Remote edits (any transaction with a different origin) cause the
+ *    component to recompute runs and push them down as a new prop. The caret
+ *    is preserved across these by capturing it as a Y.RelativePosition before
+ *    every render and re-resolving it after.
+ *
+ * This component does not own the Y.Doc / Y.Text. The consumer creates and
+ * disposes of them.
+ */
+export declare function YTextInput(props: YTextInputProps): React.ReactElement;
+//# sourceMappingURL=YTextInput.d.ts.map

package/build/YTextInput.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"YTextInput.d.ts","sourceRoot":"","sources":["../src/YTextInput.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAoB/B,OAAO,KAAK,EAA6B,eAAe,EAAE,MAAM,SAAS,CAAC;AAG1E;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,eAAe,GAAG,KAAK,CAAC,YAAY,CA4NrE"}

package/build/YTextInput.js

@@ -0,0 +1,178 @@
+import * as React from 'react';
+import { StyleSheet } from 'react-native';
+import { applyReplaceEdit, captureRelativeSelection, resolveRelativeSelection, ytextToRuns, } from './bridge';
+import { NativeYTextInputView, parseMarkTapAttrs, serializeRun, } from './internal/NativeYTextInputView';
+import { registerEditor, unregisterEditor } from './internal/editorRegistry';
+import { compileRenderSpec } from './schema';
+import { ORIGIN_LOCAL_VIEW } from './types';
+/**
+ * Editable inline rich-text view backed by a Y.Text shared type.
+ *
+ * Mounts a native `UITextView` (iOS) or `AppCompatEditText` (Android), keeps it
+ * in sync with the Y.Text both ways:
+ *
+ *  - User edits captured on the native side flow up as `replace` deltas,
+ *    applied to the Y.Text inside a transaction tagged `ORIGIN_LOCAL_VIEW`.
+ *    The component's own Y.Text observer skips re-rendering for these — the
+ *    view already has the change locally.
+ *
+ *  - Remote edits (any transaction with a different origin) cause the
+ *    component to recompute runs and push them down as a new prop. The caret
+ *    is preserved across these by capturing it as a Y.RelativePosition before
+ *    every render and re-resolving it after.
+ *
+ * This component does not own the Y.Doc / Y.Text. The consumer creates and
+ * disposes of them.
+ */
+export function YTextInput(props) {
+    const { yText, schema, style, placeholder, placeholderTextColor, autoFocus, editable = true, onSelectionChange, onFocus, onBlur, onSchemaViolation, } = props;
+    const nativeRef = React.useRef(null);
+    const focusedRef = React.useRef(false);
+    const selectionRef = React.useRef(null);
+    const relativeSelectionRef = React.useRef(null);
+    const pendingMarksRef = React.useRef({});
+    // We keep runs in state, but the *trigger* to re-derive them is Y.Text
+    // observe events, not React state changes. So we have a counter that bumps
+    // whenever a non-local Y.Text change happens; runs/selection are derived
+    // synchronously from yText.toDelta() at render time.
+    const [contentVersion, setContentVersion] = React.useState(0);
+    // The selection we *want* the native view to be at after the next re-render,
+    // bundled together with a monotonic `version` field that the native side
+    // uses to decide whether to re-apply. `from`/`to`/`version` MUST be sent
+    // as one atomic prop — see SerializedPendingSelection for why.
+    const [pendingSelection, setPendingSelection] = React.useState(null);
+    // Snapshot runs at render time from the current Y.Text. This is cheap
+    // (Y.Text.toDelta walks the type once) and means we don't have to manage
+    // a stale runs cache. We serialise marks to JSON because the bridge can't
+    // type-cleanly carry heterogeneous mark-attr dictionaries.
+    const serializedRuns = React.useMemo(() => ytextToRuns(yText).map(serializeRun), [yText, contentVersion]);
+    const renderSpec = React.useMemo(() => compileRenderSpec(schema), [schema]);
+    // Decompose the consumer-supplied style into a flat TextStyle so we can
+    // forward the baseline font/colour into the native view as discrete props.
+    // (The native view also receives the original style for layout.)
+    const flatStyle = React.useMemo(() => StyleSheet.flatten(style), [style]);
+    // Subscribe to Y.Text observe events. For non-local origins we have to
+    // re-render and reposition the caret; for local-view origins we no-op (the
+    // native view already has the change).
+    React.useEffect(() => {
+        function onYTextChange(_event, transaction) {
+            if (transaction.origin === ORIGIN_LOCAL_VIEW) {
+                // Local edit round-trip: the view's text already matches the Y.Text.
+                // We may still need to bump contentVersion to keep React's view of
+                // "what runs are" consistent, but we must NOT push the runs back down
+                // or we lose the caret. So skip entirely.
+                return;
+            }
+            // Remote / programmatic edit. Recover the caret via RelativePosition.
+            const rel = relativeSelectionRef.current;
+            if (rel) {
+                const resolved = resolveRelativeSelection(yText, rel);
+                if (resolved) {
+                    setPendingSelection((prev) => ({
+                        from: resolved.from,
+                        to: resolved.to,
+                        version: (prev?.version ?? 0) + 1,
+                    }));
+                }
+                else {
+                    // Lost positions — clamp caret to end.
+                    const len = yText.length;
+                    setPendingSelection((prev) => ({
+                        from: len,
+                        to: len,
+                        version: (prev?.version ?? 0) + 1,
+                    }));
+                }
+            }
+            setContentVersion((v) => v + 1);
+        }
+        yText.observe(onYTextChange);
+        return () => {
+            yText.unobserve(onYTextChange);
+        };
+    }, [yText]);
+    // Register this editor instance against the Y.Text so the imperative editor
+    // hook (or any consumer code) can find the live view.
+    React.useEffect(() => {
+        const handle = {
+            getSelection: () => (focusedRef.current ? selectionRef.current : null),
+            getPendingMarks: () => pendingMarksRef.current,
+            setPendingMarks: (marks) => {
+                pendingMarksRef.current = marks;
+            },
+            focus: () => {
+                nativeRef.current?.focus();
+            },
+            blur: () => {
+                nativeRef.current?.blur();
+            },
+            isFocused: () => focusedRef.current,
+            setSelection: (range) => {
+                setPendingSelection((prev) => ({
+                    from: range.from,
+                    to: range.to,
+                    version: (prev?.version ?? 0) + 1,
+                }));
+            },
+        };
+        registerEditor(yText, handle);
+        return () => {
+            unregisterEditor(yText, handle);
+        };
+    }, [yText]);
+    // Capture a fresh relative selection whenever the absolute selection or the
+    // Y.Text content changes — so that subsequent remote edits can resolve back
+    // to "the same logical place".
+    React.useEffect(() => {
+        if (selectionRef.current) {
+            relativeSelectionRef.current = captureRelativeSelection(yText, selectionRef.current);
+        }
+    }, [yText, contentVersion]);
+    // autoFocus: defer to a mount-time effect so the native view has registered
+    // its tag with the bridge before we ask it to focus.
+    React.useEffect(() => {
+        if (autoFocus) {
+            const id = setTimeout(() => nativeRef.current?.focus(), 0);
+            return () => clearTimeout(id);
+        }
+        return undefined;
+    }, [autoFocus]);
+    // Edit captured from native. Apply to Y.Text inside a local transaction.
+    const handleContentChange = React.useCallback((event) => {
+        const { from, to, text } = event.nativeEvent;
+        applyReplaceEdit(yText, { type: 'replace', from, to, text }, schema, onSchemaViolation, pendingMarksRef.current);
+        // Any insert consumes pending marks.
+        if (text.length > 0) {
+            pendingMarksRef.current = {};
+        }
+    }, [yText, schema, onSchemaViolation]);
+    const handleSelectionChange = React.useCallback((event) => {
+        const sel = {
+            from: event.nativeEvent.from,
+            to: event.nativeEvent.to,
+        };
+        selectionRef.current = sel;
+        relativeSelectionRef.current = captureRelativeSelection(yText, sel);
+        // A selection change with a non-zero length, or that moves the caret
+        // away from a position with pending marks, clears pending marks. The
+        // simplest rule that matches user expectation: clear on any explicit
+        // selection change. Typing-driven selection moves already cleared
+        // pending marks in handleContentChange.
+        pendingMarksRef.current = {};
+        onSelectionChange?.(sel);
+    }, [yText, onSelectionChange]);
+    const handleFocusChange = React.useCallback((event) => {
+        const focused = event.nativeEvent.focused;
+        focusedRef.current = focused;
+        if (focused)
+            onFocus?.();
+        else
+            onBlur?.();
+    }, [onFocus, onBlur]);
+    const handleMarkTap = React.useCallback((event) => {
+        const { mark, attrsJson } = event.nativeEvent;
+        schema.marks[mark]?.onTap?.(parseMarkTapAttrs(attrsJson));
+    }, [schema]);
+    return (<NativeYTextInputView ref={nativeRef} runs={serializedRuns} renderSpec={renderSpec} pendingSelection={pendingSelection} editable={editable} placeholder={placeholder} placeholderColor={placeholderTextColor} baseFontSize={typeof flatStyle?.fontSize === 'number' ? flatStyle.fontSize : undefined} baseFontFamily={typeof flatStyle?.fontFamily === 'string' ? flatStyle.fontFamily : undefined} baseColor={typeof flatStyle?.color === 'string' ? flatStyle.color : undefined} baseFontWeight={typeof flatStyle?.fontWeight === 'string' ? flatStyle.fontWeight : undefined} baseFontStyle={typeof flatStyle?.fontStyle === 'string' ? flatStyle.fontStyle : undefined} style={style} onContentChange={handleContentChange} onNativeSelectionChange={handleSelectionChange} onFocusChange={handleFocusChange} onMarkTap={handleMarkTap}/>);
+}
+//# sourceMappingURL=YTextInput.js.map

package/build/YTextInput.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"YTextInput.js","sourceRoot":"","sources":["../src/YTextInput.tsx"],"names":[],"mappings":"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","sourcesContent":["import * as React from 'react';\nimport { StyleSheet, type TextStyle } from 'react-native';\nimport * as Y from 'yjs';\n\nimport {\n  applyReplaceEdit,\n  captureRelativeSelection,\n  resolveRelativeSelection,\n  ytextToRuns,\n  type RelativeSelection,\n} from './bridge';\nimport {\n  NativeYTextInputView,\n  parseMarkTapAttrs,\n  serializeRun,\n  type NativeYTextInputViewRef,\n  type SerializedRun,\n} from './internal/NativeYTextInputView';\nimport { registerEditor, unregisterEditor, type EditorHandle } from './internal/editorRegistry';\nimport { compileRenderSpec } from './schema';\nimport type { MarkAttrs, SelectionRange, YTextInputProps } from './types';\nimport { ORIGIN_LOCAL_VIEW } from './types';\n\n/**\n * Editable inline rich-text view backed by a Y.Text shared type.\n *\n * Mounts a native `UITextView` (iOS) or `AppCompatEditText` (Android), keeps it\n * in sync with the Y.Text both ways:\n *\n *  - User edits captured on the native side flow up as `replace` deltas,\n *    applied to the Y.Text inside a transaction tagged `ORIGIN_LOCAL_VIEW`.\n *    The component's own Y.Text observer skips re-rendering for these — the\n *    view already has the change locally.\n *\n *  - Remote edits (any transaction with a different origin) cause the\n *    component to recompute runs and push them down as a new prop. The caret\n *    is preserved across these by capturing it as a Y.RelativePosition before\n *    every render and re-resolving it after.\n *\n * This component does not own the Y.Doc / Y.Text. The consumer creates and\n * disposes of them.\n */\nexport function YTextInput(props: YTextInputProps): React.ReactElement {\n  const {\n    yText,\n    schema,\n    style,\n    placeholder,\n    placeholderTextColor,\n    autoFocus,\n    editable = true,\n    onSelectionChange,\n    onFocus,\n    onBlur,\n    onSchemaViolation,\n  } = props;\n\n  const nativeRef = React.useRef<NativeYTextInputViewRef | null>(null);\n  const focusedRef = React.useRef<boolean>(false);\n  const selectionRef = React.useRef<SelectionRange | null>(null);\n  const relativeSelectionRef = React.useRef<RelativeSelection | null>(null);\n  const pendingMarksRef = React.useRef<MarkAttrs>({});\n\n  // We keep runs in state, but the *trigger* to re-derive them is Y.Text\n  // observe events, not React state changes. So we have a counter that bumps\n  // whenever a non-local Y.Text change happens; runs/selection are derived\n  // synchronously from yText.toDelta() at render time.\n  const [contentVersion, setContentVersion] = React.useState(0);\n  // The selection we *want* the native view to be at after the next re-render,\n  // bundled together with a monotonic `version` field that the native side\n  // uses to decide whether to re-apply. `from`/`to`/`version` MUST be sent\n  // as one atomic prop — see SerializedPendingSelection for why.\n  const [pendingSelection, setPendingSelection] = React.useState<{\n    from: number;\n    to: number;\n    version: number;\n  } | null>(null);\n\n  // Snapshot runs at render time from the current Y.Text. This is cheap\n  // (Y.Text.toDelta walks the type once) and means we don't have to manage\n  // a stale runs cache. We serialise marks to JSON because the bridge can't\n  // type-cleanly carry heterogeneous mark-attr dictionaries.\n  const serializedRuns: SerializedRun[] = React.useMemo(\n    () => ytextToRuns(yText).map(serializeRun),\n    [yText, contentVersion]\n  );\n  const renderSpec = React.useMemo(() => compileRenderSpec(schema), [schema]);\n\n  // Decompose the consumer-supplied style into a flat TextStyle so we can\n  // forward the baseline font/colour into the native view as discrete props.\n  // (The native view also receives the original style for layout.)\n  const flatStyle = React.useMemo(\n    () => StyleSheet.flatten(style) as TextStyle | undefined,\n    [style]\n  );\n\n  // Subscribe to Y.Text observe events. For non-local origins we have to\n  // re-render and reposition the caret; for local-view origins we no-op (the\n  // native view already has the change).\n  React.useEffect(() => {\n    function onYTextChange(_event: Y.YTextEvent, transaction: Y.Transaction): void {\n      if (transaction.origin === ORIGIN_LOCAL_VIEW) {\n        // Local edit round-trip: the view's text already matches the Y.Text.\n        // We may still need to bump contentVersion to keep React's view of\n        // \"what runs are\" consistent, but we must NOT push the runs back down\n        // or we lose the caret. So skip entirely.\n        return;\n      }\n      // Remote / programmatic edit. Recover the caret via RelativePosition.\n      const rel = relativeSelectionRef.current;\n      if (rel) {\n        const resolved = resolveRelativeSelection(yText, rel);\n        if (resolved) {\n          setPendingSelection((prev) => ({\n            from: resolved.from,\n            to: resolved.to,\n            version: (prev?.version ?? 0) + 1,\n          }));\n        } else {\n          // Lost positions — clamp caret to end.\n          const len = yText.length;\n          setPendingSelection((prev) => ({\n            from: len,\n            to: len,\n            version: (prev?.version ?? 0) + 1,\n          }));\n        }\n      }\n      setContentVersion((v) => v + 1);\n    }\n    yText.observe(onYTextChange);\n    return () => {\n      yText.unobserve(onYTextChange);\n    };\n  }, [yText]);\n\n  // Register this editor instance against the Y.Text so the imperative editor\n  // hook (or any consumer code) can find the live view.\n  React.useEffect(() => {\n    const handle: EditorHandle = {\n      getSelection: () => (focusedRef.current ? selectionRef.current : null),\n      getPendingMarks: () => pendingMarksRef.current,\n      setPendingMarks: (marks) => {\n        pendingMarksRef.current = marks;\n      },\n      focus: () => {\n        nativeRef.current?.focus();\n      },\n      blur: () => {\n        nativeRef.current?.blur();\n      },\n      isFocused: () => focusedRef.current,\n      setSelection: (range) => {\n        setPendingSelection((prev) => ({\n          from: range.from,\n          to: range.to,\n          version: (prev?.version ?? 0) + 1,\n        }));\n      },\n    };\n    registerEditor(yText, handle);\n    return () => {\n      unregisterEditor(yText, handle);\n    };\n  }, [yText]);\n\n  // Capture a fresh relative selection whenever the absolute selection or the\n  // Y.Text content changes — so that subsequent remote edits can resolve back\n  // to \"the same logical place\".\n  React.useEffect(() => {\n    if (selectionRef.current) {\n      relativeSelectionRef.current = captureRelativeSelection(yText, selectionRef.current);\n    }\n  }, [yText, contentVersion]);\n\n  // autoFocus: defer to a mount-time effect so the native view has registered\n  // its tag with the bridge before we ask it to focus.\n  React.useEffect(() => {\n    if (autoFocus) {\n      const id = setTimeout(() => nativeRef.current?.focus(), 0);\n      return () => clearTimeout(id);\n    }\n    return undefined;\n  }, [autoFocus]);\n\n  // Edit captured from native. Apply to Y.Text inside a local transaction.\n  const handleContentChange = React.useCallback(\n    (event: { nativeEvent: { type: 'replace'; from: number; to: number; text: string } }) => {\n      const { from, to, text } = event.nativeEvent;\n      applyReplaceEdit(\n        yText,\n        { type: 'replace', from, to, text },\n        schema,\n        onSchemaViolation,\n        pendingMarksRef.current\n      );\n      // Any insert consumes pending marks.\n      if (text.length > 0) {\n        pendingMarksRef.current = {};\n      }\n    },\n    [yText, schema, onSchemaViolation]\n  );\n\n  const handleSelectionChange = React.useCallback(\n    (event: { nativeEvent: { from: number; to: number } }) => {\n      const sel: SelectionRange = {\n        from: event.nativeEvent.from,\n        to: event.nativeEvent.to,\n      };\n      selectionRef.current = sel;\n      relativeSelectionRef.current = captureRelativeSelection(yText, sel);\n      // A selection change with a non-zero length, or that moves the caret\n      // away from a position with pending marks, clears pending marks. The\n      // simplest rule that matches user expectation: clear on any explicit\n      // selection change. Typing-driven selection moves already cleared\n      // pending marks in handleContentChange.\n      pendingMarksRef.current = {};\n      onSelectionChange?.(sel);\n    },\n    [yText, onSelectionChange]\n  );\n\n  const handleFocusChange = React.useCallback(\n    (event: { nativeEvent: { focused: boolean } }) => {\n      const focused = event.nativeEvent.focused;\n      focusedRef.current = focused;\n      if (focused) onFocus?.();\n      else onBlur?.();\n    },\n    [onFocus, onBlur]\n  );\n\n  const handleMarkTap = React.useCallback(\n    (event: { nativeEvent: { mark: string; attrsJson: string } }) => {\n      const { mark, attrsJson } = event.nativeEvent;\n      schema.marks[mark]?.onTap?.(parseMarkTapAttrs(attrsJson));\n    },\n    [schema]\n  );\n\n  return (\n    <NativeYTextInputView\n      ref={nativeRef}\n      runs={serializedRuns}\n      renderSpec={renderSpec}\n      pendingSelection={pendingSelection}\n      editable={editable}\n      placeholder={placeholder}\n      placeholderColor={placeholderTextColor}\n      baseFontSize={typeof flatStyle?.fontSize === 'number' ? flatStyle.fontSize : undefined}\n      baseFontFamily={typeof flatStyle?.fontFamily === 'string' ? flatStyle.fontFamily : undefined}\n      baseColor={typeof flatStyle?.color === 'string' ? flatStyle.color : undefined}\n      baseFontWeight={typeof flatStyle?.fontWeight === 'string' ? flatStyle.fontWeight : undefined}\n      baseFontStyle={typeof flatStyle?.fontStyle === 'string' ? flatStyle.fontStyle : undefined}\n      style={style}\n      onContentChange={handleContentChange}\n      onNativeSelectionChange={handleSelectionChange}\n      onFocusChange={handleFocusChange}\n      onMarkTap={handleMarkTap}\n    />\n  );\n}\n"]}