@apollohg/react-native-rich-text-editor 2.0.0

package/dist/NativeEditorTypes.d.ts

@@ -0,0 +1,318 @@
+import type { SerializedEditorMentionTheme } from './EditorMentionThemeNormalization';
+import { type SchemaDefinition } from './schemas';
+import { type EditorCollaborationLimits, type EditorEditingLimits, type EditorResourceLimits } from './ResourceLimits';
+/**
+ * A selection in engine document positions.
+ *
+ * `anchor`/`head` are set for a `'text'` selection, `pos` for a `'node'` one,
+ * and neither for `'all'`. The `*Scalar` variants carry the same points
+ * measured in Unicode scalars instead of document positions.
+ */
+export interface Selection {
+    type: 'text' | 'node' | 'all';
+    /** Fixed end of a text selection. */
+    anchor?: number;
+    /** Moving end of a text selection. Equals `anchor` for a collapsed caret. */
+    head?: number;
+    /** Position of the selected node, for a `'node'` selection. */
+    pos?: number;
+    /** `anchor` in Unicode scalars. */
+    anchorScalar?: number;
+    /** `head` in Unicode scalars. */
+    headScalar?: number;
+    /** `pos` in Unicode scalars. */
+    posScalar?: number;
+}
+/**
+ * An opaque, factory-created document range for local awareness publication.
+ * Its provenance is verified at runtime before a native call; the type brand
+ * prevents accidental literal construction in TypeScript consumers.
+ */
+export declare class NativeEditorLocalAwarenessSelectionValue {
+    readonly anchor: number;
+    readonly head: number;
+    private readonly _nativeEditorLocalAwarenessSelectionBrand;
+    constructor(anchor: number, head: number);
+}
+export type NativeEditorLocalAwarenessSelection = NativeEditorLocalAwarenessSelectionValue;
+/** What this client publishes to other peers in one awareness update. */
+export interface NativeEditorLocalAwarenessIntent {
+    /**
+     * Application-defined presence payload, e.g. `{ user: { name, color } }`.
+     * Published at the awareness root, so `cursor` and `focused` are reserved.
+     */
+    state: Record<string, unknown>;
+    /** Whether this client currently holds editing focus. */
+    focused: boolean;
+    /**
+     * How this intent treats the local cursor. Rust owns it as a sticky
+     * index, so the three cases are deliberately distinct:
+     *
+     * - **omitted** — retain the cursor already published. Use this for
+     *   focus-only or state-only updates: restating a document position
+     *   that the document has since invalidated would be refused.
+     * - **`null`** — publish presence with no cursor at all.
+     * - **a factory selection** — set the cursor to these positions, which
+     *   must resolve against the current document.
+     */
+    selection?: NativeEditorLocalAwarenessSelection | null;
+}
+/** Where a list item sits in its list, supplied with every rendered list block. */
+export interface ListContext {
+    /** Whether the enclosing list is numbered. */
+    ordered: boolean;
+    /** Zero-based position of this item among its siblings. */
+    index: number;
+    /** Number of sibling items in the enclosing list. */
+    total: number;
+    /** The list's `start` attribute — the number the first item takes. */
+    start: number;
+    isFirst: boolean;
+    isLast: boolean;
+    /** List variant, e.g. `'task'` for a checklist. */
+    kind?: string | null;
+    /** Checked state, for a task list item. */
+    checked?: boolean | null;
+}
+/** A mark carrying attributes, e.g. a link with its `href`. */
+export interface RenderMarkWithAttrs {
+    type: string;
+    [key: string]: unknown;
+}
+/** A mark on a rendered text run: its name alone, or its name plus attributes. */
+export type RenderMark = string | RenderMarkWithAttrs;
+/** One piece of the flattened render stream the engine produces for a document. */
+export interface RenderElement {
+    type: 'textRun' | 'blockStart' | 'blockEnd' | 'voidInline' | 'voidBlock' | 'opaqueInlineAtom' | 'opaqueBlockAtom';
+    text?: string;
+    marks?: RenderMark[];
+    nodeType?: string;
+    depth?: number;
+    docPos?: number;
+    atomId?: string;
+    label?: string;
+    attrs?: Record<string, unknown>;
+    mentionTheme?: SerializedEditorMentionTheme;
+    listContext?: ListContext;
+    language?: string;
+}
+/**
+ * A splice against the previously rendered block list: replace `deleteCount`
+ * blocks at `startIndex` with `renderBlocks`. Lets a view redraw only the
+ * blocks that changed.
+ */
+export interface RenderBlocksPatch {
+    baseDocumentVersion: string;
+    startIndex: number;
+    deleteCount: number;
+    renderBlocks: RenderElement[][];
+}
+/** What the current selection can do — the state a toolbar renders from. */
+export interface ActiveState {
+    /** Marks active at the selection, keyed by mark name. */
+    marks: Record<string, boolean>;
+    /** Attributes of each active mark, e.g. `{ link: { href } }`. */
+    markAttrs: Record<string, Record<string, unknown>>;
+    /** Node types enclosing the selection, keyed by node name. */
+    nodes: Record<string, boolean>;
+    /** Whether each command would apply at the selection, keyed by command name. */
+    commands: Record<string, boolean>;
+    /** Mark names the schema permits at the selection. */
+    allowedMarks: string[];
+    /** Node names that can be inserted at the selection. */
+    insertableNodes: string[];
+}
+/** Undo and redo availability. */
+export interface HistoryState {
+    canUndo: boolean;
+    canRedo: boolean;
+}
+export type DeepReadonly<T> = T extends ReadonlyArray<infer Item> ? ReadonlyArray<DeepReadonly<Item>> : T extends object ? {
+    readonly [Key in keyof T]: DeepReadonly<T[Key]>;
+} : T;
+/** A recursively immutable active-state view supplied by atomic render snapshots. */
+export type ReadonlyActiveState = DeepReadonly<ActiveState>;
+export type NativeEditorAtomicRenderPayload = {
+    renderBlocks: RenderElement[][];
+    renderPatch: null;
+} | {
+    renderBlocks: null;
+    renderPatch: RenderBlocksPatch;
+};
+export type NativeEditorAtomicRenderSnapshotShape = NativeEditorAtomicRenderPayload & {
+    selection: Selection;
+    activeState: ActiveState;
+    historyState: HistoryState;
+    documentVersion: string;
+    stateRevision: string;
+    scalarLength: number;
+    /** The core's own answer for whether the document holds no content. */
+    documentIsEmpty: boolean;
+};
+/** A recursively immutable view of the value frozen by renderUpdate(). */
+export type NativeEditorAtomicRenderSnapshot = DeepReadonly<NativeEditorAtomicRenderSnapshotShape>;
+/** One coherent view of the document after a change: what to draw, plus selection and state. */
+export interface EditorUpdate {
+    /** The whole document as a flat render stream. */
+    renderElements: RenderElement[];
+    /** The same content grouped into blocks. */
+    renderBlocks?: RenderElement[][];
+    /** Blocks that changed since the previous update, when the engine could compute a splice. */
+    renderPatch?: RenderBlocksPatch;
+    selection: Selection;
+    activeState: ActiveState;
+    historyState: HistoryState;
+    /** Decimal-string engine document revision this update describes. */
+    documentVersion?: string;
+}
+/** The document in both serialized forms, read in one pass. */
+export interface ContentSnapshot {
+    html: string;
+    json: DocumentJSON;
+}
+/**
+ * A ProseMirror-style JSON document or fragment. Deliberately open: the shape
+ * is whatever the active {@link SchemaDefinition} admits, so nodes carry
+ * `type`, optional `attrs`, `content`, `marks`, and `text`.
+ */
+export interface DocumentJSON {
+    [key: string]: unknown;
+}
+/** A participant in a collaboration room. */
+export interface CollaborationPeer {
+    /** Yjs client identity, as a decimal string. */
+    clientId: string;
+    /** Whether this record describes this device. */
+    isLocal: boolean;
+    /** The peer's published awareness state. */
+    state: Record<string, unknown> | null;
+}
+export type CommandBlockedReason = 'composition' | 'detached' | 'pendingUpdate' | 'destroyed' | 'unknown';
+export interface CommandBlockedInfo {
+    blocked: boolean;
+    reason: CommandBlockedReason | null;
+}
+export type NativeEditorHistoryMode = 'undoableBoundary' | 'resetAndClear';
+/**
+ * Provenance of an exported room snapshot. A snapshot only restores into a
+ * handle whose document, lineage, fragment, and schema match.
+ */
+export interface NativeEditorSnapshotMetadata {
+    /** Snapshot format version, so older exports can be recognized. */
+    formatVersion: number;
+    documentId: string;
+    lineageId: string;
+    fragmentName: string;
+    /** Digest of the schema the snapshot was taken under. */
+    schemaFingerprint: string;
+}
+/** An exported room document: its provenance plus the encoded Yjs state. */
+export interface NativeEditorRoomSnapshot {
+    metadata: NativeEditorSnapshotMetadata;
+    /** Encoded Yjs state. Bounded by `EditorResourceLimits.maxEncodedStateBytes`. */
+    encodedState: Uint8Array;
+}
+/**
+ * How a document handle's content starts out. Fixed at creation — there is no
+ * prop equivalent.
+ *
+ * - `localEmpty` — the schema's empty document.
+ * - `localJson` / `localHtml` — seeded from the given content.
+ * - `room` — a collaborative document. It renders nothing until the server's
+ *   document arrives, unless a `snapshot` seeds it offline.
+ */
+export type NativeEditorInitialization = {
+    type: 'localEmpty';
+} | {
+    type: 'localJson';
+    json: DocumentJSON;
+} | {
+    type: 'localHtml';
+    html: string;
+} | {
+    type: 'room';
+    /** Room identity. Must match the collaboration controller's `documentId`. */
+    documentId: string;
+    /** Application-owned lineage tag, e.g. `` `my-app|${documentId}` ``. A
+     *  snapshot only restores into a handle declaring the same lineage. */
+    lineageId: string;
+    /** Previously exported state, for offline restore. */
+    snapshot?: NativeEditorRoomSnapshot;
+};
+/**
+ * Everything fixed for the lifetime of a document handle. Initialization,
+ * schema, editing policy, and limits all live here rather than on the view,
+ * so an editor and its collaboration controller cannot disagree about them.
+ */
+export interface NativeEditorCreateConfig {
+    initialization: NativeEditorInitialization;
+    /** Node and mark types this document admits. Defaults to `defaultSchema`. */
+    schema?: SchemaDefinition;
+    /** Yjs fragment the document lives in. Defaults to `'prosemirror'`. */
+    fragmentName?: string;
+    /** Engine-enforced editing policy. `RichTextEditor.editable` is a separate, per-view interaction gate. */
+    policy?: {
+        /** Maximum document text length in Unicode scalars. A change that would exceed it is rejected. */
+        maxLength?: number;
+        /** Whether the engine refuses every mutation, raising `MUTATION_REJECTED`. */
+        readOnly?: boolean;
+        /** Regular expression applied per character to typed input; characters that do not match are dropped. */
+        inputFilter?: string;
+        /** Whether `data:` image sources are admitted. Defaults to false. */
+        allowBase64Images?: boolean;
+    };
+    /** Resource bounds. See {@link EditorResourceLimits}. */
+    limits?: {
+        resource?: EditorResourceLimits;
+        editing?: EditorEditingLimits;
+        collaboration?: EditorCollaborationLimits;
+    };
+}
+export interface NativeEditorInputRequest {
+    baseDocumentRevision: string;
+    text: string;
+}
+export interface NativeEditorCommandRequest {
+    baseDocumentRevision: string;
+    command: Record<string, unknown>;
+}
+export interface NativeEditorLocalApiRequest {
+    baseDocumentRevision: string;
+    setJson?: DocumentJSON;
+    setHtml?: string;
+    history: NativeEditorHistoryMode;
+}
+export type NativeEditorOffsetKind = 'scalar' | 'utf16';
+export type NativeEditorPositionAffinity = 'before' | 'after';
+/**
+ * Mirrors the Rust `PositionEnvelope`. `offset` is measured in the currency
+ * named by `kind` — scalar offsets are Unicode scalars, not document positions.
+ */
+export interface NativeEditorPositionEnvelope {
+    offset: number;
+    kind: NativeEditorOffsetKind;
+    affinity?: NativeEditorPositionAffinity;
+}
+export type NativeEditorSelectionEnvelope = {
+    type: 'text';
+    anchor: NativeEditorPositionEnvelope;
+    head: NativeEditorPositionEnvelope;
+} | {
+    type: 'node';
+    at: NativeEditorPositionEnvelope;
+} | {
+    type: 'atom';
+    docPos: number;
+    edge: 'node' | 'before' | 'after';
+} | {
+    type: 'all';
+};
+export interface NativeEditorSelectionRequest {
+    baseDocumentRevision: string;
+    selection: NativeEditorSelectionEnvelope;
+}
+export interface NativeEditorReplaceDocumentRequest {
+    setJson?: DocumentJSON;
+    setHtml?: string;
+    history: NativeEditorHistoryMode;
+}

