@openeditor/react-native-prose-editor 0.0.2

package/dist/NativeEditorBridge.js

@@ -0,0 +1,933 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NativeCollaborationBridge = exports.NativeEditorBridge = void 0;
+exports.normalizeActiveState = normalizeActiveState;
+exports.parseEditorUpdateJson = parseEditorUpdateJson;
+exports.encodeCollaborationStateBase64 = encodeCollaborationStateBase64;
+exports.decodeCollaborationStateBase64 = decodeCollaborationStateBase64;
+exports.parseCollaborationResultJson = parseCollaborationResultJson;
+exports._resetNativeModuleCache = _resetNativeModuleCache;
+const expo_modules_core_1 = require("expo-modules-core");
+const react_native_1 = require("react-native");
+const schemas_1 = require("./schemas");
+const ERR_DESTROYED = 'NativeEditorBridge: editor has been destroyed';
+const ERR_NATIVE_RESPONSE = 'NativeEditorBridge: invalid JSON response from native module';
+const ERR_INVALID_ENCODED_STATE = 'NativeEditorBridge: invalid encoded collaboration state';
+const BASE64_ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+function normalizeActiveState(raw) {
+    const obj = raw ?? {};
+    return {
+        marks: (obj.marks ?? {}),
+        markAttrs: (obj.markAttrs ?? {}),
+        nodes: (obj.nodes ?? {}),
+        commands: (obj.commands ?? {}),
+        allowedMarks: (obj.allowedMarks ?? []),
+        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) {
+    if (!json || json === '')
+        return null;
+    try {
+        const parsed = JSON.parse(json);
+        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
+            : undefined;
+        return {
+            renderElements: Array.isArray(parsed.renderElements)
+                ? parsed.renderElements
+                : flattenRenderBlocks(renderBlocks),
+            renderBlocks,
+            renderPatch,
+            selection: (parsed.selection ?? { type: 'text', anchor: 0, head: 0 }),
+            activeState: normalizeActiveState(parsed.activeState),
+            historyState: (parsed.historyState ?? {
+                canUndo: false,
+                canRedo: false,
+            }),
+            documentVersion: typeof parsed.documentVersion === 'number' ? parsed.documentVersion : undefined,
+        };
+    }
+    catch (e) {
+        if (e instanceof Error && e.message.startsWith('NativeEditorBridge:')) {
+            throw e;
+        }
+        throw new Error(ERR_NATIVE_RESPONSE);
+    }
+}
+function flattenRenderBlocks(renderBlocks) {
+    if (!renderBlocks || renderBlocks.length === 0) {
+        return [];
+    }
+    return renderBlocks.flat();
+}
+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 parseContentSnapshotJson(json) {
+    try {
+        const parsed = JSON.parse(json);
+        if ('error' in parsed) {
+            throw new Error(`NativeEditorBridge: ${parsed.error}`);
+        }
+        return {
+            html: typeof parsed.html === 'string' ? parsed.html : '',
+            json: parsed.json != null && typeof parsed.json === 'object'
+                ? parsed.json
+                : {},
+        };
+    }
+    catch (e) {
+        if (e instanceof Error && e.message.startsWith('NativeEditorBridge:')) {
+            throw e;
+        }
+        throw new Error(ERR_NATIVE_RESPONSE);
+    }
+}
+function parseDocumentJSON(json) {
+    if (!json || json === '{}')
+        return {};
+    try {
+        const parsed = JSON.parse(json);
+        if (parsed != null &&
+            typeof parsed === 'object' &&
+            'error' in parsed) {
+            throw new Error(`NativeEditorBridge: ${parsed.error}`);
+        }
+        return parsed;
+    }
+    catch (e) {
+        if (e instanceof Error && e.message.startsWith('NativeEditorBridge:')) {
+            throw e;
+        }
+        throw new Error(ERR_NATIVE_RESPONSE);
+    }
+}
+function parseCollaborationPeersJson(json) {
+    if (!json || json === '[]')
+        return [];
+    try {
+        const parsed = JSON.parse(json);
+        return Array.isArray(parsed) ? parsed : [];
+    }
+    catch {
+        throw new Error(ERR_NATIVE_RESPONSE);
+    }
+}
+function parseByteArrayJson(json) {
+    if (!json || json === '[]')
+        return new Uint8Array();
+    try {
+        const parsed = JSON.parse(json);
+        if (!Array.isArray(parsed)) {
+            throw new Error(ERR_NATIVE_RESPONSE);
+        }
+        return Uint8Array.from(parsed);
+    }
+    catch (e) {
+        if (e instanceof Error && e.message.startsWith('NativeEditorBridge:')) {
+            throw e;
+        }
+        throw new Error(ERR_NATIVE_RESPONSE);
+    }
+}
+function bytesToBase64(bytes) {
+    let output = '';
+    for (let index = 0; index < bytes.length; index += 3) {
+        const byte1 = bytes[index] ?? 0;
+        const byte2 = bytes[index + 1] ?? 0;
+        const byte3 = bytes[index + 2] ?? 0;
+        const chunk = (byte1 << 16) | (byte2 << 8) | byte3;
+        output += BASE64_ALPHABET[(chunk >> 18) & 0x3f];
+        output += BASE64_ALPHABET[(chunk >> 12) & 0x3f];
+        output += index + 1 < bytes.length ? BASE64_ALPHABET[(chunk >> 6) & 0x3f] : '=';
+        output += index + 2 < bytes.length ? BASE64_ALPHABET[chunk & 0x3f] : '=';
+    }
+    return output;
+}
+function base64ToBytes(base64) {
+    const normalized = base64.replace(/\s+/g, '');
+    if (normalized.length === 0)
+        return new Uint8Array();
+    if (normalized.length % 4 === 1) {
+        throw new Error(ERR_INVALID_ENCODED_STATE);
+    }
+    const bytes = [];
+    for (let index = 0; index < normalized.length; index += 4) {
+        const chunk = normalized.slice(index, index + 4);
+        const values = chunk.split('').map((char, charIndex) => {
+            if (char === '=') {
+                return charIndex >= 2 ? 0 : -1;
+            }
+            const value = BASE64_ALPHABET.indexOf(char);
+            return value;
+        });
+        if (values[0] < 0 || values[1] < 0 || values.some((value) => value < 0)) {
+            throw new Error(ERR_INVALID_ENCODED_STATE);
+        }
+        const combined = (values[0] << 18) | (values[1] << 12) | (values[2] << 6) | values[3];
+        bytes.push((combined >> 16) & 0xff);
+        if (chunk[2] !== '=') {
+            bytes.push((combined >> 8) & 0xff);
+        }
+        if (chunk[3] !== '=') {
+            bytes.push(combined & 0xff);
+        }
+    }
+    return Uint8Array.from(bytes);
+}
+function normalizeEncodedStateInput(encodedState) {
+    if (typeof encodedState === 'string') {
+        return Array.from(base64ToBytes(encodedState));
+    }
+    return Array.from(encodedState);
+}
+function encodeCollaborationStateBase64(encodedState) {
+    return bytesToBase64(normalizeEncodedStateInput(encodedState));
+}
+function decodeCollaborationStateBase64(base64) {
+    return base64ToBytes(base64);
+}
+function normalizeDocumentJsonString(jsonString, schema) {
+    try {
+        const parsed = JSON.parse(jsonString);
+        const normalized = (0, schemas_1.normalizeDocumentJson)(parsed, schema);
+        return normalized === parsed ? jsonString : JSON.stringify(normalized);
+    }
+    catch {
+        return jsonString;
+    }
+}
+function parseCommandPreparationJson(json) {
+    if (!json)
+        return { ready: true };
+    let parsed;
+    try {
+        parsed = JSON.parse(json);
+    }
+    catch {
+        throw new Error(ERR_NATIVE_RESPONSE);
+    }
+    if (typeof parsed.error === 'string') {
+        throw new Error(`NativeEditorBridge: ${parsed.error}`);
+    }
+    const rawBlockedReason = parsed.blockedReason;
+    const blockedReason = rawBlockedReason === 'composition' ||
+        rawBlockedReason === 'detached' ||
+        rawBlockedReason === 'pendingUpdate' ||
+        rawBlockedReason === 'destroyed'
+        ? rawBlockedReason
+        : rawBlockedReason === 'unknown'
+            ? 'unknown'
+            : undefined;
+    return {
+        ready: parsed.ready !== false,
+        updateJSON: typeof parsed.updateJSON === 'string' ? parsed.updateJSON : undefined,
+        blockedReason,
+    };
+}
+function parseCollaborationResultJson(json) {
+    if (!json || json === '') {
+        return {
+            messages: [],
+            documentChanged: false,
+            peersChanged: false,
+        };
+    }
+    try {
+        const parsed = JSON.parse(json);
+        if ('error' in parsed) {
+            throw new Error(`NativeEditorBridge: ${parsed.error}`);
+        }
+        return {
+            messages: Array.isArray(parsed.messages) ? parsed.messages : [],
+            documentChanged: parsed.documentChanged === true,
+            documentJson: parsed.documentJson && typeof parsed.documentJson === 'object'
+                ? parsed.documentJson
+                : undefined,
+            peersChanged: parsed.peersChanged === true,
+            peers: Array.isArray(parsed.peers) ? parsed.peers : undefined,
+        };
+    }
+    catch (e) {
+        if (e instanceof Error && e.message.startsWith('NativeEditorBridge:')) {
+            throw e;
+        }
+        throw new Error(ERR_NATIVE_RESPONSE);
+    }
+}
+let _nativeModule = null;
+function getNativeModule() {
+    if (!_nativeModule) {
+        _nativeModule = (0, expo_modules_core_1.requireNativeModule)('NativeEditor');
+    }
+    return _nativeModule;
+}
+/** @internal Reset the cached native module reference. For testing only. */
+function _resetNativeModuleCache() {
+    _nativeModule = null;
+}
+class NativeEditorBridge {
+    constructor(editorId, schema) {
+        this._destroyed = false;
+        this._lastSelection = { type: 'text', anchor: 0, head: 0 };
+        this._documentVersion = 0;
+        this._cachedHtml = null;
+        this._cachedJsonString = null;
+        this._renderBlocksCache = null;
+        this._lastCommandBlocked = false;
+        this._lastCommandBlockedReason = null;
+        this._lastCommandPreflightUpdate = null;
+        this._lastAcceptedUpdateJson = null;
+        this._hasSeenDocumentVersion = false;
+        this._editorId = editorId;
+        this._schema = schema;
+    }
+    /** Create a new editor instance backed by the Rust engine. */
+    static create(config) {
+        const configObj = {};
+        let parsedSchema;
+        if (config?.maxLength != null)
+            configObj.maxLength = config.maxLength;
+        if (config?.allowBase64Images != null) {
+            configObj.allowBase64Images = config.allowBase64Images;
+        }
+        if (config?.schemaJson != null) {
+            try {
+                parsedSchema = JSON.parse(config.schemaJson);
+                configObj.schema = parsedSchema;
+            }
+            catch {
+                // Fall back to the default schema when the provided JSON is invalid.
+            }
+        }
+        const id = getNativeModule().editorCreate(JSON.stringify(configObj));
+        return new NativeEditorBridge(id, parsedSchema);
+    }
+    /** The underlying native editor ID. */
+    get editorId() {
+        return this._editorId;
+    }
+    /** Whether this bridge has been destroyed. */
+    get isDestroyed() {
+        return this._destroyed;
+    }
+    consumeLastCommandBlocked() {
+        const blocked = this._lastCommandBlocked;
+        this._lastCommandBlocked = false;
+        this._lastCommandBlockedReason = null;
+        return blocked;
+    }
+    consumeLastCommandBlockedReason() {
+        const reason = this._lastCommandBlockedReason;
+        this._lastCommandBlocked = false;
+        this._lastCommandBlockedReason = null;
+        return reason;
+    }
+    consumeLastCommandBlockedInfo() {
+        const info = {
+            blocked: this._lastCommandBlocked,
+            reason: this._lastCommandBlockedReason,
+        };
+        this._lastCommandBlocked = false;
+        this._lastCommandBlockedReason = null;
+        return info;
+    }
+    consumeLastCommandPreflightUpdate() {
+        const update = this._lastCommandPreflightUpdate;
+        this._lastCommandPreflightUpdate = null;
+        return update;
+    }
+    prepareForNativeCommand() {
+        this.assertNotDestroyed();
+        return this.prepareForCommand();
+    }
+    /** Destroy the editor instance and free native resources. */
+    destroy() {
+        if (this._destroyed)
+            return;
+        this._destroyed = true;
+        this._renderBlocksCache = null;
+        this._lastCommandBlocked = false;
+        this._lastCommandBlockedReason = null;
+        this._lastCommandPreflightUpdate = null;
+        getNativeModule().editorDestroy(this._editorId);
+    }
+    /** Set content from HTML. Returns render elements for display. */
+    setHtml(html) {
+        this.assertNotDestroyed();
+        this.invalidateContentCaches();
+        this._renderBlocksCache = null;
+        const json = getNativeModule().editorSetHtml(this._editorId, html);
+        return parseRenderElements(json);
+    }
+    /** Get content as HTML. */
+    getHtml() {
+        this.assertNotDestroyed();
+        if (this._cachedHtml?.version === this._documentVersion) {
+            return this._cachedHtml.value;
+        }
+        const html = getNativeModule().editorGetHtml(this._editorId);
+        this._cachedHtml = { version: this._documentVersion, value: html };
+        return html;
+    }
+    /** Get cached HTML without making a native roundtrip. */
+    getCachedHtml() {
+        this.assertNotDestroyed();
+        return this._cachedHtml?.value ?? null;
+    }
+    /** Set content from ProseMirror JSON. Returns render elements. */
+    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. */
+    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);
+    }
+    /** Get content as raw ProseMirror JSON string. */
+    getJsonString() {
+        this.assertNotDestroyed();
+        if (this._cachedJsonString?.version === this._documentVersion) {
+            return this._cachedJsonString.value;
+        }
+        const json = getNativeModule().editorGetJson(this._editorId);
+        this._cachedJsonString = { version: this._documentVersion, value: json };
+        return json;
+    }
+    /** Get cached raw ProseMirror JSON without making a native roundtrip. */
+    getCachedJsonString() {
+        this.assertNotDestroyed();
+        return this._cachedJsonString?.value ?? null;
+    }
+    /** Get cached ProseMirror JSON without making a native roundtrip. */
+    getCachedJson() {
+        const json = this.getCachedJsonString();
+        return json == null ? null : parseDocumentJSON(json);
+    }
+    /** Get content as ProseMirror JSON. */
+    getJson() {
+        return parseDocumentJSON(this.getJsonString());
+    }
+    /** Get both HTML and JSON content in one native roundtrip. */
+    getContentSnapshot() {
+        this.assertNotDestroyed();
+        if (this._cachedHtml?.version === this._documentVersion &&
+            this._cachedJsonString?.version === this._documentVersion) {
+            return {
+                html: this._cachedHtml.value,
+                json: parseDocumentJSON(this._cachedJsonString.value),
+            };
+        }
+        const snapshot = parseContentSnapshotJson(getNativeModule().editorGetContentSnapshot(this._editorId));
+        this._cachedHtml = { version: this._documentVersion, value: snapshot.html };
+        this._cachedJsonString = {
+            version: this._documentVersion,
+            value: JSON.stringify(snapshot.json),
+        };
+        return snapshot;
+    }
+    /** Insert text at a document position. Returns the full update. */
+    insertText(pos, text) {
+        this.assertNotDestroyed();
+        return this.runPreparedCommand(() => getNativeModule().editorInsertText(this._editorId, pos, text));
+    }
+    /** Delete a range [from, to). Returns the full update. */
+    deleteRange(from, to) {
+        this.assertNotDestroyed();
+        return this.runPreparedCommand(() => getNativeModule().editorDeleteRange(this._editorId, from, to));
+    }
+    /** Replace the current selection with text atomically. */
+    replaceSelectionText(text) {
+        this.assertNotDestroyed();
+        return this.runPreparedCommand(() => getNativeModule().editorReplaceSelectionText(this._editorId, text));
+    }
+    /** Toggle a mark (bold, italic, etc.) on the current selection. */
+    toggleMark(markType) {
+        this.assertNotDestroyed();
+        return this.runPreparedCommand(() => {
+            const scalarSelection = this.currentScalarSelection();
+            return scalarSelection
+                ? getNativeModule().editorToggleMarkAtSelectionScalar(this._editorId, scalarSelection.anchor, scalarSelection.head, markType)
+                : getNativeModule().editorToggleMark(this._editorId, markType);
+        }, { refreshSelectionAfterPreflight: true });
+    }
+    /** Set a mark with attrs on the current selection. */
+    setMark(markType, attrs) {
+        this.assertNotDestroyed();
+        const attrsJson = JSON.stringify(attrs);
+        return this.runPreparedCommand(() => {
+            const scalarSelection = this.currentScalarSelection();
+            return scalarSelection
+                ? getNativeModule().editorSetMarkAtSelectionScalar(this._editorId, scalarSelection.anchor, scalarSelection.head, markType, attrsJson)
+                : getNativeModule().editorSetMark(this._editorId, markType, attrsJson);
+        }, { refreshSelectionAfterPreflight: true });
+    }
+    /** Set a mark with attrs at an explicit scalar selection. */
+    setMarkAtSelectionScalar(scalarAnchor, scalarHead, markType, attrs) {
+        this.assertNotDestroyed();
+        return this.runPreparedCommand(() => getNativeModule().editorSetMarkAtSelectionScalar(this._editorId, scalarAnchor, scalarHead, markType, JSON.stringify(attrs)), { cancelIfPreflightUpdated: true });
+    }
+    /** Remove a mark from the current selection. */
+    unsetMark(markType) {
+        this.assertNotDestroyed();
+        return this.runPreparedCommand(() => {
+            const scalarSelection = this.currentScalarSelection();
+            return scalarSelection
+                ? getNativeModule().editorUnsetMarkAtSelectionScalar(this._editorId, scalarSelection.anchor, scalarSelection.head, markType)
+                : getNativeModule().editorUnsetMark(this._editorId, markType);
+        }, { refreshSelectionAfterPreflight: true });
+    }
+    /** Remove a mark at an explicit scalar selection. */
+    unsetMarkAtSelectionScalar(scalarAnchor, scalarHead, markType) {
+        this.assertNotDestroyed();
+        return this.runPreparedCommand(() => getNativeModule().editorUnsetMarkAtSelectionScalar(this._editorId, scalarAnchor, scalarHead, markType), { cancelIfPreflightUpdated: true });
+    }
+    /** Toggle blockquote wrapping for the current block selection. */
+    toggleBlockquote() {
+        this.assertNotDestroyed();
+        return this.runPreparedCommand(() => {
+            const scalarSelection = this.currentScalarSelection();
+            return scalarSelection
+                ? getNativeModule().editorToggleBlockquoteAtSelectionScalar(this._editorId, scalarSelection.anchor, scalarSelection.head)
+                : getNativeModule().editorToggleBlockquote(this._editorId);
+        }, { refreshSelectionAfterPreflight: true });
+    }
+    /** Toggle a heading level on the current block selection. */
+    toggleHeading(level) {
+        this.assertNotDestroyed();
+        if (!Number.isInteger(level) || level < 1 || level > 6) {
+            throw new Error('NativeEditorBridge: invalid heading level');
+        }
+        return this.runPreparedCommand(() => {
+            const scalarSelection = this.currentScalarSelection();
+            return scalarSelection
+                ? getNativeModule().editorToggleHeadingAtSelectionScalar(this._editorId, scalarSelection.anchor, scalarSelection.head, level)
+                : getNativeModule().editorToggleHeading(this._editorId, level);
+        }, { refreshSelectionAfterPreflight: true });
+    }
+    /** Set the document selection by anchor and head positions. */
+    setSelection(anchor, head) {
+        this.assertNotDestroyed();
+        getNativeModule().editorSetSelection(this._editorId, anchor, head);
+        this._lastSelection = { type: 'text', anchor, head };
+    }
+    /** Convert a document position to a scalar position used by native text views. */
+    docToScalar(docPos) {
+        this.assertNotDestroyed();
+        return getNativeModule().editorDocToScalar(this._editorId, docPos);
+    }
+    /** Convert a native scalar position back to a document position. */
+    scalarToDoc(scalar) {
+        this.assertNotDestroyed();
+        return getNativeModule().editorScalarToDoc(this._editorId, scalar);
+    }
+    /** Get the current selection from the Rust engine (synchronous native call).
+     *  Always returns the live selection, not a stale cache. */
+    getSelection() {
+        if (this._destroyed)
+            return { type: 'text', anchor: 0, head: 0 };
+        try {
+            const json = getNativeModule().editorGetSelection(this._editorId);
+            const sel = JSON.parse(json);
+            this._lastSelection = sel;
+            return sel;
+        }
+        catch {
+            return this._lastSelection;
+        }
+    }
+    /** Update the cached selection from native events (scalar offsets).
+     *  Called by the React component when native selection change events arrive. */
+    updateSelectionFromNative(anchor, head) {
+        if (this._destroyed)
+            return;
+        this._lastSelection = { type: 'text', anchor, head };
+    }
+    /** Get the current full state from Rust (render elements, selection, etc.). */
+    getCurrentState() {
+        this.assertNotDestroyed();
+        const json = getNativeModule().editorGetCurrentState(this._editorId);
+        return this.parseAndNoteUpdate(json);
+    }
+    /** Get the current selection-related state without render elements. */
+    getSelectionState() {
+        this.assertNotDestroyed();
+        const json = getNativeModule().editorGetSelectionState(this._editorId);
+        return this.parseAndNoteUpdate(json);
+    }
+    /** Split the block at a position (Enter key). */
+    splitBlock(pos) {
+        this.assertNotDestroyed();
+        return this.runPreparedCommand(() => getNativeModule().editorSplitBlock(this._editorId, pos));
+    }
+    /** Insert HTML content at the current selection. */
+    insertContentHtml(html) {
+        this.assertNotDestroyed();
+        return this.runPreparedCommand(() => getNativeModule().editorInsertContentHtml(this._editorId, html));
+    }
+    /** Insert JSON content at the current selection. */
+    insertContentJson(doc) {
+        this.assertNotDestroyed();
+        return this.runPreparedCommand(() => getNativeModule().editorInsertContentJson(this._editorId, JSON.stringify(doc)));
+    }
+    /** Insert JSON content at an explicit scalar selection. */
+    insertContentJsonAtSelectionScalar(scalarAnchor, scalarHead, doc) {
+        return this.insertContentJsonAtSelectionScalarLazy(scalarAnchor, scalarHead, () => doc);
+    }
+    /** Insert lazily-built JSON content at an explicit scalar selection. */
+    insertContentJsonAtSelectionScalarLazy(scalarAnchor, scalarHead, resolveDoc) {
+        this.assertNotDestroyed();
+        return this.runPreparedCommand(() => getNativeModule().editorInsertContentJsonAtSelectionScalar(this._editorId, scalarAnchor, scalarHead, JSON.stringify(resolveDoc())), { cancelIfPreflightUpdated: true });
+    }
+    /** Replace entire document with HTML via transaction (preserves undo history). */
+    replaceHtml(html) {
+        this.assertNotDestroyed();
+        return this.runPreparedCommand(() => getNativeModule().editorReplaceHtml(this._editorId, html));
+    }
+    /** Replace entire document with JSON via transaction (preserves undo history). */
+    replaceJson(doc) {
+        return this.replaceJsonString(JSON.stringify((0, schemas_1.normalizeDocumentJson)(doc, this._schema)));
+    }
+    /** Replace entire document with a serialized JSON transaction. */
+    replaceJsonString(jsonString) {
+        this.assertNotDestroyed();
+        const normalizedJsonString = normalizeDocumentJsonString(jsonString, this._schema);
+        return this.runPreparedCommand(() => getNativeModule().editorReplaceJson(this._editorId, normalizedJsonString));
+    }
+    /** Undo the last operation. Returns update or null if nothing to undo. */
+    undo() {
+        this.assertNotDestroyed();
+        return this.runPreparedCommand(() => getNativeModule().editorUndo(this._editorId));
+    }
+    /** Redo the last undone operation. Returns update or null if nothing to redo. */
+    redo() {
+        this.assertNotDestroyed();
+        return this.runPreparedCommand(() => getNativeModule().editorRedo(this._editorId));
+    }
+    /** Check if undo is available. */
+    canUndo() {
+        this.assertNotDestroyed();
+        return getNativeModule().editorCanUndo(this._editorId);
+    }
+    /** Check if redo is available. */
+    canRedo() {
+        this.assertNotDestroyed();
+        return getNativeModule().editorCanRedo(this._editorId);
+    }
+    /** Toggle a list type on the current selection. Wraps if not in list, unwraps if already in that list type. */
+    toggleList(listType) {
+        this.assertNotDestroyed();
+        return this.runPreparedCommand(() => {
+            const isActive = this.getCurrentState()?.activeState?.nodes?.[listType] === true;
+            const scalarSelection = this.currentScalarSelection();
+            return isActive
+                ? scalarSelection
+                    ? getNativeModule().editorUnwrapFromListAtSelectionScalar(this._editorId, scalarSelection.anchor, scalarSelection.head)
+                    : getNativeModule().editorUnwrapFromList(this._editorId)
+                : scalarSelection
+                    ? getNativeModule().editorWrapInListAtSelectionScalar(this._editorId, scalarSelection.anchor, scalarSelection.head, listType)
+                    : getNativeModule().editorWrapInList(this._editorId, listType);
+        }, { refreshSelectionAfterPreflight: true });
+    }
+    /** Unwrap the current list item back to a paragraph. */
+    unwrapFromList() {
+        this.assertNotDestroyed();
+        return this.runPreparedCommand(() => {
+            const scalarSelection = this.currentScalarSelection();
+            return scalarSelection
+                ? getNativeModule().editorUnwrapFromListAtSelectionScalar(this._editorId, scalarSelection.anchor, scalarSelection.head)
+                : getNativeModule().editorUnwrapFromList(this._editorId);
+        }, { refreshSelectionAfterPreflight: true });
+    }
+    /** Indent the current list item into a nested list. */
+    indentListItem() {
+        this.assertNotDestroyed();
+        return this.runPreparedCommand(() => {
+            const scalarSelection = this.currentScalarSelection();
+            return scalarSelection
+                ? getNativeModule().editorIndentListItemAtSelectionScalar(this._editorId, scalarSelection.anchor, scalarSelection.head)
+                : getNativeModule().editorIndentListItem(this._editorId);
+        }, { refreshSelectionAfterPreflight: true });
+    }
+    /** Outdent the current list item to the parent list level. */
+    outdentListItem() {
+        this.assertNotDestroyed();
+        return this.runPreparedCommand(() => {
+            const scalarSelection = this.currentScalarSelection();
+            return scalarSelection
+                ? getNativeModule().editorOutdentListItemAtSelectionScalar(this._editorId, scalarSelection.anchor, scalarSelection.head)
+                : getNativeModule().editorOutdentListItem(this._editorId);
+        }, { refreshSelectionAfterPreflight: true });
+    }
+    /** Insert a void node (e.g. 'horizontalRule') at the current selection. */
+    insertNode(nodeType) {
+        this.assertNotDestroyed();
+        return this.runPreparedCommand(() => {
+            const scalarSelection = this.currentScalarSelection();
+            return scalarSelection
+                ? getNativeModule().editorInsertNodeAtSelectionScalar(this._editorId, scalarSelection.anchor, scalarSelection.head, nodeType)
+                : getNativeModule().editorInsertNode(this._editorId, nodeType);
+        }, { refreshSelectionAfterPreflight: true });
+    }
+    parseUpdateJson(json, options) {
+        this.assertNotDestroyed();
+        return this.parseAndNoteUpdate(json, options);
+    }
+    noteUpdate(update) {
+        if (!update) {
+            return;
+        }
+        this._lastSelection = update.selection;
+        if (update.renderBlocks) {
+            this._renderBlocksCache = update.renderBlocks;
+        }
+        if (typeof update.documentVersion !== 'number') {
+            this.invalidateContentCaches();
+            return;
+        }
+        this._hasSeenDocumentVersion = true;
+        if (update.documentVersion !== this._documentVersion) {
+            this._documentVersion = update.documentVersion;
+            this.invalidateContentCaches();
+        }
+    }
+    shouldRejectUpdate(update, json, options) {
+        if (!update) {
+            return false;
+        }
+        if (typeof update.documentVersion !== 'number') {
+            return (options?.rejectVersionlessAfterDocumentVersion === true &&
+                react_native_1.Platform.OS === 'android' &&
+                this._hasSeenDocumentVersion);
+        }
+        if (react_native_1.Platform.OS === 'android') {
+            this._hasSeenDocumentVersion = true;
+        }
+        if (update.documentVersion < this._documentVersion) {
+            return true;
+        }
+        if (options?.rejectSameDocumentVersion === true) {
+            return (update.documentVersion === this._documentVersion &&
+                json === this._lastAcceptedUpdateJson);
+        }
+        return false;
+    }
+    parseAndNoteUpdate(json, options) {
+        let update = parseEditorUpdateJson(json, this._renderBlocksCache ?? 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;
+        }
+        return update;
+    }
+    prepareForCommand() {
+        this._lastCommandBlocked = false;
+        this._lastCommandBlockedReason = null;
+        this._lastCommandPreflightUpdate = null;
+        const nativeModule = getNativeModule();
+        const prepareForCommand = nativeModule.editorPrepareForCommand;
+        if (typeof prepareForCommand !== 'function') {
+            return true;
+        }
+        const preparation = parseCommandPreparationJson(prepareForCommand(this._editorId));
+        if (preparation.updateJSON) {
+            this._lastCommandPreflightUpdate = this.parseAndNoteUpdate(preparation.updateJSON, {
+                rejectVersionlessAfterDocumentVersion: true,
+            });
+        }
+        if (!preparation.ready) {
+            this._lastCommandBlocked = true;
+            this._lastCommandBlockedReason = preparation.blockedReason ?? 'unknown';
+            return false;
+        }
+        return true;
+    }
+    runPreparedCommand(mutate, options) {
+        if (!this.prepareForCommand()) {
+            return null;
+        }
+        if (options?.cancelIfPreflightUpdated === true &&
+            this._lastCommandPreflightUpdate != null) {
+            return null;
+        }
+        if (options?.refreshSelectionAfterPreflight === true && react_native_1.Platform.OS === 'android') {
+            this.getSelection();
+        }
+        const update = this.parseAndNoteUpdate(mutate());
+        if (update) {
+            this._lastCommandPreflightUpdate = null;
+        }
+        return update;
+    }
+    invalidateContentCaches() {
+        this._cachedHtml = null;
+        this._cachedJsonString = null;
+    }
+    assertNotDestroyed() {
+        if (this._destroyed) {
+            throw new Error(ERR_DESTROYED);
+        }
+    }
+    currentScalarSelection() {
+        const selection = this._lastSelection;
+        const nativeModule = getNativeModule();
+        if (selection.type === 'text') {
+            const anchor = selection.anchor ?? 0;
+            const head = selection.head ?? anchor;
+            return {
+                anchor: nativeModule.editorDocToScalar(this._editorId, anchor),
+                head: nativeModule.editorDocToScalar(this._editorId, head),
+            };
+        }
+        if (selection.type === 'node' && typeof selection.pos === 'number') {
+            const scalar = nativeModule.editorDocToScalar(this._editorId, selection.pos);
+            return { anchor: scalar, head: scalar };
+        }
+        return null;
+    }
+}
+exports.NativeEditorBridge = NativeEditorBridge;
+class NativeCollaborationBridge {
+    constructor(sessionId) {
+        this._destroyed = false;
+        this._sessionId = sessionId;
+    }
+    static create(config) {
+        const { initialEncodedState, ...normalizedConfig } = config ?? {};
+        const id = getNativeModule().collaborationSessionCreate(JSON.stringify(normalizedConfig));
+        const bridge = new NativeCollaborationBridge(id);
+        if (initialEncodedState != null) {
+            try {
+                bridge.replaceEncodedState(initialEncodedState);
+            }
+            catch (error) {
+                bridge.destroy();
+                throw error;
+            }
+        }
+        return bridge;
+    }
+    get sessionId() {
+        return this._sessionId;
+    }
+    get isDestroyed() {
+        return this._destroyed;
+    }
+    destroy() {
+        if (this._destroyed)
+            return;
+        this._destroyed = true;
+        getNativeModule().collaborationSessionDestroy(this._sessionId);
+    }
+    getDocumentJson() {
+        this.assertNotDestroyed();
+        return parseDocumentJSON(getNativeModule().collaborationSessionGetDocumentJson(this._sessionId));
+    }
+    getEncodedState() {
+        this.assertNotDestroyed();
+        return parseByteArrayJson(getNativeModule().collaborationSessionGetEncodedState(this._sessionId));
+    }
+    getEncodedStateBase64() {
+        return encodeCollaborationStateBase64(this.getEncodedState());
+    }
+    getPeers() {
+        this.assertNotDestroyed();
+        return parseCollaborationPeersJson(getNativeModule().collaborationSessionGetPeersJson(this._sessionId));
+    }
+    start() {
+        this.assertNotDestroyed();
+        return parseCollaborationResultJson(getNativeModule().collaborationSessionStart(this._sessionId));
+    }
+    applyLocalDocumentJson(doc) {
+        this.assertNotDestroyed();
+        return parseCollaborationResultJson(getNativeModule().collaborationSessionApplyLocalDocumentJson(this._sessionId, JSON.stringify(doc)));
+    }
+    applyEncodedState(encodedState) {
+        this.assertNotDestroyed();
+        return parseCollaborationResultJson(getNativeModule().collaborationSessionApplyEncodedState(this._sessionId, JSON.stringify(normalizeEncodedStateInput(encodedState))));
+    }
+    replaceEncodedState(encodedState) {
+        this.assertNotDestroyed();
+        return parseCollaborationResultJson(getNativeModule().collaborationSessionReplaceEncodedState(this._sessionId, JSON.stringify(normalizeEncodedStateInput(encodedState))));
+    }
+    handleMessage(bytes) {
+        this.assertNotDestroyed();
+        return parseCollaborationResultJson(getNativeModule().collaborationSessionHandleMessage(this._sessionId, JSON.stringify(Array.from(bytes))));
+    }
+    setLocalAwareness(state) {
+        this.assertNotDestroyed();
+        return parseCollaborationResultJson(getNativeModule().collaborationSessionSetLocalAwareness(this._sessionId, JSON.stringify(state)));
+    }
+    clearLocalAwareness() {
+        this.assertNotDestroyed();
+        return parseCollaborationResultJson(getNativeModule().collaborationSessionClearLocalAwareness(this._sessionId));
+    }
+    assertNotDestroyed() {
+        if (this._destroyed) {
+            throw new Error(ERR_DESTROYED);
+        }
+    }
+}
+exports.NativeCollaborationBridge = NativeCollaborationBridge;