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

package/src/YTextInput.tsx

@@ -0,0 +1,263 @@
+import * as React from 'react';
+import { StyleSheet, type TextStyle } from 'react-native';
+import * as Y from 'yjs';
+
+import {
+  applyReplaceEdit,
+  captureRelativeSelection,
+  resolveRelativeSelection,
+  ytextToRuns,
+  type RelativeSelection,
+} from './bridge';
+import {
+  NativeYTextInputView,
+  parseMarkTapAttrs,
+  serializeRun,
+  type NativeYTextInputViewRef,
+  type SerializedRun,
+} from './internal/NativeYTextInputView';
+import { registerEditor, unregisterEditor, type EditorHandle } from './internal/editorRegistry';
+import { compileRenderSpec } from './schema';
+import type { MarkAttrs, SelectionRange, YTextInputProps } from './types';
+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: YTextInputProps): React.ReactElement {
+  const {
+    yText,
+    schema,
+    style,
+    placeholder,
+    placeholderTextColor,
+    autoFocus,
+    editable = true,
+    onSelectionChange,
+    onFocus,
+    onBlur,
+    onSchemaViolation,
+  } = props;
+
+  const nativeRef = React.useRef<NativeYTextInputViewRef | null>(null);
+  const focusedRef = React.useRef<boolean>(false);
+  const selectionRef = React.useRef<SelectionRange | null>(null);
+  const relativeSelectionRef = React.useRef<RelativeSelection | null>(null);
+  const pendingMarksRef = React.useRef<MarkAttrs>({});
+
+  // 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<{
+    from: number;
+    to: number;
+    version: number;
+  } | null>(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: SerializedRun[] = 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) as TextStyle | undefined,
+    [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: Y.YTextEvent, transaction: Y.Transaction): void {
+      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: EditorHandle = {
+      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: { nativeEvent: { type: 'replace'; from: number; to: number; text: string } }) => {
+      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: { nativeEvent: { from: number; to: number } }) => {
+      const sel: SelectionRange = {
+        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: { nativeEvent: { focused: boolean } }) => {
+      const focused = event.nativeEvent.focused;
+      focusedRef.current = focused;
+      if (focused) onFocus?.();
+      else onBlur?.();
+    },
+    [onFocus, onBlur]
+  );
+
+  const handleMarkTap = React.useCallback(
+    (event: { nativeEvent: { mark: string; attrsJson: string } }) => {
+      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}
+    />
+  );
+}

package/src/YTextRenderer.tsx

@@ -0,0 +1,96 @@
+import * as React from 'react';
+import { Text, type TextStyle } from 'react-native';
+
+import { ytextToRuns } from './bridge';
+import type { MarkAttrs, Run, Schema, YTextRendererProps } from './types';
+
+/**
+ * Read-only rich-text renderer for a Y.Text.
+ *
+ * Implemented as nested `<Text>` views — no native `UITextView` /
+ * `AppCompatEditText` instance, no event handling, no keyboard. Significantly
+ * cheaper than {@link YTextInput} and the right choice for lists of read-only
+ * content (feeds, notification bodies, message previews, etc.).
+ *
+ * Observes the Y.Text and re-renders on every change. The consumer should
+ * unmount this component when the underlying Y.Text is freed.
+ */
+export function YTextRenderer(props: YTextRendererProps): React.ReactElement {
+  const { yText, schema, style, numberOfLines } = props;
+  const [version, setVersion] = React.useState(0);
+
+  React.useEffect(() => {
+    function onChange(): void {
+      setVersion((v) => v + 1);
+    }
+    yText.observe(onChange);
+    return () => {
+      yText.unobserve(onChange);
+    };
+  }, [yText]);
+
+  const runs = React.useMemo<Run[]>(() => ytextToRuns(yText), [yText, version]);
+
+  // Empty Y.Text — render an empty Text rather than nothing, so the consumer's
+  // layout (line height, spacing) is preserved.
+  if (runs.length === 0) {
+    return <Text style={style} numberOfLines={numberOfLines} />;
+  }
+
+  return (
+    <Text style={style} numberOfLines={numberOfLines}>
+      {runs.map((run, index) => (
+        <RunText key={index} run={run} schema={schema} />
+      ))}
+    </Text>
+  );
+}
+
+function RunText({ run, schema }: { run: Run; schema: Schema }): React.ReactElement {
+  // Layer each mark's renderStyle in declaration order; consumer-defined
+  // marks later in the schema map override earlier ones if they collide —
+  // EXCEPT for `textDecorationLine`, which RN's style-flatten would just
+  // overwrite (last write wins). Multiple marks can legitimately want both
+  // decorations at once (e.g. `underline` + `strike`), and RN accepts the
+  // combined token `"underline line-through"` for both. We accumulate the
+  // distinct decoration tokens across marks and apply the merged value as
+  // the final style layer.
+  const styles: TextStyle[] = [];
+  const decorationTokens = new Set<string>();
+  let onPress: (() => void) | undefined;
+  for (const markName of Object.keys(run.marks)) {
+    const value = run.marks[markName];
+    // `null` / `false` are the "explicitly off" sentinels produced by the
+    // insert path's `computeInsertAttrs`. Skip them so we don't re-apply
+    // the mark's renderStyle to text the user just toggled it off for.
+    if (value === null || value === false || value === undefined) continue;
+    const spec = schema.marks[markName];
+    if (!spec) continue;
+    if (spec.renderStyle) {
+      const { textDecorationLine, ...rest } = spec.renderStyle;
+      if (textDecorationLine && textDecorationLine !== 'none') {
+        for (const token of String(textDecorationLine).split(/\s+/)) {
+          if (token === 'underline' || token === 'line-through') {
+            decorationTokens.add(token);
+          }
+        }
+      }
+      styles.push(rest);
+    }
+    if (spec.onTap) {
+      const attrs = (run.marks[markName] as MarkAttrs) ?? {};
+      onPress = () => spec.onTap?.(attrs);
+    }
+  }
+  if (decorationTokens.size > 0) {
+    // Stable order: underline first, line-through second. RN accepts
+    // "underline line-through" / "none" / each on its own.
+    const ordered = ['underline', 'line-through'].filter((t) => decorationTokens.has(t));
+    styles.push({ textDecorationLine: ordered.join(' ') as TextStyle['textDecorationLine'] });
+  }
+  return (
+    <Text style={styles} onPress={onPress}>
+      {run.text}
+    </Text>
+  );
+}