package/dist/NativeEditorTypes.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NativeEditorLocalAwarenessSelectionValue = void 0;
+/**
+ * An opaque, factory-created document range for local awareness publication.
+ * Its provenance is verified at runtime before a native call; the type brand
+ * prevents accidental literal construction in TypeScript consumers.
+ */
+class NativeEditorLocalAwarenessSelectionValue {
+    constructor(anchor, head) {
+        this.anchor = anchor;
+        this.head = head;
+    }
+}
+exports.NativeEditorLocalAwarenessSelectionValue = NativeEditorLocalAwarenessSelectionValue;

package/dist/NativeEditorV2Decimal.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Canonical v2 u64 wire values are decimal strings only. The range check is
+ * lexical after syntax validation, so JavaScript never coerces the value.
+ */
+export declare function normalizeNativeEditorV2U64(value: unknown): string | null;

package/dist/NativeEditorV2Decimal.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeNativeEditorV2U64 = normalizeNativeEditorV2U64;
+const CANONICAL_V2_U64 = /^(0|[1-9]\d*)$/;
+const V2_U64_MAX = '18446744073709551615';
+/**
+ * Canonical v2 u64 wire values are decimal strings only. The range check is
+ * lexical after syntax validation, so JavaScript never coerces the value.
+ */
+function normalizeNativeEditorV2U64(value) {
+    if (typeof value !== 'string' || !CANONICAL_V2_U64.test(value))
+        return null;
+    if (value.length < V2_U64_MAX.length)
+        return value;
+    if (value.length > V2_U64_MAX.length || value > V2_U64_MAX)
+        return null;
+    return value;
+}

