@pilotiq/pilotiq 0.12.0 → 0.13.0

package/src/react/fields/TextLikeInput.tsx

@@ -1,12 +1,12 @@
-import React, { useCallback, useEffect, useMemo, useRef, useState } from 'react'
+import React, { useCallback, useEffect, useRef, useState } from 'react'
 import type { ElementMeta } from '../../schema/Element.js'
-import type { TextBinding } from '../FormCollabBindingRegistry.js'
 import { useFieldState } from '../FormStateContext.js'
 import { useCollabRoom } from '../CollabRoomContext.js'
 import { getCollabTextRenderer, type CollabTextRenderer } from '../CollabTextRendererRegistry.js'
+import { useRowCoords } from '../RowCoordsContext.js'
+import { parseRowFieldPath } from '../formStateHelpers.js'
 import { Input } from '../ui/input.js'
 import { Textarea } from '../ui/textarea.js'
-import { computeDelta, preserveCursor } from './textDelta.js'
 
 /**
  * Bridge between controlled (FormStateProvider) and uncontrolled
@@ -15,15 +15,17 @@ import { computeDelta, preserveCursor } from './textDelta.js'
  * fires the live trigger on change/blur according to the field's `live`
  * config. Outside a controlled form, falls back to plain `defaultValue`.
  *
- * **Phase F.6 — character-level CRDT branch.** When a `<RecordCollabRoom>`
- * is mounted up-tree AND `@pilotiq-pro/collab`'s binding registered a
- * `TextBinding` for this field (text-shaped fieldType + `.collab() !== false`),
- * the input takes the `BoundTextInput` path: edits emit `TextDelta`s to
- * the binding's `Y.Text`, remote changes flow back via `observe`, and
- * cursor position survives both. The legacy whole-string LWW path
- * still runs for non-text fields, non-collab forms, and masked inputs
- * (mask + character-level CRDT is incompatible — peers would see raw
- * keystrokes desynced from the rendered mask).
+ * **Collab branch — Tiptap-backed `Y.XmlFragment`.** When a
+ * `<RecordCollabRoom>` is mounted up-tree AND `@pilotiq/tiptap`'s
+ * `registerTiptap()` registered a collab text renderer, the input
+ * mounts the Tiptap-backed editor against a `Y.XmlFragment` keyed by
+ * either the bare field name (top-level) or
+ * `${arrayName}.${rowId}.${fieldName}` (Repeater / Builder row leaves
+ * via `useRowCoords()`). Selections anchor to `Y.RelativePosition` via
+ * y-prosemirror, so cursors survive both mid-word remote edits and
+ * concurrent inserts. Masked fields fall through to the legacy
+ * whole-string LWW path (mask + character-level CRDT is incompatible
+ * — peers would see raw keystrokes desynced from the rendered mask).
  */
 export function TextLikeInput({
   el, name, common, type, extraProps, multiline, applyMask,
@@ -42,6 +44,7 @@ export function TextLikeInput({
   const fs = useFieldState(name)
   const room = useCollabRoom()
   const collabRenderer = getCollabTextRenderer()
+  const rowCoords = useRowCoords()
   const liveCfg = el['live']
   const liveOpts = (typeof liveCfg === 'object' && liveCfg !== null
     ? liveCfg as { onBlur?: boolean; debounce?: number }
@@ -49,35 +52,48 @@ export function TextLikeInput({
   const onBlurMode = liveOpts.onBlur === true
   const mask = applyMask ?? identity
 
-  // Phase F.6 — character-level CRDT path. Masking is mutually exclusive
-  // with character-level CRDT (peers would see raw keystrokes diverged
-  // from the local mask render); masked fields fall through to LWW.
-  // We read the mask from the field meta directly — `applyMask` is a
-  // `useCallback`-wrapped fn that's *always* defined (identity when no
-  // mask), so its truthiness can't gate the branch.
+  // Masking is mutually exclusive with character-level CRDT (peers would
+  // see raw keystrokes diverged from the local mask render); masked
+  // fields fall through to LWW. We read the mask from the field meta
+  // directly — `applyMask` is a `useCallback`-wrapped fn that's *always*
+  // defined (identity when no mask), so its truthiness can't gate the
+  // branch.
   const hasMask = typeof el['mask'] === 'string'
 
-  // Phase B — Tiptap-backed plain-text editor for collab text fields.
-  // When a `<RecordCollabRoom>` is mounted up-tree AND `@pilotiq/tiptap`'s
-  // `registerTiptap()` registered a collab text renderer, take the new path:
-  // the editor anchors selections to Yjs `RelativePosition` (via y-prosemirror)
-  // instead of integer string offsets, fixing the cursor-jump + two-peer
-  // concurrent-insert races that the legacy `Y.Text` + `computeDelta` path
-  // can't resolve. Dotted-path row leaves (Repeater / Builder) stay on the
-  // legacy `fs.textBinding` path — per-row collab editor support is a
-  // separate follow-up.
+  // Collab branch — Tiptap-backed plain-text editor. Top-level fields
+  // use the bare `name` as the fragment-key; Repeater / Builder row
+  // leaves compose `${arrayName}.${rowId}.${fieldName}` from
+  // `useRowCoords()` so the Y.XmlFragment survives row reorders (keyed
+  // by the stable rowId, not the array index). The hidden FormData
+  // input keeps the original dotted path so submission lands on the
+  // server at the right slot.
+  //
+  // Dotted paths that don't match a row shape (no rowCoords OR
+  // `parseRowFieldPath` returns null — nested row arrays, malformed
+  // names) skip the collab path and fall through to the controlled /
+  // uncontrolled branches below.
   const fieldCollab = el['collab'] as boolean | undefined
+  const fragmentKey: string | null = (() => {
+    if (!name.includes('.')) return name
+    if (!rowCoords) return null
+    const parsed = parseRowFieldPath(name)
+    if (!parsed) return null
+    if (parsed.arrayName !== rowCoords.arrayName) return null
+    if (parsed.index     !== rowCoords.rowIndex)  return null
+    return `${rowCoords.arrayName}.${rowCoords.rowId}.${parsed.fieldName}`
+  })()
   if (
     room &&
     collabRenderer &&
     fieldCollab !== false &&
     !hasMask &&
-    !name.includes('.')
+    fragmentKey !== null
   ) {
     return (
       <CollabTextField
         Renderer={collabRenderer}
-        name={name}
+        fragmentKey={fragmentKey}
+        hiddenInputName={name}
         multiline={multiline}
         defaultValue={stringValue(common['defaultValue'])}
         {...(common['placeholder'] !== undefined ? { placeholder: String(common['placeholder']) } : {})}
@@ -90,21 +106,6 @@ export function TextLikeInput({
     )
   }
 
-  if (fs.textBinding && !hasMask) {
-    return (
-      <BoundTextInput
-        binding={fs.textBinding}
-        name={name}
-        triggerLive={fs.triggerLive}
-        onBlurMode={onBlurMode}
-        common={common}
-        extraProps={extraProps}
-        type={type}
-        multiline={multiline}
-      />
-    )
-  }
-
   if (fs.controlled) {
     const ctxValue = fs.value !== undefined && fs.value !== null ? String(fs.value) : ''
     const onChange = (e: React.ChangeEvent<HTMLInputElement | HTMLTextAreaElement>): void => {
@@ -144,174 +145,7 @@ export function TextLikeInput({
 }
 
 /**
- * Phase F.6 — CRDT-bound text input. Owns its own controlled state
- * because the binding's `Y.Text` is the source of truth (not the
- * form's `values` map). Mirrors every committed value back into the
- * form context via `fs.setValue` so submission / live re-resolve see
- * the latest string.
- *
- * Lifecycle:
- *   - Mount: seed local state from `binding.read()`; mirror it into
- *     the form's `values` map.
- *   - Local edit: compute a `TextDelta` (insert / delete / replace)
- *     from the before/after strings and `applyDelta` to the binding.
- *     Eagerly update local state in the same React render so the
- *     controlled input doesn't lag the keystroke.
- *   - Remote edit: `binding.observe` fires with the post-change
- *     string; we replace local state and best-effort preserve the
- *     local cursor via `preserveCursor`. The local-echo of our own
- *     `applyDelta` is collapsed by the value-equality check.
- *   - IME composition: `applyDelta` is deferred to `compositionend`
- *     so the binding never sees intermediate composing chars (which
- *     would emit one delta per keystroke and confuse downstream
- *     observers).
- */
-function BoundTextInput({
-  binding, name, triggerLive, onBlurMode, common, extraProps, type, multiline,
-}: {
-  binding:     TextBinding
-  name:        string
-  triggerLive: (valueOverride?: unknown) => void
-  onBlurMode:  boolean
-  common:      Record<string, unknown>
-  extraProps:  Record<string, unknown>
-  type:        string
-  multiline:   boolean
-}): React.ReactElement {
-  const fs = useFieldState(name)
-  // SSR-rendered default. Captured once at mount; used as display
-  // fallback while the room's `Y.Text` is still empty (the seed race
-  // for Y.Text isn't safe across concurrent first-mounters, so no peer
-  // populates it client-side — see `@pilotiq-pro/collab` for the
-  // rationale). First user edit emits a replace-from-empty delta that
-  // atomically lifts the displayed value into the CRDT.
-  // eslint-disable-next-line react-hooks/exhaustive-deps
-  const fallback    = useMemo(() => stringValue(fs.value), [])
-  const [value, setValueLocal] = useState<string>(() => binding.read() || fallback)
-  const valueRef    = useRef<string>(value)
-  const isComposing = useRef<boolean>(false)
-  const inputRef    = useRef<HTMLInputElement | HTMLTextAreaElement | null>(null)
-
-  useEffect(() => { valueRef.current = value }, [value])
-
-  // Stable ref to the form-mirror writer so the observer effect below
-  // doesn't tear down on every render (fs.setValue is a fresh arrow on
-  // every useFieldState call).
-  const mirrorRef = useRef<(v: string) => void>(() => {})
-  useEffect(() => {
-    mirrorRef.current = (v: string): void => { fs.setValue(v) }
-  })
-
-  // On mount / binding swap: read the binding's current state. If
-  // non-empty (i.e. someone else has already typed), display it and
-  // mirror into the form values map. If empty, leave the fallback
-  // showing — no client-side seed (see file-header comment).
-  useEffect(() => {
-    const initial = binding.read()
-    if (initial.length > 0) {
-      setValueLocal(initial)
-      valueRef.current = initial
-      mirrorRef.current(initial)
-    }
-  }, [binding])
-
-  // Subscribe to text-CRDT changes. Yjs fires this for BOTH local and
-  // remote transactions — local echoes are collapsed by the
-  // `next === prev` guard.
-  useEffect(() => {
-    const unsubscribe = binding.observe((next) => {
-      const prev = valueRef.current
-      if (next === prev) return
-      const el = inputRef.current
-      const cursor = el?.selectionStart ?? next.length
-      const restored = preserveCursor(prev, next, cursor)
-      setValueLocal(next)
-      valueRef.current = next
-      mirrorRef.current(next)
-      // Defer cursor restore until after React commits. Only reapply
-      // when the input is still focused — yanking the selection on a
-      // blurred field would steal focus across the page.
-      requestAnimationFrame(() => {
-        if (!el) return
-        if (document.activeElement !== el) return
-        try { el.setSelectionRange(restored, restored) } catch { /* setSelectionRange unsupported on some input types — defensive */ }
-      })
-    })
-    return unsubscribe
-  }, [binding])
-
-  const commitDelta = useCallback((after: string): void => {
-    // Compute the delta against the binding's *current* Y.Text contents
-    // — not the renderer's `before` ref. The two can diverge in three
-    // cases that all converge correctly under this approach:
-    //   1. First edit when Y.Text is empty: delta = `insert@0 <whole>`,
-    //      which atomically lifts the displayed fallback into the CRDT
-    //      without a separate seed op.
-    //   2. After a remote-applied update: Y.Text holds the peer's value;
-    //      computing against it avoids "ghost" deltas that re-emit ops
-    //      against a stale local ref.
-    //   3. After a server-resolve `triggerLive` replace: same as (2).
-    const before = binding.read()
-    if (after === before) return
-    const delta = computeDelta(before, after)
-    if (!delta) return
-    // Pre-stamp `valueRef.current = after` BEFORE `applyDelta`. Y.Text's
-    // observe fires synchronously inside `applyDelta` for our own write,
-    // so without this the observer would see `prev=before, next=after`
-    // and run `preserveCursor` — which is designed for *remote* edits
-    // and clobbers the user's caret on local typing (typed '1' at pos 0
-    // would jump cursor forward by delta-length and the next keystroke
-    // would insert at the wrong index, producing scrambled output).
-    // With `valueRef` already at `after`, the observer's `next === prev`
-    // short-circuit fires and the cursor is left alone for local echoes.
-    valueRef.current = after
-    binding.applyDelta(delta)
-    setValueLocal(after)
-    mirrorRef.current(after)
-    if (!onBlurMode) triggerLive(after)
-  }, [binding, onBlurMode, triggerLive])
-
-  const onChange = (e: React.ChangeEvent<HTMLInputElement | HTMLTextAreaElement>): void => {
-    if (isComposing.current) {
-      // IME mid-composition — paint locally, hold the delta until commit.
-      setValueLocal(e.target.value)
-      return
-    }
-    commitDelta(e.target.value)
-  }
-
-  const onCompositionStart = (): void => { isComposing.current = true }
-  const onCompositionEnd   = (e: React.CompositionEvent<HTMLInputElement | HTMLTextAreaElement>): void => {
-    isComposing.current = false
-    commitDelta(e.currentTarget.value)
-  }
-
-  const onBlur = (): void => {
-    if (onBlurMode) triggerLive(valueRef.current)
-  }
-
-  const setRef = (el: HTMLInputElement | HTMLTextAreaElement | null): void => {
-    inputRef.current = el
-  }
-
-  const props = {
-    ...common,
-    ...extraProps,
-    defaultValue: undefined,
-    value,
-    onChange,
-    onBlur,
-    onCompositionStart,
-    onCompositionEnd,
-    ref: setRef,
-  }
-
-  if (multiline) return <Textarea {...(props as React.ComponentProps<typeof Textarea>)} />
-  return <Input {...(props as React.ComponentProps<typeof Input>)} type={type} />
-}
-
-/**
- * Phase B — wrapper around the registered Tiptap-backed collab editor.
+ * Wrapper around the registered Tiptap-backed collab editor.
  * Owns the local text mirror so the hidden `<input>` always carries the
  * editor's current value for FormData submission. When `FormStateProvider`
  * is mounted up-tree, also mirrors every update into the values map via
@@ -322,21 +156,29 @@ function BoundTextInput({
  * editor handles composition natively and y-prosemirror anchors selections
  * to `Yjs.RelativePosition`, so the cursor survives concurrent + mid-word
  * remote edits without any client-side bookkeeping.
+ *
+ * `fragmentKey` and `hiddenInputName` diverge for row-text leaves (Phase
+ * 1 of collab-row-text-tiptap-backed.md): the renderer's Y.XmlFragment is
+ * keyed by `${arrayName}.${rowId}.${fieldName}` so it survives row
+ * reorders, while the hidden FormData input keeps the dotted path
+ * (`items.0.title`) so submission lands at the right server-side slot.
+ * For top-level fields the two are identical.
  */
 function CollabTextField({
-  Renderer, name, multiline, defaultValue, placeholder, disabled,
+  Renderer, fragmentKey, hiddenInputName, multiline, defaultValue, placeholder, disabled,
   triggerLive, setValue, controlled, onBlurMode,
 }: {
-  Renderer:     CollabTextRenderer
-  name:         string
-  multiline:    boolean
-  defaultValue: string
-  placeholder?: string
-  disabled:     boolean
-  triggerLive:  (valueOverride?: unknown) => void
-  setValue:     (v: unknown) => void
-  controlled:   boolean
-  onBlurMode:   boolean
+  Renderer:        CollabTextRenderer
+  fragmentKey:     string
+  hiddenInputName: string
+  multiline:       boolean
+  defaultValue:    string
+  placeholder?:    string
+  disabled:        boolean
+  triggerLive:     (valueOverride?: unknown) => void
+  setValue:        (v: unknown) => void
+  controlled:      boolean
+  onBlurMode:      boolean
 }): React.ReactElement {
   const [text, setText] = useState<string>(defaultValue)
   const textRef = useRef(text)
@@ -376,9 +218,9 @@ function CollabTextField({
 
   return (
     <>
-      <input type="hidden" name={name} value={text} />
+      <input type="hidden" name={hiddenInputName} value={text} />
       <Renderer
-        name={name}
+        name={fragmentKey}
         multiline={multiline}
         defaultValue={defaultValue}
         {...(placeholder !== undefined ? { placeholder } : {})}

package/src/react/formStateHelpers.test.ts

@@ -4,7 +4,6 @@ import assert from 'node:assert/strict'
 import {
   collectFieldDefaults,
   collectRowArrayFieldNames,
-  collectRowTextLeavesByArray,
   fieldOptsOutOfCollab,
   findFieldMeta,
   parseFormDataToNested,
@@ -492,104 +491,6 @@ describe('routeBindingWrite', () => {
   })
 })
 
-describe('collectRowTextLeavesByArray', () => {
-  const textField = (name: string, fieldType: string = 'text', collab?: boolean): ElementMeta => ({
-    type:      'field',
-    fieldType,
-    name,
-    label:     name,
-    required:  false,
-    disabled:  false,
-    ...(collab === false ? { collab: false } : {}),
-  } as ElementMeta)
-
-  // Repeater meta carries the row schema under `template` (`children` is
-  // the per-resolved-row child list, not the field-level template). Tests
-  // must mirror what `RepeaterField.toMeta()` actually emits.
-  const repeater = (name: string, template: ElementMeta[], collab?: boolean): ElementMeta => ({
-    type:      'field',
-    fieldType: 'repeater',
-    name,
-    label:     name,
-    required:  false,
-    disabled:  false,
-    template,
-    ...(collab === false ? { collab: false } : {}),
-  } as ElementMeta)
-
-  it('collects text-shaped inner-field names per Repeater', () => {
-    const meta = formMeta([
-      repeater('tags', [
-        textField('label', 'text'),
-        textField('summary', 'textarea'),
-        textField('count', 'number'),
-      ]),
-    ])
-    const out = collectRowTextLeavesByArray(meta)
-    assert.equal(out.size, 1)
-    assert.deepEqual([...out.get('tags')!].sort(), ['label', 'summary'])
-  })
-
-  it('walks Builder block templates', () => {
-    const meta = formMeta([
-      {
-        type:      'field',
-        fieldType: 'builder',
-        name:      'blocks',
-        children:  [],
-        blocks: [
-          { name: 'heading',   template: [textField('text', 'text')] },
-          { name: 'paragraph', template: [textField('body', 'markdown')] },
-        ],
-      } as unknown as ElementMeta,
-    ])
-    const out = collectRowTextLeavesByArray(meta)
-    assert.deepEqual([...out.get('blocks')!].sort(), ['body', 'text'])
-  })
-
-  it('skips opted-out inner fields', () => {
-    const meta = formMeta([
-      repeater('tags', [
-        textField('label',  'text'),
-        textField('private', 'text', false),   // .collab(false)
-      ]),
-    ])
-    const out = collectRowTextLeavesByArray(meta)
-    assert.deepEqual([...out.get('tags')!], ['label'])
-  })
-
-  it('omits opted-out top-level arrays', () => {
-    const meta = formMeta([
-      repeater('public',  [textField('a', 'text')]),
-      repeater('private', [textField('b', 'text')], false),
-    ])
-    const out = collectRowTextLeavesByArray(meta)
-    assert.equal(out.has('public'),  true)
-    assert.equal(out.has('private'), false)
-  })
-
-  it('stops at nested array boundaries (no 5+ segment dotted paths)', () => {
-    const meta = formMeta([
-      repeater('outer', [
-        textField('outerLabel', 'text'),
-        repeater('inner', [textField('innerLabel', 'text')]),
-      ]),
-    ])
-    const out = collectRowTextLeavesByArray(meta)
-    assert.deepEqual([...out.get('outer')!], ['outerLabel'])
-    assert.equal(out.has('inner'), false, 'nested Repeater not surfaced as a top-level array')
-  })
-
-  it('returns empty map when no Repeater/Builder has text leaves', () => {
-    const meta = formMeta([
-      textField('top', 'text'),
-      repeater('numbers', [textField('count', 'number')]),
-    ])
-    const out = collectRowTextLeavesByArray(meta)
-    assert.equal(out.size, 0)
-  })
-})
-
 describe('fieldOptsOutOfCollab', () => {
   it('returns true only when the field carries an explicit collab=false', () => {
     const meta = formMeta([

package/src/react/formStateHelpers.ts

@@ -379,86 +379,3 @@ export function collectRowArrayFieldNames(formMeta: ElementMeta): string[] {
   }
 }
 
-/**
- * Phase F.5c — text-shaped fieldTypes whose row-leaf values should be
- * routed through `Y.Text` instead of `Y.Map` LWW. Mirrors the same
- * allowlist `@pilotiq-pro/collab`'s top-level binding uses; consumers
- * registering character-level CRDT for additional plain-text-shaped
- * fields update both copies in lockstep until a cross-repo shared
- * constants module exists.
- */
-const ROW_TEXT_FIELD_TYPES: ReadonlySet<string> = new Set([
-  'text', 'textarea', 'email', 'slug', 'markdown',
-])
-
-/**
- * Phase F.5c — per-Repeater/Builder set of inner-field names that
- * carry text-shaped leaves eligible for character-level CRDT. Drives
- * `useFieldState(dottedName).textBinding` resolution: only fields in
- * the per-array set go through `binding.getRowTextBinding`; everything
- * else stays on row-level Y.Map LWW.
- *
- * Repeater rows expose their schema directly under `meta.children`;
- * Builder rows nest schemas under `meta.blocks[i].template`. The
- * walker descends through every block's template so a `markdown` leaf
- * inside any block-type lands in the array's allowlist. Nested
- * Repeaters / Builders inside row schemas are out of scope v1 (their
- * dotted paths are 5+ segments and `parseRowFieldPath` rejects them).
- */
-export function collectRowTextLeavesByArray(formMeta: ElementMeta): Map<string, Set<string>> {
-  const out = new Map<string, Set<string>>()
-  walkTop(formMeta)
-  return out
-
-  function walkTop(node: ElementMeta): void {
-    if (node.type === 'field') {
-      const fieldType = String(node['fieldType'] ?? '')
-      if (fieldType === 'repeater' || fieldType === 'builder') {
-        if ((node as { collab?: boolean }).collab === false) return
-        const name = String(node['name'] ?? '')
-        if (!name) return
-        const set = new Set<string>()
-        // Repeater's `toMeta()` emits the row schema under `template` (not
-        // `children` — that's per-resolved-row). Builder nests row schemas
-        // under `blocks[i].template`. Reading `children` here pre-fix gave
-        // every Repeater an empty text-leaf set → row text never CRDT'd.
-        if (fieldType === 'repeater') walkRow((node as { template?: unknown }).template, set)
-        else                          walkBlocks((node as { blocks?: unknown }).blocks, set)
-        if (set.size > 0) out.set(name, set)
-        return
-      }
-    }
-    const children = node.children
-    if (Array.isArray(children)) {
-      for (const child of children) walkTop(child as ElementMeta)
-    }
-  }
-
-  function walkRow(children: unknown, set: Set<string>): void {
-    if (!Array.isArray(children)) return
-    for (const child of children) walkRowEl(child as ElementMeta, set)
-  }
-
-  function walkRowEl(node: ElementMeta, set: Set<string>): void {
-    if (node.type === 'field') {
-      const fieldType = String(node['fieldType'] ?? '')
-      if (fieldType === 'repeater' || fieldType === 'builder') return   // nested array
-      if ((node as { collab?: boolean }).collab === false) return
-      const name = String(node['name'] ?? '')
-      if (name && ROW_TEXT_FIELD_TYPES.has(fieldType)) set.add(name)
-      return
-    }
-    const children = node.children
-    if (Array.isArray(children)) {
-      for (const child of children) walkRowEl(child as ElementMeta, set)
-    }
-  }
-
-  function walkBlocks(blocks: unknown, set: Set<string>): void {
-    if (!Array.isArray(blocks)) return
-    for (const block of blocks) {
-      const tpl = (block as { template?: unknown }).template
-      walkRow(tpl, set)
-    }
-  }
-}

package/src/react/index.ts

@@ -55,8 +55,6 @@ export {
   type FormCollabBinding,
   type FormCollabBindingFactory,
   type FormCollabBindingFactoryArgs,
-  type TextBinding,
-  type TextDelta,
   type RowsEvent,
   type RowBindingApi,
 } from './FormCollabBindingRegistry.js'

package/dist/react/fields/textDelta.d.ts

@@ -1,44 +0,0 @@
-import type { TextDelta } from '../FormCollabBindingRegistry.js';
-/**
- * Phase F.6 — derive a single character-level edit op from two strings.
- *
- * Strategy: find the longest common prefix and suffix between `before`
- * and `after`; whatever's left in the middle is the changed region.
- *
- *   - middle-after empty + middle-before non-empty → `delete`
- *   - middle-before empty + middle-after non-empty → `insert`
- *   - both non-empty                              → `replace`
- *   - both empty (identical strings)              → `null`
- *
- * This correctly handles the common edit shapes: single-key insert,
- * single-key backspace, multi-char paste replacing a selection, IME
- * commits, accent-key composition. It does NOT preserve user intent
- * when the same character appears at multiple positions and the edit
- * could be attributed to either occurrence — Yjs's per-character
- * identity makes that distinction lossy at the string-diff layer
- * (the `Y.Text` itself maintains item identity internally). For v1
- * we accept the ambiguity; the CRDT semantics still converge.
- */
-export declare function computeDelta(before: string, after: string): TextDelta | null;
-/**
- * Phase F.6 — best-effort cursor anchor across a remote-applied edit.
- *
- *   - Edit landed AFTER cursor (cursor inside the common prefix) → keep
- *     cursor where it is.
- *   - Edit landed BEFORE cursor                                  → shift
- *     cursor by `after.length − before.length` so its character-offset
- *     into the post-edit string matches its pre-edit anchor.
- *   - Edit landed OVERLAPPING the cursor                         → cursor
- *     ends up at the boundary between the changed region and the
- *     unchanged suffix (which `Math.max(0, cursor + delta)` produces
- *     naturally and clamps to the new bounds).
- *
- * This is a heuristic, not a Yjs `RelativePosition`. Two peers typing
- * at the exact same insertion point can still see a one-character cursor
- * twitch on the remote-mirror side; v2 (in-input remote carets) would
- * upgrade to relative positions if/when a consumer asks. Native input
- * cursors are clamped to `[0, after.length]` by every browser, so this
- * function does the same to avoid `setSelectionRange` throwing.
- */
-export declare function preserveCursor(before: string, after: string, cursor: number): number;
-//# sourceMappingURL=textDelta.d.ts.map

package/dist/react/fields/textDelta.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"textDelta.d.ts","sourceRoot":"","sources":["../../../src/react/fields/textDelta.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAA;AAEhE;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CA8B5E;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAWpF"}