package/src/bridge.ts

@@ -0,0 +1,283 @@
+import * as Y from 'yjs';
+
+import { validateMarks } from './schema';
+import type { MarkAttrs, ReplaceEdit, Run, Schema, SelectionRange } from './types';
+import { ORIGIN_LOCAL_VIEW } from './types';
+
+/**
+ * Convert a Y.Text into the array of attributed runs sent down to the native
+ * view as a prop.
+ *
+ * v0.1 only deals with string inserts — embeds (the future inline-non-text node
+ * story documented in the spec) are deferred. If the underlying delta contains
+ * a non-string insert we stringify defensively rather than throwing.
+ */
+export function ytextToRuns(yText: Y.Text): Run[] {
+  const delta = yText.toDelta() as YDeltaOp[];
+  const runs: Run[] = [];
+  for (const op of delta) {
+    if (op.insert == null) continue;
+    const text = typeof op.insert === 'string' ? op.insert : String(op.insert);
+    if (text.length === 0) continue;
+    runs.push({ text, marks: op.attributes ?? {} });
+  }
+  return runs;
+}
+
+/**
+ * The shape `Y.Text.toDelta()` returns. Yjs's published types are loose here;
+ * we narrow to what we actually consume.
+ */
+interface YDeltaOp {
+  insert?: string | object;
+  attributes?: MarkAttrs;
+}
+
+/**
+ * Compute the marks that should be inherited by an insertion at the given
+ * character offset. Mirrors Quill / ProseMirror behaviour: the inserted text
+ * adopts the marks of the character immediately to its left.
+ *
+ * At offset 0 there is no left character, so we return empty marks.
+ */
+export function inheritedMarksAt(yText: Y.Text, position: number): MarkAttrs {
+  if (position <= 0) return {};
+  const delta = yText.toDelta() as YDeltaOp[];
+  let cursor = 0;
+  for (const op of delta) {
+    const len = typeof op.insert === 'string' ? op.insert.length : op.insert ? 1 : 0;
+    if (len === 0) continue;
+    if (cursor + len >= position) {
+      return op.attributes ? { ...op.attributes } : {};
+    }
+    cursor += len;
+  }
+  return {};
+}
+
+/**
+ * Get the marks that are common to *every* character in `[from, to)`. Used by
+ * `toggleMark` to decide whether to add or remove.
+ */
+export function marksInRange(yText: Y.Text, from: number, to: number): MarkAttrs {
+  if (to <= from) return inheritedMarksAt(yText, from);
+  const delta = yText.toDelta() as YDeltaOp[];
+  let cursor = 0;
+  let common: MarkAttrs | null = null;
+  for (const op of delta) {
+    const len = typeof op.insert === 'string' ? op.insert.length : op.insert ? 1 : 0;
+    if (len === 0) continue;
+    const opStart = cursor;
+    const opEnd = cursor + len;
+    cursor = opEnd;
+    if (opEnd <= from) continue;
+    if (opStart >= to) break;
+    const attrs = op.attributes ?? {};
+    if (common === null) {
+      common = { ...attrs };
+    } else {
+      for (const key of Object.keys(common)) {
+        const a = JSON.stringify(common[key]);
+        const b = JSON.stringify(attrs[key]);
+        if (a !== b) delete common[key];
+      }
+    }
+  }
+  return common ?? {};
+}
+
+/**
+ * Apply a `replace` edit captured from the native view to the Y.Text.
+ *
+ * The edit is wrapped in a single Y.Doc transaction tagged with
+ * {@link ORIGIN_LOCAL_VIEW} so the observer loop in {@link YTextInput} knows
+ * to skip the resulting render-down (the view already has the change locally).
+ */
+export function applyReplaceEdit(
+  yText: Y.Text,
+  edit: ReplaceEdit,
+  schema: Schema,
+  onSchemaViolation?: (info: { mark: string; attrs: MarkAttrs }) => void,
+  pendingMarks?: MarkAttrs
+): void {
+  const doc = yText.doc;
+  if (!doc) {
+    // Y.Text not attached to a doc — extremely defensive, shouldn't happen in
+    // normal use, but we'd rather no-op than crash.
+    return;
+  }
+  doc.transact(() => {
+    const deleteLen = edit.to - edit.from;
+    if (deleteLen > 0) {
+      yText.delete(edit.from, deleteLen);
+    }
+    if (edit.text.length > 0) {
+      const insertAttrs = computeInsertAttrs(
+        yText,
+        edit.from,
+        schema,
+        pendingMarks,
+        onSchemaViolation
+      );
+      yText.insert(
+        edit.from,
+        edit.text,
+        Object.keys(insertAttrs).length > 0 ? insertAttrs : undefined
+      );
+    }
+  }, ORIGIN_LOCAL_VIEW);
+}
+
+/**
+ * Compute the attributes to pass to `Y.Text.insert(...)` for a new run of text
+ * at `position`, given the inherited marks of the character to the left and
+ * the editor's pending-marks overlay.
+ *
+ * Crucially, the returned object actively **`null`s out** any mark that's
+ * being suppressed — either because the user toggled it off via the pending
+ * overlay, or because the schema sanitiser dropped it (unknown mark, failed
+ * validation). Y.Text inheriting an attribute on the new characters can only
+ * be cancelled by passing `null` for that key; passing `undefined` or
+ * omitting the key keeps the inheritance.
+ */
+function computeInsertAttrs(
+  yText: Y.Text,
+  position: number,
+  schema: Schema,
+  pendingMarks: MarkAttrs | undefined,
+  onSchemaViolation?: (info: { mark: string; attrs: MarkAttrs }) => void
+): MarkAttrs {
+  const inherited = inheritedMarksAt(yText, position);
+  const pending = pendingMarks ?? {};
+
+  // Build the "intended" set of marks. Start from inherited, then apply
+  // pending: a truthy value adds/overrides, `false` removes.
+  const additions: MarkAttrs = { ...inherited };
+  const explicitRemovals = new Set<string>();
+  for (const [name, value] of Object.entries(pending)) {
+    if (value === false) {
+      explicitRemovals.add(name);
+      delete additions[name];
+    } else {
+      additions[name] = value as MarkAttrs;
+    }
+  }
+
+  const { sanitised, violations } = validateMarks(additions, schema);
+  if (onSchemaViolation) {
+    for (const v of violations) onSchemaViolation(v);
+  }
+
+  // Anything we *wanted* to keep but the sanitiser dropped (unknown mark,
+  // invalid attrs) should also be actively removed so it doesn't leak into
+  // the inserted characters via Y.Text inheritance.
+  for (const name of Object.keys(additions)) {
+    if (!(name in sanitised)) explicitRemovals.add(name);
+  }
+  // Inherited marks that the user didn't explicitly touch and that *did*
+  // survive sanitisation are already in `sanitised`. Inherited marks that
+  // *failed* sanitisation are caught by the loop above. We don't need to
+  // null any of them twice.
+
+  const out: MarkAttrs = { ...sanitised };
+  for (const name of explicitRemovals) {
+    out[name] = null;
+  }
+  return out;
+}
+
+/**
+ * Wrap a programmatic mutation (anything driven from JS — toolbar mark
+ * toggles, scripted inserts, deletes) in a Y.Doc transaction.
+ *
+ * Critically, we do NOT tag this with {@link ORIGIN_LOCAL_VIEW}. That origin
+ * is reserved for {@link applyReplaceEdit} — the round-trip path for text
+ * the user just typed into the native view, where the view *already* shows
+ * the change and re-pushing runs back down would clobber the in-flight IME
+ * composition / caret. Programmatic mutations, by contrast, haven't been
+ * reflected in the native view yet, so they MUST be observed by `YTextInput`
+ * to trigger an attributed-string update. Leaving the origin unset (or, in
+ * future, using a distinct `ORIGIN_LOCAL_PROGRAMMATIC` sentinel) is what
+ * causes the observer's `origin === ORIGIN_LOCAL_VIEW` short-circuit to
+ * fall through and recompute / repaint.
+ */
+export function transactProgrammatic(yText: Y.Text, fn: () => void): void {
+  const doc = yText.doc;
+  if (!doc) {
+    fn();
+    return;
+  }
+  doc.transact(fn);
+}
+
+/**
+ * Carrier for a caret/range expressed as relative positions. Survives concurrent
+ * remote insertions/deletions: when the underlying Y.Text changes, resolving
+ * the relative positions against the new state gives us the new absolute offsets
+ * that correspond to "the same logical place" the user was at.
+ */
+export interface RelativeSelection {
+  from: Y.RelativePosition;
+  to: Y.RelativePosition;
+}
+
+/**
+ * Capture the current absolute selection as a {@link RelativeSelection}.
+ *
+ * Y.RelativePosition has an "assoc" flag controlling which side of a tie the
+ * position lives on. For a caret we use:
+ *   - `assoc = -1` for the `from` (start) — sticks to the *left* of a future
+ *     insertion at the same offset, which is the conventional caret behaviour
+ *     for the start of a selection
+ *   - `assoc = 1` for the `to` (end) — sticks to the *right*
+ *
+ * For a collapsed caret both still work — the caret stays where the user "is".
+ */
+export function captureRelativeSelection(
+  yText: Y.Text,
+  selection: SelectionRange
+): RelativeSelection {
+  return {
+    from: Y.createRelativePositionFromTypeIndex(yText, selection.from, -1),
+    to: Y.createRelativePositionFromTypeIndex(yText, selection.to, 1),
+  };
+}
+
+/**
+ * Resolve a {@link RelativeSelection} against the current Y.Text state.
+ *
+ * Returns `null` if either endpoint can no longer be resolved (e.g. the Y.Text
+ * was completely cleared remotely). Callers should fall back to a sensible
+ * default — typically clamping the caret to `yText.length`.
+ */
+export function resolveRelativeSelection(
+  yText: Y.Text,
+  sel: RelativeSelection
+): SelectionRange | null {
+  const doc = yText.doc;
+  if (!doc) return null;
+  const from = Y.createAbsolutePositionFromRelativePosition(sel.from, doc);
+  const to = Y.createAbsolutePositionFromRelativePosition(sel.to, doc);
+  if (!from || !to || from.type !== yText || to.type !== yText) return null;
+  return { from: from.index, to: to.index };
+}
+
+/**
+ * Apply (or remove) a mark across a range. Removal is requested by passing
+ * `attrs = null` (matches the Yjs `format()` semantics).
+ */
+export function formatRange(
+  yText: Y.Text,
+  from: number,
+  to: number,
+  markName: string,
+  attrs: MarkAttrs | null
+): void {
+  if (to <= from) return;
+  transactProgrammatic(yText, () => {
+    // Y.Text.format expects an attributes object where `null` values remove
+    // the corresponding mark. We pass the single mark either as its attrs
+    // object (apply) or as `null` (remove).
+    yText.format(from, to - from, { [markName]: attrs });
+  });
+}

package/src/index.ts

@@ -0,0 +1,21 @@
+/**
+ * @eclosion-tech/react-native-yjs-text
+ *
+ * Native React Native rich text editor backed by Y.Text. No WebView, no
+ * `contenteditable`, no DOM. See ./SPEC.md for the full design rationale.
+ */
+export { YTextInput } from './YTextInput';
+export { YTextRenderer } from './YTextRenderer';
+export { useYTextEditor } from './useYTextEditor';
+export { defaultSchema } from './schema';
+export type {
+  MarkAttrs,
+  MarkSpec,
+  Run,
+  Schema,
+  SelectionRange,
+  YTextEditor,
+  YTextInputProps,
+  YTextRendererProps,
+} from './types';
+export { ORIGIN_LOCAL_VIEW } from './types';