package/dist/NativeProseViewer.d.ts

@@ -0,0 +1,122 @@
+import type { AtomViewport } from './AtomHost';
+import { type ViewProps } from 'react-native';
+import { type EditorImageLoadingPolicy } from './ImageLoadingPolicy';
+import { type EditorResourceLimits } from './ResourceLimits';
+import { type EditorTheme } from './EditorTheme';
+import type { DocumentJSON } from './NativeEditorBridge';
+import type { EditorAddons, MentionPressEvent, MentionsAddonOptions } from './EditorAddon';
+import { type AtomNodeDefinition } from './atoms';
+import { type RichTextViewerAtomAttrsUpdateEvent } from './useViewerAtoms';
+import { type SchemaDefinition } from './schemas';
+export type { RichTextViewerAtomAttrsUpdateEvent, NativeProseViewerAtomAttrsUpdateEvent, } from './useViewerAtoms';
+/** A parse, layout, or rendering failure reported by the native viewer. */
+export interface RichTextViewerErrorEvent {
+    /** Native subsystem that raised the failure, e.g. `'viewer'`. */
+    domain: string;
+    /** Stable failure code, e.g. `'INVALID_MENTION_ATTRIBUTES'`. */
+    code: string;
+    message: string;
+    /** Whether the viewer gave up on this content, as opposed to skipping one element. */
+    fatal: boolean;
+}
+/** A tap on a mention node. Requires a mention addon with `onPress`. */
+export type RichTextViewerMentionPressEvent = MentionPressEvent;
+/** A tap on link-marked text. Requires `enableLinkTaps` and `onPressLink`. */
+export interface RichTextViewerLinkPressEvent {
+    /** The link mark's `href` attribute. */
+    href: string;
+    /** The text the link mark covers. */
+    text: string;
+}
+/** Mention rendering and press handling for the viewer. */
+export type RichTextViewerMentionsConfig = MentionsAddonOptions;
+export type RichTextViewerAddons = EditorAddons;
+/** Props shared by both content forms of {@link RichTextViewerProps}. */
+export interface RichTextViewerBaseProps extends ViewProps {
+    /** Schema the content is parsed against. Defaults to {@link defaultSchema}; the mention node is always added. */
+    schema?: SchemaDefinition;
+    /** React renderers for custom block atoms; their node specs are added to the schema. */
+    atoms?: readonly AtomNodeDefinition<any>[];
+    /** Whether persisted atom attributes are read-only. Defaults to true; prose is always read-only. */
+    readOnly?: boolean;
+    /** Whether atom controls receive input. Defaults to true, independently of readOnly. */
+    atomsInteractive?: boolean;
+    /** Opt-in atom virtualization; range is relative to the native viewer content. */
+    atomViewport?: AtomViewport;
+    /** Handles an atom update request. Persist it in the app and supply updated content. */
+    onUpdateAtomAttrs?: (event: RichTextViewerAtomAttrsUpdateEvent) => void | Promise<void>;
+    /** Native content theme. See {@link EditorTheme}. */
+    theme?: EditorTheme;
+    /** Whether `data:` image sources are admitted. Defaults to false. */
+    allowBase64Images?: boolean;
+    /** Bounds image fetching and decoding. See {@link EditorImageLoadingPolicy}. */
+    imageLoadingPolicy?: EditorImageLoadingPolicy;
+    /** Bounds the content the viewer will parse. See {@link EditorResourceLimits}. */
+    resourceLimits?: EditorResourceLimits;
+    /** Whether content with no text measures to zero height. Defaults to true. */
+    collapseTrailingEmptyParagraphs?: boolean;
+    /** Whether link-marked text is tappable. Defaults to true. */
+    enableLinkTaps?: boolean;
+    /** Whether image nodes are fetched and drawn. Defaults to true. */
+    renderImages?: boolean;
+    /**
+     * Bump this to discard the prepared layout after the app's font
+     * environment changes (a newly registered font, a font-scale change).
+     * Defaults to 0.
+     */
+    fontEnvironmentRevision?: number;
+    addons?: RichTextViewerAddons;
+    /** Called when link-marked text is tapped. */
+    onPressLink?: (event: RichTextViewerLinkPressEvent) => void;
+    /** Called when the viewer cannot parse, lay out, or render the content. */
+    onError?: (error: RichTextViewerErrorEvent) => void;
+}
+interface RichTextViewerJsonProps extends RichTextViewerBaseProps {
+    /** ProseMirror JSON document, or a JSON string holding one. */
+    contentJSON: DocumentJSON | string;
+    contentHTML?: never;
+}
+interface RichTextViewerHtmlProps extends RichTextViewerBaseProps {
+    /** HTML document. Sanitize untrusted HTML before passing it here. */
+    contentHTML: string;
+    contentJSON?: never;
+}
+/**
+ * Props for {@link RichTextViewer}. Supply exactly one content source:
+ * `contentJSON` or `contentHTML`.
+ */
+export type RichTextViewerProps = RichTextViewerJsonProps | RichTextViewerHtmlProps;
+/**
+ * Read-only renderer for HTML or ProseMirror JSON. It prepares a native
+ * layout and measures to that layout's exact size, so the host must give it a
+ * finite width; no editor session is created and no document handle is
+ * needed.
+ *
+ * Requires the New Architecture.
+ *
+ * @example
+ * ```tsx
+ * <RichTextViewer
+ *     contentHTML='<p>Read-only content</p>'
+ *     theme={{ text: { fontSize: 16 } }}
+ *     onPressLink={({ href }) => openLink(href)}
+ * />
+ * ```
+ */
+export declare function RichTextViewer(props: RichTextViewerProps): import("react/jsx-runtime").JSX.Element;
+/** @deprecated Use RichTextViewerErrorEvent instead. */
+export type NativeProseViewerErrorEvent = RichTextViewerErrorEvent;
+/** @deprecated Use RichTextViewerMentionPressEvent instead. */
+export type NativeProseViewerMentionPressEvent = RichTextViewerMentionPressEvent;
+/** @deprecated Use RichTextViewerLinkPressEvent instead. */
+export type NativeProseViewerLinkPressEvent = RichTextViewerLinkPressEvent;
+/** @deprecated Use RichTextViewerMentionsConfig instead. */
+export type NativeProseViewerMentionsConfig = RichTextViewerMentionsConfig;
+/** @deprecated Use RichTextViewerAddons instead. */
+export type NativeProseViewerAddons = RichTextViewerAddons;
+/** @deprecated Use RichTextViewerBaseProps instead. */
+export type NativeProseViewerBaseProps = RichTextViewerBaseProps;
+/** @deprecated Use RichTextViewerProps instead. */
+export type NativeProseViewerProps = RichTextViewerProps;
+/** @deprecated Use RichTextViewer instead. */
+export declare const NativeProseViewer: typeof RichTextViewer;

