@openeditor/react-native-prose-editor 0.0.7 → 0.0.9

package/dist/NativeEditorBridge.d.ts

@@ -36,6 +36,7 @@ export interface NativeEditorModule {
     editorToggleBlockquote(editorId: number): string;
     editorToggleHeading(editorId: number, level: number): string;
     editorSetSelection(editorId: number, anchor: number, head: number): void;
+    editorSetCellSelection?(editorId: number, anchor: number, head: number): void;
     editorGetSelection(editorId: number): string;
     editorGetSelectionState(editorId: number): string;
     editorGetCurrentState(editorId: number): string;
@@ -61,6 +62,11 @@ export interface NativeEditorModule {
     editorUnwrapFromList(editorId: number): string;
     editorIndentListItem(editorId: number): string;
     editorOutdentListItem(editorId: number): string;
+    editorInsertTableRow(editorId: number, after: boolean): string;
+    editorDeleteTableRow(editorId: number): string;
+    editorInsertTableColumn(editorId: number, after: boolean): string;
+    editorDeleteTableColumn(editorId: number): string;
+    editorMoveTableCell(editorId: number, forward: boolean): string;
     editorInsertNode(editorId: number, nodeType: string): string;
     editorUndo(editorId: number): string;
     editorRedo(editorId: number): string;
@@ -68,42 +74,55 @@ export interface NativeEditorModule {
     editorCanRedo(editorId: number): boolean;
 }
 export interface Selection {
-    type: 'text' | 'node' | 'all';
+    type: 'text' | 'node' | 'cell' | 'all';
     anchor?: number;
     head?: number;
     pos?: number;
+    anchorScalar?: number;
+    headScalar?: number;
+    posScalar?: number;
 }
-export interface ListContext {
-    ordered: boolean;
-    index: number;
-    total: number;
-    start: number;
-    isFirst: boolean;
-    isLast: boolean;
-    kind?: string | null;
-    checked?: boolean | null;
-}
-export interface RenderMarkWithAttrs {
+export interface RenderTreeMarkWithAttrs {
     type: string;
     [key: string]: unknown;
 }
-export type RenderMark = string | RenderMarkWithAttrs;
-export interface RenderElement {
-    type: 'textRun' | 'blockStart' | 'blockEnd' | 'voidInline' | 'voidBlock' | 'opaqueInlineAtom' | 'opaqueBlockAtom';
+export type RenderTreeMark = string | RenderTreeMarkWithAttrs;
+export type RenderTreeNodeKind = 'doc' | 'block' | 'textBlock' | 'list' | 'listItem' | 'columns' | 'column' | 'table' | 'tableRow' | 'tableCell' | 'text' | 'inlineAtom' | 'blockAtom' | 'inlineContainer';
+export interface RenderTreeNode {
+    kind: RenderTreeNodeKind;
+    nodeType: string;
+    docPos: number;
+    docSize: number;
+    attrs?: Record<string, unknown>;
+    marks?: RenderTreeMark[];
     text?: string;
-    marks?: RenderMark[];
-    nodeType?: string;
-    depth?: number;
-    docPos?: number;
     label?: string;
-    attrs?: Record<string, unknown>;
     mentionTheme?: EditorMentionTheme;
-    listContext?: ListContext;
+    children?: RenderTreeNode[];
+}
+export interface RenderTree {
+    version: number;
+    root: RenderTreeNode;
 }
-interface RenderBlocksPatch {
+export type RenderTreePatchOperation = {
+    type: 'updateMetadata';
+    path: number[];
+    docPos: number;
+    docSize: number;
+} | {
+    type: 'replaceNode';
+    path: number[];
+    node: RenderTreeNode;
+} | {
+    type: 'spliceChildren';
+    path: number[];
     startIndex: number;
     deleteCount: number;
-    renderBlocks: RenderElement[][];
+    children: RenderTreeNode[];
+};
+export interface RenderTreePatch {
+    version: number;
+    operations: RenderTreePatchOperation[];
 }
 export interface ActiveState {
     marks: Record<string, boolean>;
@@ -118,9 +137,10 @@ export interface HistoryState {
     canRedo: boolean;
 }
 export interface EditorUpdate {
-    renderElements: RenderElement[];
-    renderBlocks?: RenderElement[][];
-    renderPatch?: RenderBlocksPatch;
+    renderTree: RenderTree;
+    renderPatch?: RenderTreePatch;
+    /** Canonical flat IME snapshot; offsets match scalar selection fields. */
+    inputText: string;
     selection: Selection;
     activeState: ActiveState;
     historyState: HistoryState;
@@ -156,7 +176,8 @@ export interface CommandBlockedInfo {
 }
 export type EncodedCollaborationStateInput = Uint8Array | readonly number[] | string;
 export declare function normalizeActiveState(raw: unknown): ActiveState;
-export declare function parseEditorUpdateJson(json: string, previousRenderBlocks?: RenderElement[][]): EditorUpdate | null;
+export declare function parseEditorUpdateJson(json: string, previousRenderTree?: RenderTree): EditorUpdate | null;
+export declare function applyRenderTreePatch(tree: RenderTree, patch: RenderTreePatch): RenderTree;
 export declare function encodeCollaborationStateBase64(encodedState: EncodedCollaborationStateInput): string;
 export declare function decodeCollaborationStateBase64(base64: string): Uint8Array;
 export declare function parseCollaborationResultJson(json: string): CollaborationResult;
@@ -170,7 +191,7 @@ export declare class NativeEditorBridge {
     private _documentVersion;
     private _cachedHtml;
     private _cachedJsonString;
-    private _renderBlocksCache;
+    private _renderTreeCache;
     private _lastCommandBlocked;
     private _lastCommandBlockedReason;
     private _lastCommandPreflightUpdate;
@@ -194,16 +215,16 @@ export declare class NativeEditorBridge {
     prepareForNativeCommand(): boolean;
     /** Destroy the editor instance and free native resources. */
     destroy(): void;
-    /** Set content from HTML. Returns render elements for display. */
-    setHtml(html: string): RenderElement[];
+    /** Set content from HTML. Returns the structural editor state. */
+    setHtml(html: string): EditorUpdate | null;
     /** Get content as HTML. */
     getHtml(): string;
     /** Get cached HTML without making a native roundtrip. */
     getCachedHtml(): string | null;
-    /** Set content from ProseMirror JSON. Returns render elements. */
-    setJson(doc: DocumentJSON): RenderElement[];
-    /** Set content from a serialized ProseMirror JSON string. Returns render elements. */
-    setJsonString(jsonString: string): RenderElement[];
+    /** Set content from ProseMirror JSON. Returns the structural editor state. */
+    setJson(doc: DocumentJSON): EditorUpdate | null;
+    /** Set content from a serialized ProseMirror JSON string. Returns the structural editor state. */
+    setJsonString(jsonString: string): EditorUpdate | null;
     /** Get content as raw ProseMirror JSON string. */
     getJsonString(): string;
     /** Get cached raw ProseMirror JSON without making a native roundtrip. */
@@ -236,6 +257,8 @@ export declare class NativeEditorBridge {
     toggleHeading(level: number): EditorUpdate | null;
     /** Set the document selection by anchor and head positions. */
     setSelection(anchor: number, head: number): void;
+    /** Set a table cell selection by cell document positions. */
+    setCellSelection(anchor: number, head: number): void;
     /** Convert a document position to a scalar position used by native text views. */
     docToScalar(docPos: number): number;
     /** Convert a native scalar position back to a document position. */
@@ -282,6 +305,11 @@ export declare class NativeEditorBridge {
     indentListItem(): EditorUpdate | null;
     /** Outdent the current list item to the parent list level. */
     outdentListItem(): EditorUpdate | null;
+    insertTableRow(after?: boolean): EditorUpdate | null;
+    deleteTableRow(): EditorUpdate | null;
+    insertTableColumn(after?: boolean): EditorUpdate | null;
+    deleteTableColumn(): EditorUpdate | null;
+    moveTableCell(forward?: boolean): EditorUpdate | null;
     /** Insert a void node (e.g. 'horizontalRule') at the current selection. */
     insertNode(nodeType: string): EditorUpdate | null;
     parseUpdateJson(json: string, options?: ParseUpdateOptions): EditorUpdate | null;
@@ -322,4 +350,3 @@ export declare class NativeCollaborationBridge {
     clearLocalAwareness(): CollaborationResult;
     private assertNotDestroyed;
 }
-export {};

package/dist/NativeEditorBridge.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.NativeCollaborationBridge = exports.NativeEditorBridge = void 0;
 exports.normalizeActiveState = normalizeActiveState;
 exports.parseEditorUpdateJson = parseEditorUpdateJson;
+exports.applyRenderTreePatch = applyRenderTreePatch;
 exports.encodeCollaborationStateBase64 = encodeCollaborationStateBase64;
 exports.decodeCollaborationStateBase64 = decodeCollaborationStateBase64;
 exports.parseCollaborationResultJson = parseCollaborationResultJson;
@@ -25,30 +26,7 @@ function normalizeActiveState(raw) {
         insertableNodes: (obj.insertableNodes ?? []),
     };
 }
-function parseRenderElements(json) {
-    if (!json || json === '[]')
-        return [];
-    try {
-        const parsed = JSON.parse(json);
-        if (parsed != null &&
-            typeof parsed === 'object' &&
-            !Array.isArray(parsed) &&
-            'error' in parsed) {
-            throw new Error(`NativeEditorBridge: ${parsed.error}`);
-        }
-        if (!Array.isArray(parsed)) {
-            throw new Error(ERR_NATIVE_RESPONSE);
-        }
-        return parsed;
-    }
-    catch (e) {
-        if (e instanceof Error && e.message.startsWith('NativeEditorBridge:')) {
-            throw e;
-        }
-        throw new Error(ERR_NATIVE_RESPONSE);
-    }
-}
-function parseEditorUpdateJson(json, previousRenderBlocks) {
+function parseEditorUpdateJson(json, previousRenderTree) {
     if (!json || json === '')
         return null;
     try {
@@ -56,20 +34,21 @@ function parseEditorUpdateJson(json, previousRenderBlocks) {
         if ('error' in parsed) {
             throw new Error(`NativeEditorBridge: ${parsed.error}`);
         }
-        const renderBlocks = Array.isArray(parsed.renderBlocks)
-            ? parsed.renderBlocks
-            : applyRenderBlocksPatch(previousRenderBlocks, parsed.renderPatch != null && typeof parsed.renderPatch === 'object'
-                ? parsed.renderPatch
-                : undefined);
-        const renderPatch = parsed.renderPatch != null && typeof parsed.renderPatch === 'object'
-            ? parsed.renderPatch
+        const renderPatch = parsed.renderPatch != null
+            ? parseRenderTreePatch(parsed.renderPatch)
             : undefined;
+        const renderTree = parsed.renderTree != null
+            ? parseRenderTree(parsed.renderTree)
+            : previousRenderTree && renderPatch
+                ? applyRenderTreePatch(previousRenderTree, renderPatch)
+                : previousRenderTree;
+        if (!renderTree) {
+            throw new Error(ERR_NATIVE_RESPONSE);
+        }
         return {
-            renderElements: Array.isArray(parsed.renderElements)
-                ? parsed.renderElements
-                : flattenRenderBlocks(renderBlocks),
-            renderBlocks,
+            renderTree,
             renderPatch,
+            inputText: typeof parsed.inputText === 'string' ? parsed.inputText : '',
             selection: (parsed.selection ?? { type: 'text', anchor: 0, head: 0 }),
             activeState: normalizeActiveState(parsed.activeState),
             historyState: (parsed.historyState ?? {
@@ -86,30 +65,79 @@ function parseEditorUpdateJson(json, previousRenderBlocks) {
         throw new Error(ERR_NATIVE_RESPONSE);
     }
 }
-function flattenRenderBlocks(renderBlocks) {
-    if (!renderBlocks || renderBlocks.length === 0) {
-        return [];
+function parseRenderTreePatch(raw) {
+    if (raw == null || typeof raw !== 'object' || Array.isArray(raw)) {
+        throw new Error(ERR_NATIVE_RESPONSE);
     }
-    return renderBlocks.flat();
+    const candidate = raw;
+    if (typeof candidate.version !== 'number' || !Array.isArray(candidate.operations)) {
+        throw new Error(ERR_NATIVE_RESPONSE);
+    }
+    return candidate;
 }
-function applyRenderBlocksPatch(previousRenderBlocks, renderPatch) {
-    if (!previousRenderBlocks || !renderPatch) {
-        return undefined;
-    }
-    const { startIndex, deleteCount, renderBlocks } = renderPatch;
-    if (!Number.isInteger(startIndex) ||
-        !Number.isInteger(deleteCount) ||
-        startIndex < 0 ||
-        deleteCount < 0 ||
-        startIndex > previousRenderBlocks.length ||
-        startIndex + deleteCount > previousRenderBlocks.length) {
-        return undefined;
-    }
-    return [
-        ...previousRenderBlocks.slice(0, startIndex),
-        ...renderBlocks,
-        ...previousRenderBlocks.slice(startIndex + deleteCount),
-    ];
+function applyRenderTreePatch(tree, patch) {
+    let root = cloneRenderTreeNode(tree.root);
+    for (const operation of patch.operations) {
+        if (operation.type === 'replaceNode' && operation.path.length === 0) {
+            root = cloneRenderTreeNode(operation.node);
+            continue;
+        }
+        const target = resolveRenderTreeNode(root, operation.path);
+        if (!target)
+            throw new Error(ERR_NATIVE_RESPONSE);
+        switch (operation.type) {
+            case 'updateMetadata':
+                target.docPos = operation.docPos;
+                target.docSize = operation.docSize;
+                break;
+            case 'replaceNode': {
+                const parent = resolveRenderTreeNode(root, operation.path.slice(0, -1));
+                const index = operation.path[operation.path.length - 1];
+                if (!parent?.children || index == null || !parent.children[index]) {
+                    throw new Error(ERR_NATIVE_RESPONSE);
+                }
+                parent.children[index] = cloneRenderTreeNode(operation.node);
+                break;
+            }
+            case 'spliceChildren':
+                target.children ?? (target.children = []);
+                target.children.splice(operation.startIndex, operation.deleteCount, ...operation.children.map(cloneRenderTreeNode));
+                break;
+        }
+    }
+    return { version: tree.version, root };
+}
+function resolveRenderTreeNode(root, path) {
+    let current = root;
+    for (const index of path) {
+        const child = current.children?.[index];
+        if (!child)
+            return null;
+        current = child;
+    }
+    return current;
+}
+function cloneRenderTreeNode(node) {
+    return {
+        ...node,
+        ...(node.attrs ? { attrs: { ...node.attrs } } : {}),
+        ...(node.marks ? { marks: node.marks.map((mark) => typeof mark === 'string' ? mark : { ...mark }) } : {}),
+        ...(node.mentionTheme ? { mentionTheme: { ...node.mentionTheme } } : {}),
+        ...(node.children ? { children: node.children.map(cloneRenderTreeNode) } : {}),
+    };
+}
+function parseRenderTree(raw) {
+    if (raw == null || typeof raw !== 'object' || Array.isArray(raw)) {
+        throw new Error(ERR_NATIVE_RESPONSE);
+    }
+    const candidate = raw;
+    if (typeof candidate.version !== 'number' ||
+        candidate.root == null ||
+        typeof candidate.root !== 'object' ||
+        Array.isArray(candidate.root)) {
+        throw new Error(ERR_NATIVE_RESPONSE);
+    }
+    return candidate;
 }
 function parseContentSnapshotJson(json) {
     try {
@@ -321,7 +349,7 @@ class NativeEditorBridge {
         this._documentVersion = 0;
         this._cachedHtml = null;
         this._cachedJsonString = null;
-        this._renderBlocksCache = null;
+        this._renderTreeCache = null;
         this._lastCommandBlocked = false;
         this._lastCommandBlockedReason = null;
         this._lastCommandPreflightUpdate = null;
@@ -394,19 +422,18 @@ class NativeEditorBridge {
         if (this._destroyed)
             return;
         this._destroyed = true;
-        this._renderBlocksCache = null;
+        this._renderTreeCache = null;
         this._lastCommandBlocked = false;
         this._lastCommandBlockedReason = null;
         this._lastCommandPreflightUpdate = null;
         getNativeModule().editorDestroy(this._editorId);
     }
-    /** Set content from HTML. Returns render elements for display. */
+    /** Set content from HTML. Returns the structural editor state. */
     setHtml(html) {
         this.assertNotDestroyed();
         this.invalidateContentCaches();
-        this._renderBlocksCache = null;
-        const json = getNativeModule().editorSetHtml(this._editorId, html);
-        return parseRenderElements(json);
+        getNativeModule().editorSetHtml(this._editorId, html);
+        return this.getCurrentState();
     }
     /** Get content as HTML. */
     getHtml() {
@@ -423,18 +450,17 @@ class NativeEditorBridge {
         this.assertNotDestroyed();
         return this._cachedHtml?.value ?? null;
     }
-    /** Set content from ProseMirror JSON. Returns render elements. */
+    /** Set content from ProseMirror JSON. Returns the structural editor state. */
     setJson(doc) {
         return this.setJsonString(JSON.stringify((0, schemas_1.normalizeDocumentJson)(doc, this._schema)));
     }
-    /** Set content from a serialized ProseMirror JSON string. Returns render elements. */
+    /** Set content from a serialized ProseMirror JSON string. Returns the structural editor state. */
     setJsonString(jsonString) {
         this.assertNotDestroyed();
         this.invalidateContentCaches();
-        this._renderBlocksCache = null;
         const normalizedJsonString = normalizeDocumentJsonString(jsonString, this._schema);
-        const json = getNativeModule().editorSetJson(this._editorId, normalizedJsonString);
-        return parseRenderElements(json);
+        getNativeModule().editorSetJson(this._editorId, normalizedJsonString);
+        return this.getCurrentState();
     }
     /** Get content as raw ProseMirror JSON string. */
     getJsonString() {
@@ -563,6 +589,12 @@ class NativeEditorBridge {
         getNativeModule().editorSetSelection(this._editorId, anchor, head);
         this._lastSelection = { type: 'text', anchor, head };
     }
+    /** Set a table cell selection by cell document positions. */
+    setCellSelection(anchor, head) {
+        this.assertNotDestroyed();
+        getNativeModule().editorSetCellSelection?.(this._editorId, anchor, head);
+        this._lastSelection = { type: 'cell', anchor, head };
+    }
     /** Convert a document position to a scalar position used by native text views. */
     docToScalar(docPos) {
         this.assertNotDestroyed();
@@ -711,6 +743,26 @@ class NativeEditorBridge {
                 : getNativeModule().editorOutdentListItem(this._editorId);
         }, { refreshSelectionAfterPreflight: true });
     }
+    insertTableRow(after = true) {
+        this.assertNotDestroyed();
+        return this.runPreparedCommand(() => getNativeModule().editorInsertTableRow(this._editorId, after));
+    }
+    deleteTableRow() {
+        this.assertNotDestroyed();
+        return this.runPreparedCommand(() => getNativeModule().editorDeleteTableRow(this._editorId));
+    }
+    insertTableColumn(after = true) {
+        this.assertNotDestroyed();
+        return this.runPreparedCommand(() => getNativeModule().editorInsertTableColumn(this._editorId, after));
+    }
+    deleteTableColumn() {
+        this.assertNotDestroyed();
+        return this.runPreparedCommand(() => getNativeModule().editorDeleteTableColumn(this._editorId));
+    }
+    moveTableCell(forward = true) {
+        this.assertNotDestroyed();
+        return this.runPreparedCommand(() => getNativeModule().editorMoveTableCell(this._editorId, forward));
+    }
     /** Insert a void node (e.g. 'horizontalRule') at the current selection. */
     insertNode(nodeType) {
         this.assertNotDestroyed();
@@ -730,9 +782,7 @@ class NativeEditorBridge {
             return;
         }
         this._lastSelection = update.selection;
-        if (update.renderBlocks) {
-            this._renderBlocksCache = update.renderBlocks;
-        }
+        this._renderTreeCache = update.renderTree;
         if (typeof update.documentVersion !== 'number') {
             this.invalidateContentCaches();
             return;
@@ -765,17 +815,10 @@ class NativeEditorBridge {
         return false;
     }
     parseAndNoteUpdate(json, options) {
-        let update = parseEditorUpdateJson(json, this._renderBlocksCache ?? undefined);
+        const update = parseEditorUpdateJson(json, this._renderTreeCache ?? undefined);
         if (this.shouldRejectUpdate(update, json, options)) {
             return null;
         }
-        if (update?.renderPatch && !update.renderBlocks) {
-            json = getNativeModule().editorGetCurrentState(this._editorId);
-            update = parseEditorUpdateJson(json, this._renderBlocksCache ?? undefined);
-            if (this.shouldRejectUpdate(update, json, options)) {
-                return null;
-            }
-        }
         this.noteUpdate(update);
         if (update) {
             this._lastAcceptedUpdateJson = json;

package/dist/NativeProseViewer.d.ts

@@ -1,53 +1,32 @@
 import React from 'react';
 import { type StyleProp, type ViewStyle } from 'react-native';
-import { type EditorMentionTheme, type EditorTheme } from './EditorTheme';
+import type { EditorTheme } from './EditorTheme';
 import type { DocumentJSON } from './NativeEditorBridge';
 import { type SchemaDefinition } from './schemas';
-export interface NativeProseViewerMentionRenderContext {
-    docPos: number;
-    label: string;
-    attrs: Record<string, unknown>;
-}
-export interface NativeProseViewerMentionPressEvent extends NativeProseViewerMentionRenderContext {
-}
-export interface NativeProseViewerLinkPressEvent {
-    href: string;
-    text: string;
-}
-type NativeProseViewerContent = DocumentJSON | string;
-export type NativeProseViewerMentionPrefix = string | ((mention: NativeProseViewerMentionRenderContext) => string | null | undefined);
-export interface NativeProseViewerMentionsAddonConfig {
-    trigger?: string;
-    prefix?: NativeProseViewerMentionPrefix;
-    theme?: EditorMentionTheme;
-    resolveTheme?: (mention: NativeProseViewerMentionRenderContext) => EditorMentionTheme | null | undefined;
-    onPress?: (event: NativeProseViewerMentionPressEvent) => void;
-}
-export interface NativeProseViewerAddons {
-    mentions?: NativeProseViewerMentionsAddonConfig;
-}
 interface NativeProseViewerBaseProps {
-    contentRevision?: string | number;
-    contentJSONRevision?: string | number;
+    revision?: string | number;
     schema?: SchemaDefinition;
     theme?: EditorTheme;
     style?: StyleProp<ViewStyle>;
     allowBase64Images?: boolean;
-    collapseTrailingEmptyParagraphs?: boolean;
-    enableLinkTaps?: boolean;
-    addons?: NativeProseViewerAddons;
-    onPressLink?: (event: NativeProseViewerLinkPressEvent) => void;
-    contentId?: string;
-    containerWidth?: number;
 }
 interface NativeProseViewerJsonProps extends NativeProseViewerBaseProps {
-    contentJSON: NativeProseViewerContent;
+    contentJSON: DocumentJSON | string;
     contentHTML?: never;
+    collapseWhenEmpty?: boolean;
 }
 interface NativeProseViewerHtmlProps extends NativeProseViewerBaseProps {
     contentHTML: string;
     contentJSON?: never;
 }
 export type NativeProseViewerProps = NativeProseViewerJsonProps | NativeProseViewerHtmlProps;
-export declare function NativeProseViewer({ ...props }: NativeProseViewerProps): React.JSX.Element;
+/**
+ * Read-only presentation of the canonical block-editor surface.
+ *
+ * The viewer deliberately shares the editor's document parser, render tree,
+ * layout surface, theme implementation, and native views. Keeping it as a
+ * configured editor prevents the read-only product from becoming a second
+ * rendering engine with subtly different schema behavior.
+ */
+export declare function NativeProseViewer(props: NativeProseViewerProps): React.JSX.Element;
 export {};