@apollohg/react-native-prose-editor 0.1.1 → 0.3.0

package/dist/EditorToolbar.js

@@ -0,0 +1,394 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_EDITOR_TOOLBAR_ITEMS = void 0;
+exports.EditorToolbar = EditorToolbar;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const vector_icons_1 = require("@expo/vector-icons");
+const react_1 = require("react");
+const react_native_1 = require("react-native");
+function defaultIcon(id) {
+    return { type: 'default', id };
+}
+exports.DEFAULT_EDITOR_TOOLBAR_ITEMS = [
+    { type: 'mark', mark: 'bold', label: 'Bold', icon: defaultIcon('bold') },
+    { type: 'mark', mark: 'italic', label: 'Italic', icon: defaultIcon('italic') },
+    { type: 'mark', mark: 'underline', label: 'Underline', icon: defaultIcon('underline') },
+    { type: 'mark', mark: 'strike', label: 'Strikethrough', icon: defaultIcon('strike') },
+    { type: 'blockquote', label: 'Blockquote', icon: defaultIcon('blockquote') },
+    { type: 'separator' },
+    { type: 'list', listType: 'bulletList', label: 'Bullet List', icon: defaultIcon('bulletList') },
+    {
+        type: 'list',
+        listType: 'orderedList',
+        label: 'Ordered List',
+        icon: defaultIcon('orderedList'),
+    },
+    {
+        type: 'command',
+        command: 'indentList',
+        label: 'Indent List',
+        icon: defaultIcon('indentList'),
+    },
+    {
+        type: 'command',
+        command: 'outdentList',
+        label: 'Outdent List',
+        icon: defaultIcon('outdentList'),
+    },
+    { type: 'node', nodeType: 'hardBreak', label: 'Line Break', icon: defaultIcon('lineBreak') },
+    {
+        type: 'node',
+        nodeType: 'horizontalRule',
+        label: 'Horizontal Rule',
+        icon: defaultIcon('horizontalRule'),
+    },
+    { type: 'separator' },
+    { type: 'command', command: 'undo', label: 'Undo', icon: defaultIcon('undo') },
+    { type: 'command', command: 'redo', label: 'Redo', icon: defaultIcon('redo') },
+];
+const BUTTON_HIT = 44;
+const BUTTON_VISIBLE = 32;
+const TOOLBAR_PADDING_H = 12;
+const TOOLBAR_PADDING_V = 4;
+const ACTIVE_BG = 'rgba(0, 122, 255, 0.12)';
+const ACTIVE_COLOR = '#007AFF';
+const DEFAULT_COLOR = '#666666';
+const DISABLED_COLOR = '#C7C7CC';
+const SEPARATOR_COLOR = '#E5E5EA';
+const TOOLBAR_BG = '#FFFFFF';
+const TOOLBAR_BORDER = '#E5E5EA';
+const TOOLBAR_RADIUS = 0;
+const BUTTON_RADIUS = 6;
+const DEFAULT_GLYPH_ICONS = {
+    bold: 'B',
+    italic: 'I',
+    underline: 'U',
+    strike: 'S',
+    link: '🔗',
+    image: '🖼',
+    blockquote: '❝',
+    bulletList: '•≡',
+    orderedList: '1.',
+    indentList: '→',
+    outdentList: '←',
+    lineBreak: '↵',
+    horizontalRule: '—',
+    undo: '↩',
+    redo: '↪',
+};
+const DEFAULT_MATERIAL_ICONS = {
+    bold: 'format-bold',
+    italic: 'format-italic',
+    underline: 'format-underlined',
+    strike: 'strikethrough-s',
+    link: 'link',
+    image: 'image',
+    blockquote: 'format-quote',
+    bulletList: 'format-list-bulleted',
+    orderedList: 'format-list-numbered',
+    indentList: 'format-indent-increase',
+    outdentList: 'format-indent-decrease',
+    lineBreak: 'keyboard-return',
+    horizontalRule: 'horizontal-rule',
+    undo: 'undo',
+    redo: 'redo',
+};
+function EditorToolbar({ activeState, historyState, onToggleBold, onToggleItalic, onToggleUnderline, onToggleStrike, onToggleBulletList, onToggleBlockquote, onToggleOrderedList, onIndentList, onOutdentList, onInsertHorizontalRule, onInsertLineBreak, onUndo, onRedo, onToggleMark, onToggleListType, onInsertNodeType, onRunCommand, onToolbarAction, onRequestLink, onRequestImage, toolbarItems = exports.DEFAULT_EDITOR_TOOLBAR_ITEMS, theme, showTopBorder = true, }) {
+    const marks = activeState.marks ?? {};
+    const nodes = activeState.nodes ?? {};
+    const commands = activeState.commands ?? {};
+    const allowedMarks = activeState.allowedMarks ?? [];
+    const insertableNodes = activeState.insertableNodes ?? [];
+    const isMarkActive = (0, react_1.useCallback)((mark) => !!marks[mark], [marks]);
+    const isInList = !!nodes['bulletList'] || !!nodes['orderedList'];
+    const canIndentList = isInList && !!commands['indentList'];
+    const canOutdentList = isInList && !!commands['outdentList'];
+    const getActionForItem = (0, react_1.useCallback)((item) => {
+        switch (item.type) {
+            case 'separator':
+                return null;
+            case 'mark':
+                if (onToggleMark) {
+                    return () => onToggleMark(item.mark);
+                }
+                switch (item.mark) {
+                    case 'bold':
+                        return onToggleBold;
+                    case 'italic':
+                        return onToggleItalic;
+                    case 'underline':
+                        return onToggleUnderline;
+                    case 'strike':
+                        return onToggleStrike;
+                    default:
+                        return null;
+                }
+            case 'list':
+                if (onToggleListType) {
+                    return () => onToggleListType(item.listType);
+                }
+                return item.listType === 'bulletList'
+                    ? (onToggleBulletList ?? null)
+                    : (onToggleOrderedList ?? null);
+            case 'link':
+                return onRequestLink ?? null;
+            case 'image':
+                return onRequestImage ?? null;
+            case 'blockquote':
+                return onToggleBlockquote ?? null;
+            case 'node':
+                if (onInsertNodeType) {
+                    return () => onInsertNodeType(item.nodeType);
+                }
+                switch (item.nodeType) {
+                    case 'hardBreak':
+                        return onInsertLineBreak ?? null;
+                    case 'horizontalRule':
+                        return onInsertHorizontalRule ?? null;
+                    default:
+                        return null;
+                }
+            case 'command':
+                if (onRunCommand) {
+                    return () => onRunCommand(item.command);
+                }
+                switch (item.command) {
+                    case 'indentList':
+                        return onIndentList ?? null;
+                    case 'outdentList':
+                        return onOutdentList ?? null;
+                    case 'undo':
+                        return onUndo;
+                    case 'redo':
+                        return onRedo;
+                }
+            case 'action':
+                return onToolbarAction ? () => onToolbarAction(item.key) : null;
+        }
+    }, [
+        onIndentList,
+        onInsertHorizontalRule,
+        onInsertLineBreak,
+        onInsertNodeType,
+        onOutdentList,
+        onRedo,
+        onRunCommand,
+        onRequestLink,
+        onRequestImage,
+        onToolbarAction,
+        onToggleBold,
+        onToggleBlockquote,
+        onToggleBulletList,
+        onToggleItalic,
+        onToggleListType,
+        onToggleMark,
+        onToggleOrderedList,
+        onToggleStrike,
+        onToggleUnderline,
+        onUndo,
+    ]);
+    const makeButtonKey = (0, react_1.useCallback)((item, index) => item.key ??
+        (item.type === 'mark'
+            ? `mark:${item.mark}:${index}`
+            : item.type === 'link'
+                ? `link:${index}`
+                : item.type === 'image'
+                    ? `image:${index}`
+                    : item.type === 'blockquote'
+                        ? `blockquote:${index}`
+                        : item.type === 'list'
+                            ? `list:${item.listType}:${index}`
+                            : item.type === 'command'
+                                ? `command:${item.command}:${index}`
+                                : item.type === 'node'
+                                    ? `node:${item.nodeType}:${index}`
+                                    : `action:${item.key}:${index}`), []);
+    const renderedItems = [];
+    for (let index = 0; index < toolbarItems.length; index += 1) {
+        const item = toolbarItems[index];
+        if (item.type === 'separator') {
+            renderedItems.push({
+                type: 'separator',
+                key: item.key ?? `separator:${index}`,
+            });
+            continue;
+        }
+        const action = getActionForItem(item);
+        if (!action) {
+            continue;
+        }
+        let isActive = false;
+        let isDisabled = false;
+        switch (item.type) {
+            case 'mark':
+                isActive = isMarkActive(item.mark);
+                isDisabled = !allowedMarks.includes(item.mark);
+                break;
+            case 'link':
+                isActive = isMarkActive('link');
+                isDisabled = !allowedMarks.includes('link') || !onRequestLink;
+                break;
+            case 'image':
+                isDisabled = !insertableNodes.includes('image') || !onRequestImage;
+                break;
+            case 'blockquote':
+                isActive = !!nodes['blockquote'];
+                isDisabled = !commands['toggleBlockquote'];
+                break;
+            case 'list':
+                isActive = !!nodes[item.listType];
+                isDisabled =
+                    !commands[item.listType === 'bulletList' ? 'wrapBulletList' : 'wrapOrderedList'];
+                break;
+            case 'command':
+                switch (item.command) {
+                    case 'indentList':
+                        isDisabled = !canIndentList;
+                        break;
+                    case 'outdentList':
+                        isDisabled = !canOutdentList;
+                        break;
+                    case 'undo':
+                        isDisabled = !historyState.canUndo;
+                        break;
+                    case 'redo':
+                        isDisabled = !historyState.canRedo;
+                        break;
+                }
+                break;
+            case 'action':
+                isActive = !!item.isActive;
+                isDisabled = !!item.isDisabled || !onToolbarAction;
+                break;
+            case 'node':
+                isActive = !!nodes[item.nodeType];
+                isDisabled = !insertableNodes.includes(item.nodeType);
+                break;
+        }
+        renderedItems.push({
+            type: 'button',
+            button: {
+                key: makeButtonKey(item, index),
+                label: item.label,
+                icon: item.icon,
+                action,
+                isActive,
+                isDisabled,
+            },
+        });
+    }
+    const compactItems = renderedItems.filter((entry, index, list) => {
+        if (entry.type !== 'separator') {
+            return true;
+        }
+        const previous = list[index - 1];
+        const next = list[index + 1];
+        return previous?.type === 'button' && next?.type === 'button';
+    });
+    const renderButton = ({ key, label, icon, action, isActive, isDisabled }) => {
+        const activeColor = theme?.buttonActiveColor ?? ACTIVE_COLOR;
+        const defaultColor = theme?.buttonColor ?? DEFAULT_COLOR;
+        const disabledColor = theme?.buttonDisabledColor ?? DISABLED_COLOR;
+        const color = isActive ? activeColor : isDisabled ? disabledColor : defaultColor;
+        return ((0, jsx_runtime_1.jsx)(react_native_1.TouchableOpacity, { onPress: action, disabled: isDisabled, style: [
+                styles.button,
+                {
+                    borderRadius: theme?.buttonBorderRadius ?? BUTTON_RADIUS,
+                },
+                isActive && {
+                    backgroundColor: theme?.buttonActiveBackgroundColor ?? ACTIVE_BG,
+                },
+            ], activeOpacity: 0.5, accessibilityRole: 'button', accessibilityLabel: label, accessibilityState: { selected: isActive, disabled: isDisabled }, children: (0, jsx_runtime_1.jsx)(react_native_1.View, { children: (0, jsx_runtime_1.jsx)(ToolbarIcon, { icon: icon, color: color }) }) }, key));
+    };
+    const renderSeparator = (key) => ((0, jsx_runtime_1.jsx)(react_native_1.View, { style: [
+            styles.separator,
+            theme?.separatorColor != null ? { backgroundColor: theme.separatorColor } : null,
+        ] }, key));
+    return ((0, jsx_runtime_1.jsx)(react_native_1.View, { style: [
+            styles.container,
+            !showTopBorder && styles.containerWithoutTopBorder,
+            theme?.backgroundColor != null ? { backgroundColor: theme.backgroundColor } : null,
+            theme?.borderColor != null
+                ? showTopBorder
+                    ? { borderTopColor: theme.borderColor }
+                    : null
+                : null,
+            theme?.borderWidth != null
+                ? showTopBorder
+                    ? { borderTopWidth: theme.borderWidth }
+                    : null
+                : null,
+            {
+                borderRadius: theme?.borderRadius ?? TOOLBAR_RADIUS,
+            },
+        ], children: (0, jsx_runtime_1.jsx)(react_native_1.ScrollView, { horizontal: true, showsHorizontalScrollIndicator: false, contentContainerStyle: styles.scrollContent, keyboardShouldPersistTaps: 'always', children: compactItems.map((item) => item.type === 'separator'
+                ? renderSeparator(item.key)
+                : renderButton(item.button)) }) }));
+}
+function ToolbarIcon({ icon, color }) {
+    const materialIconName = resolveMaterialIconName(icon);
+    if (materialIconName) {
+        return ((0, jsx_runtime_1.jsx)(react_native_1.View, { style: styles.iconContainer, children: (0, jsx_runtime_1.jsx)(vector_icons_1.MaterialIcons, { name: materialIconName, size: 20, color: color }) }));
+    }
+    const glyph = resolveGlyphText(icon) ?? '?';
+    return ((0, jsx_runtime_1.jsx)(react_native_1.View, { style: styles.iconContainer, children: (0, jsx_runtime_1.jsx)(react_native_1.Text, { style: [styles.iconText, { color }], children: glyph }) }));
+}
+function resolveMaterialIconName(icon) {
+    switch (icon.type) {
+        case 'default':
+            return DEFAULT_MATERIAL_ICONS[icon.id];
+        case 'platform':
+            return icon.android?.type === 'material' ? icon.android.name : undefined;
+        case 'glyph':
+            return undefined;
+    }
+}
+function resolveGlyphText(icon) {
+    switch (icon.type) {
+        case 'default':
+            return DEFAULT_GLYPH_ICONS[icon.id];
+        case 'glyph':
+            return icon.text;
+        case 'platform':
+            return icon.fallbackText;
+    }
+}
+const styles = react_native_1.StyleSheet.create({
+    container: {
+        backgroundColor: TOOLBAR_BG,
+        borderTopWidth: react_native_1.StyleSheet.hairlineWidth,
+        borderTopColor: TOOLBAR_BORDER,
+        paddingVertical: TOOLBAR_PADDING_V,
+        overflow: 'hidden',
+    },
+    containerWithoutTopBorder: {
+        borderTopWidth: 0,
+    },
+    scrollContent: {
+        flexDirection: 'row',
+        alignItems: 'center',
+        paddingHorizontal: TOOLBAR_PADDING_H,
+        minWidth: '100%',
+    },
+    button: {
+        width: BUTTON_HIT,
+        height: BUTTON_VISIBLE,
+        justifyContent: 'center',
+        alignItems: 'center',
+        borderRadius: BUTTON_RADIUS,
+    },
+    separator: {
+        width: react_native_1.StyleSheet.hairlineWidth,
+        height: 20,
+        marginHorizontal: 4,
+        backgroundColor: SEPARATOR_COLOR,
+    },
+    iconContainer: {
+        justifyContent: 'center',
+        alignItems: 'center',
+    },
+    iconText: {
+        fontSize: 16,
+        fontWeight: '600',
+    },
+});