package/dist/NativeProseViewer.js

@@ -0,0 +1,130 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NativeProseViewer = void 0;
+exports.RichTextViewer = RichTextViewer;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
+const react_native_1 = require("react-native");
+const ImageLoadingPolicy_1 = require("./ImageLoadingPolicy");
+const ResourceLimits_1 = require("./ResourceLimits");
+const EditorTheme_1 = require("./EditorTheme");
+const addons_1 = require("./addons");
+const atoms_1 = require("./atoms");
+const useViewerAtoms_1 = require("./useViewerAtoms");
+const PreparedProseViewerNativeComponent_1 = __importDefault(require("./specs/PreparedProseViewerNativeComponent"));
+const ViewerConfiguration_1 = require("./ViewerConfiguration");
+const schemas_1 = require("./schemas");
+const serializedJsonCache = new WeakMap();
+function stringifyCachedJson(value) {
+    const cached = serializedJsonCache.get(value);
+    if (cached != null) {
+        return cached;
+    }
+    const serialized = JSON.stringify(value);
+    serializedJsonCache.set(value, serialized);
+    return serialized;
+}
+function resolveViewerConfiguration(schema, allowBase64Images, resourceLimits, mentions, atoms, codeHighlighting) {
+    return {
+        initialization: { type: 'localEmpty' },
+        ...(codeHighlighting ? { codeHighlighting } : {}),
+        schema: (0, atoms_1.withAtomsSchema)((0, addons_1.withMentionsSchema)(schema ?? schemas_1.defaultSchema), atoms ?? []),
+        ...(allowBase64Images ? { policy: { allowBase64Images: true } } : {}),
+        ...(resourceLimits ? { limits: { resource: resourceLimits } } : {}),
+        ...(mentions?.trigger || mentions?.prefix
+            ? {
+                mentions: {
+                    ...(mentions.trigger ? { trigger: mentions.trigger } : {}),
+                    ...(mentions.prefix ? { prefix: mentions.prefix } : {}),
+                },
+            }
+            : {}),
+    };
+}
+/**
+ * Read-only renderer for HTML or ProseMirror JSON. It prepares a native
+ * layout and measures to that layout's exact size, so the host must give it a
+ * finite width; no editor session is created and no document handle is
+ * needed.
+ *
+ * Requires the New Architecture.
+ *
+ * @example
+ * ```tsx
+ * <RichTextViewer
+ *     contentHTML='<p>Read-only content</p>'
+ *     theme={{ text: { fontSize: 16 } }}
+ *     onPressLink={({ href }) => openLink(href)}
+ * />
+ * ```
+ */
+function RichTextViewer(props) {
+    const { contentJSON, contentHTML, schema, atoms, readOnly = true, atomsInteractive = true, atomViewport, onUpdateAtomAttrs, theme, allowBase64Images = false, imageLoadingPolicy, resourceLimits, collapseTrailingEmptyParagraphs = true, enableLinkTaps = true, renderImages = true, fontEnvironmentRevision = 0, addons, onPressLink, onError, ...viewProps } = props;
+    const { mentions, codeHighlighting } = (0, react_1.useMemo)(() => (0, addons_1.normalizeEditorAddons)(addons), [addons]);
+    const resolvedResourceLimits = (0, react_1.useMemo)(() => (resourceLimits ? (0, ResourceLimits_1.resolveEditorResourceLimits)(resourceLimits) : undefined), [resourceLimits]);
+    const configJson = (0, react_1.useMemo)(() => (0, ViewerConfiguration_1.serializePreparedProseViewerConfiguration)(resolveViewerConfiguration(schema, allowBase64Images, resolvedResourceLimits, mentions, atoms, codeHighlighting)), [allowBase64Images, mentions, resolvedResourceLimits, schema, atoms, codeHighlighting]);
+    const themeJson = (0, react_1.useMemo)(() => (0, EditorTheme_1.serializeEditorTheme)(theme, mentions?.theme), [mentions?.theme, theme]);
+    const imagePolicyJson = (0, react_1.useMemo)(() => (0, ImageLoadingPolicy_1.serializeEditorImageLoadingPolicy)(imageLoadingPolicy), [imageLoadingPolicy]);
+    const sourceKind = contentJSON === undefined ? 'html' : 'json';
+    const source = (0, react_1.useMemo)(() => {
+        if (contentJSON === undefined) {
+            return contentHTML ?? '';
+        }
+        return typeof contentJSON === 'string' ? contentJSON : stringifyCachedJson(contentJSON);
+    }, [contentHTML, contentJSON]);
+    const atomIdentity = (0, react_1.useMemo)(() => ({}), [
+        sourceKind,
+        source,
+        configJson,
+        themeJson,
+        imagePolicyJson,
+        renderImages,
+        collapseTrailingEmptyParagraphs,
+        fontEnvironmentRevision,
+    ]);
+    const viewerAtoms = (0, useViewerAtoms_1.useViewerAtoms)({
+        atoms,
+        identity: atomIdentity,
+        themeJson,
+        readOnly,
+        interactive: atomsInteractive,
+        viewport: atomViewport,
+        onUpdateAtomAttrs,
+        onError,
+    });
+    const handlePressLink = (0, react_1.useCallback)((event) => {
+        onPressLink?.(event.nativeEvent);
+    }, [onPressLink]);
+    const handlePressMention = (0, react_1.useCallback)((event) => {
+        const { docPos, label, attrsJson } = event.nativeEvent;
+        let attrs;
+        try {
+            attrs = JSON.parse(attrsJson);
+        }
+        catch {
+            attrs = null;
+        }
+        if (attrs === null || typeof attrs !== 'object' || Array.isArray(attrs)) {
+            onError?.({
+                domain: 'viewer',
+                code: 'INVALID_MENTION_ATTRIBUTES',
+                message: 'The prepared mention attributes are not a JSON object.',
+                fatal: false,
+            });
+            return;
+        }
+        mentions?.onPress?.({ docPos, label, attrs: attrs });
+    }, [mentions, onError]);
+    const handleError = (0, react_1.useCallback)((event) => {
+        onError?.(event.nativeEvent);
+    }, [onError]);
+    const nativeViewer = ((0, jsx_runtime_1.jsx)(PreparedProseViewerNativeComponent_1.default, { ...(viewerAtoms.enabled ? { style: { alignSelf: 'stretch' } } : viewProps), sourceKind: sourceKind, source: source, configJson: configJson, themeJson: viewerAtoms.themeJson, onAtomLayout: viewerAtoms.enabled ? viewerAtoms.onAtomLayout : undefined, imagePolicyJson: imagePolicyJson, imagesEnabled: renderImages, collapsesWhenEmpty: collapseTrailingEmptyParagraphs, enableLinkTaps: enableLinkTaps && onPressLink != null, mentionInteractionsEnabled: mentions?.onPress != null, fontEnvironmentRevision: fontEnvironmentRevision, onPressLink: onPressLink ? handlePressLink : undefined, onPressMention: mentions?.onPress ? handlePressMention : undefined, onError: onError ? handleError : undefined }));
+    if (!viewerAtoms.enabled)
+        return nativeViewer;
+    return ((0, jsx_runtime_1.jsx)(react_native_1.View, { ...viewProps, children: (0, jsx_runtime_1.jsxs)(react_native_1.View, { style: { alignSelf: 'stretch' }, onLayout: viewerAtoms.onContainerLayout, children: [nativeViewer, viewerAtoms.children] }) }));
+}
+/** @deprecated Use RichTextViewer instead. */
+exports.NativeProseViewer = RichTextViewer;

package/dist/NativeRichTextEditor.d.ts

@@ -0,0 +1,3 @@
+export { type RichTextEditorHeightBehavior, type RichTextEditorToolbarPlacement, type RichTextEditorValueJSONUpdateMode, type RichTextEditorAutoCapitalize, type RichTextEditorKeyboardType, type RichTextEditorAndroidInputOptions, type RemoteSelectionDecoration, type LinkRequestContext, type ImageRequestContext, type RichTextEditorProps, type RichTextEditorRef, type RichTextEditorCaretRect, type NativeRichTextEditorHeightBehavior, type NativeRichTextEditorToolbarPlacement, type NativeRichTextEditorValueJSONUpdateMode, type NativeRichTextEditorAutoCapitalize, type NativeRichTextEditorKeyboardType, type NativeRichTextEditorAndroidInputOptions, type NativeRichTextEditorProps, type NativeRichTextEditorRef, type NativeRichTextEditorCaretRect, } from './RichTextEditorTypes';
+export { RichTextEditor, NativeRichTextEditor } from './RichTextEditor';
+export type { NativeRichTextEditorFocusPreservingElement, NativeRichTextEditorFocusPreservingRef, NativeRichTextEditorFocusPreservingRefs, RichTextEditorFocusPreservingElement, RichTextEditorFocusPreservingRef, RichTextEditorFocusPreservingRefs, } from './useFocusPreservingFrames';

package/dist/NativeRichTextEditor.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NativeRichTextEditor = exports.RichTextEditor = void 0;
+var RichTextEditor_1 = require("./RichTextEditor");
+Object.defineProperty(exports, "RichTextEditor", { enumerable: true, get: function () { return RichTextEditor_1.RichTextEditor; } });
+Object.defineProperty(exports, "NativeRichTextEditor", { enumerable: true, get: function () { return RichTextEditor_1.NativeRichTextEditor; } });