package/dist/NativeEditorBridge.d.ts

@@ -0,0 +1,242 @@
+export interface NativeEditorModule {
+    editorCreate(configJson: string): number;
+    editorDestroy(editorId: number): void;
+    collaborationSessionCreate(configJson: string): number;
+    collaborationSessionDestroy(sessionId: number): void;
+    collaborationSessionGetDocumentJson(sessionId: number): string;
+    collaborationSessionGetEncodedState(sessionId: number): string;
+    collaborationSessionGetPeersJson(sessionId: number): string;
+    collaborationSessionStart(sessionId: number): string;
+    collaborationSessionApplyLocalDocumentJson(sessionId: number, json: string): string;
+    collaborationSessionApplyEncodedState(sessionId: number, encodedStateJson: string): string;
+    collaborationSessionReplaceEncodedState(sessionId: number, encodedStateJson: string): string;
+    collaborationSessionHandleMessage(sessionId: number, messageJson: string): string;
+    collaborationSessionSetLocalAwareness(sessionId: number, awarenessJson: string): string;
+    collaborationSessionClearLocalAwareness(sessionId: number): string;
+    editorSetHtml(editorId: number, html: string): string;
+    editorGetHtml(editorId: number): string;
+    editorSetJson(editorId: number, json: string): string;
+    editorGetJson(editorId: number): string;
+    editorReplaceHtml(editorId: number, html: string): string;
+    editorReplaceJson(editorId: number, json: string): string;
+    editorInsertText(editorId: number, pos: number, text: string): string;
+    editorReplaceSelectionText(editorId: number, text: string): string;
+    editorDeleteRange(editorId: number, from: number, to: number): string;
+    editorSplitBlock(editorId: number, pos: number): string;
+    editorInsertContentHtml(editorId: number, html: string): string;
+    editorInsertContentJson(editorId: number, json: string): string;
+    editorInsertContentJsonAtSelectionScalar(editorId: number, scalarAnchor: number, scalarHead: number, json: string): string;
+    editorToggleMark(editorId: number, markName: string): string;
+    editorSetMark(editorId: number, markName: string, attrsJson: string): string;
+    editorUnsetMark(editorId: number, markName: string): string;
+    editorToggleBlockquote(editorId: number): string;
+    editorSetSelection(editorId: number, anchor: number, head: number): void;
+    editorGetSelection(editorId: number): string;
+    editorGetCurrentState(editorId: number): string;
+    editorInsertTextScalar(editorId: number, scalarPos: number, text: string): string;
+    editorDeleteScalarRange(editorId: number, scalarFrom: number, scalarTo: number): string;
+    editorReplaceTextScalar(editorId: number, scalarFrom: number, scalarTo: number, text: string): string;
+    editorSplitBlockScalar(editorId: number, scalarPos: number): string;
+    editorDeleteAndSplitScalar(editorId: number, scalarFrom: number, scalarTo: number): string;
+    editorSetSelectionScalar(editorId: number, scalarAnchor: number, scalarHead: number): void;
+    editorToggleMarkAtSelectionScalar(editorId: number, scalarAnchor: number, scalarHead: number, markName: string): string;
+    editorSetMarkAtSelectionScalar(editorId: number, scalarAnchor: number, scalarHead: number, markName: string, attrsJson: string): string;
+    editorUnsetMarkAtSelectionScalar(editorId: number, scalarAnchor: number, scalarHead: number, markName: string): string;
+    editorToggleBlockquoteAtSelectionScalar(editorId: number, scalarAnchor: number, scalarHead: number): string;
+    editorWrapInListAtSelectionScalar(editorId: number, scalarAnchor: number, scalarHead: number, listType: string): string;
+    editorUnwrapFromListAtSelectionScalar(editorId: number, scalarAnchor: number, scalarHead: number): string;
+    editorIndentListItemAtSelectionScalar(editorId: number, scalarAnchor: number, scalarHead: number): string;
+    editorOutdentListItemAtSelectionScalar(editorId: number, scalarAnchor: number, scalarHead: number): string;
+    editorInsertNodeAtSelectionScalar(editorId: number, scalarAnchor: number, scalarHead: number, nodeType: string): string;
+    editorDocToScalar(editorId: number, docPos: number): number;
+    editorScalarToDoc(editorId: number, scalar: number): number;
+    editorWrapInList(editorId: number, listType: string): string;
+    editorUnwrapFromList(editorId: number): string;
+    editorIndentListItem(editorId: number): string;
+    editorOutdentListItem(editorId: number): string;
+    editorInsertNode(editorId: number, nodeType: string): string;
+    editorUndo(editorId: number): string;
+    editorRedo(editorId: number): string;
+    editorCanUndo(editorId: number): boolean;
+    editorCanRedo(editorId: number): boolean;
+}
+export interface Selection {
+    type: 'text' | 'node' | 'all';
+    anchor?: number;
+    head?: number;
+    pos?: number;
+}
+export interface ListContext {
+    ordered: boolean;
+    index: number;
+    total: number;
+    start: number;
+    isFirst: boolean;
+    isLast: boolean;
+}
+export interface RenderMarkWithAttrs {
+    type: string;
+    [key: string]: unknown;
+}
+export type RenderMark = string | RenderMarkWithAttrs;
+export interface RenderElement {
+    type: 'textRun' | 'blockStart' | 'blockEnd' | 'voidInline' | 'voidBlock' | 'opaqueInlineAtom' | 'opaqueBlockAtom';
+    text?: string;
+    marks?: RenderMark[];
+    nodeType?: string;
+    depth?: number;
+    docPos?: number;
+    label?: string;
+    attrs?: Record<string, unknown>;
+    listContext?: ListContext;
+}
+export interface ActiveState {
+    marks: Record<string, boolean>;
+    markAttrs: Record<string, Record<string, unknown>>;
+    nodes: Record<string, boolean>;
+    commands: Record<string, boolean>;
+    allowedMarks: string[];
+    insertableNodes: string[];
+}
+export interface HistoryState {
+    canUndo: boolean;
+    canRedo: boolean;
+}
+export interface EditorUpdate {
+    renderElements: RenderElement[];
+    selection: Selection;
+    activeState: ActiveState;
+    historyState: HistoryState;
+}
+export interface DocumentJSON {
+    [key: string]: unknown;
+}
+export interface CollaborationPeer {
+    clientId: number;
+    isLocal: boolean;
+    state: Record<string, unknown> | null;
+}
+export interface CollaborationResult {
+    messages: number[][];
+    documentChanged: boolean;
+    documentJson?: DocumentJSON;
+    peersChanged: boolean;
+    peers?: CollaborationPeer[];
+}
+export type EncodedCollaborationStateInput = Uint8Array | readonly number[] | string;
+export declare function normalizeActiveState(raw: unknown): ActiveState;
+export declare function parseEditorUpdateJson(json: string): EditorUpdate | null;
+export declare function encodeCollaborationStateBase64(encodedState: EncodedCollaborationStateInput): string;
+export declare function decodeCollaborationStateBase64(base64: string): Uint8Array;
+export declare function parseCollaborationResultJson(json: string): CollaborationResult;
+/** @internal Reset the cached native module reference. For testing only. */
+export declare function _resetNativeModuleCache(): void;
+export declare class NativeEditorBridge {
+    private _editorId;
+    private _destroyed;
+    private _lastSelection;
+    private constructor();
+    /** Create a new editor instance backed by the Rust engine. */
+    static create(config?: {
+        maxLength?: number;
+        schemaJson?: string;
+        allowBase64Images?: boolean;
+    }): NativeEditorBridge;
+    /** The underlying native editor ID. */
+    get editorId(): number;
+    /** Whether this bridge has been destroyed. */
+    get isDestroyed(): boolean;
+    /** Destroy the editor instance and free native resources. */
+    destroy(): void;
+    /** Set content from HTML. Returns render elements for display. */
+    setHtml(html: string): RenderElement[];
+    /** Get content as HTML. */
+    getHtml(): string;
+    /** Set content from ProseMirror JSON. Returns render elements. */
+    setJson(doc: DocumentJSON): RenderElement[];
+    /** Get content as ProseMirror JSON. */
+    getJson(): DocumentJSON;
+    /** Insert text at a document position. Returns the full update. */
+    insertText(pos: number, text: string): EditorUpdate | null;
+    /** Delete a range [from, to). Returns the full update. */
+    deleteRange(from: number, to: number): EditorUpdate | null;
+    /** Replace the current selection with text atomically. */
+    replaceSelectionText(text: string): EditorUpdate | null;
+    /** Toggle a mark (bold, italic, etc.) on the current selection. */
+    toggleMark(markType: string): EditorUpdate | null;
+    /** Set a mark with attrs on the current selection. */
+    setMark(markType: string, attrs: Record<string, unknown>): EditorUpdate | null;
+    /** Remove a mark from the current selection. */
+    unsetMark(markType: string): EditorUpdate | null;
+    /** Toggle blockquote wrapping for the current block selection. */
+    toggleBlockquote(): EditorUpdate | null;
+    /** Set the document selection by anchor and head positions. */
+    setSelection(anchor: number, head: number): void;
+    /** Get the current selection from the Rust engine (synchronous native call).
+     *  Always returns the live selection, not a stale cache. */
+    getSelection(): Selection;
+    /** Update the cached selection from native events (scalar offsets).
+     *  Called by the React component when native selection change events arrive. */
+    updateSelectionFromNative(anchor: number, head: number): void;
+    /** Get the current full state from Rust (render elements, selection, etc.). */
+    getCurrentState(): EditorUpdate | null;
+    /** Split the block at a position (Enter key). */
+    splitBlock(pos: number): EditorUpdate | null;
+    /** Insert HTML content at the current selection. */
+    insertContentHtml(html: string): EditorUpdate | null;
+    /** Insert JSON content at the current selection. */
+    insertContentJson(doc: DocumentJSON): EditorUpdate | null;
+    /** Insert JSON content at an explicit scalar selection. */
+    insertContentJsonAtSelectionScalar(scalarAnchor: number, scalarHead: number, doc: DocumentJSON): EditorUpdate | null;
+    /** Replace entire document with HTML via transaction (preserves undo history). */
+    replaceHtml(html: string): EditorUpdate | null;
+    /** Replace entire document with JSON via transaction (preserves undo history). */
+    replaceJson(doc: DocumentJSON): EditorUpdate | null;
+    /** Undo the last operation. Returns update or null if nothing to undo. */
+    undo(): EditorUpdate | null;
+    /** Redo the last undone operation. Returns update or null if nothing to redo. */
+    redo(): EditorUpdate | null;
+    /** Check if undo is available. */
+    canUndo(): boolean;
+    /** Check if redo is available. */
+    canRedo(): boolean;
+    /** Toggle a list type on the current selection. Wraps if not in list, unwraps if already in that list type. */
+    toggleList(listType: string): EditorUpdate | null;
+    /** Unwrap the current list item back to a paragraph. */
+    unwrapFromList(): EditorUpdate | null;
+    /** Indent the current list item into a nested list. */
+    indentListItem(): EditorUpdate | null;
+    /** Outdent the current list item to the parent list level. */
+    outdentListItem(): EditorUpdate | null;
+    /** Insert a void node (e.g. 'horizontalRule') at the current selection. */
+    insertNode(nodeType: string): EditorUpdate | null;
+    private assertNotDestroyed;
+    private currentScalarSelection;
+}
+export declare class NativeCollaborationBridge {
+    private _sessionId;
+    private _destroyed;
+    private constructor();
+    static create(config?: {
+        clientId?: number;
+        fragmentName?: string;
+        initialDocumentJson?: DocumentJSON;
+        initialEncodedState?: EncodedCollaborationStateInput;
+        localAwareness?: Record<string, unknown>;
+    }): NativeCollaborationBridge;
+    get sessionId(): number;
+    get isDestroyed(): boolean;
+    destroy(): void;
+    getDocumentJson(): DocumentJSON;
+    getEncodedState(): Uint8Array;
+    getEncodedStateBase64(): string;
+    getPeers(): CollaborationPeer[];
+    start(): CollaborationResult;
+    applyLocalDocumentJson(doc: DocumentJSON): CollaborationResult;
+    applyEncodedState(encodedState: EncodedCollaborationStateInput): CollaborationResult;
+    replaceEncodedState(encodedState: EncodedCollaborationStateInput): CollaborationResult;
+    handleMessage(bytes: readonly number[]): CollaborationResult;
+    setLocalAwareness(state: Record<string, unknown>): CollaborationResult;
+    clearLocalAwareness(): CollaborationResult;
+    private assertNotDestroyed;
+}