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

package/dist/NativeEditorBridge.js

@@ -0,0 +1,647 @@
+"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 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) {
+    if (!json || json === '')
+        return null;
+    try {
+        const parsed = JSON.parse(json);
+        if ('error' in parsed) {
+            throw new Error(`NativeEditorBridge: ${parsed.error}`);
+        }
+        return {
+            renderElements: (parsed.renderElements ?? []),
+            selection: (parsed.selection ?? { type: 'text', anchor: 0, head: 0 }),
+            activeState: normalizeActiveState(parsed.activeState),
+            historyState: (parsed.historyState ?? {
+                canUndo: false,
+                canRedo: false,
+            }),
+        };
+    }
+    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 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) {
+        this._destroyed = false;
+        this._lastSelection = { type: 'text', anchor: 0, head: 0 };
+        this._editorId = editorId;
+    }
+    /** Create a new editor instance backed by the Rust engine. */
+    static create(config) {
+        const configObj = {};
+        if (config?.maxLength != null)
+            configObj.maxLength = config.maxLength;
+        if (config?.allowBase64Images != null) {
+            configObj.allowBase64Images = config.allowBase64Images;
+        }
+        if (config?.schemaJson != null) {
+            try {
+                configObj.schema = JSON.parse(config.schemaJson);
+            }
+            catch {
+                // Fall back to the default schema when the provided JSON is invalid.
+            }
+        }
+        const id = getNativeModule().editorCreate(JSON.stringify(configObj));
+        return new NativeEditorBridge(id);
+    }
+    /** The underlying native editor ID. */
+    get editorId() {
+        return this._editorId;
+    }
+    /** Whether this bridge has been destroyed. */
+    get isDestroyed() {
+        return this._destroyed;
+    }
+    /** Destroy the editor instance and free native resources. */
+    destroy() {
+        if (this._destroyed)
+            return;
+        this._destroyed = true;
+        getNativeModule().editorDestroy(this._editorId);
+    }
+    /** Set content from HTML. Returns render elements for display. */
+    setHtml(html) {
+        this.assertNotDestroyed();
+        const json = getNativeModule().editorSetHtml(this._editorId, html);
+        return parseRenderElements(json);
+    }
+    /** Get content as HTML. */
+    getHtml() {
+        this.assertNotDestroyed();
+        return getNativeModule().editorGetHtml(this._editorId);
+    }
+    /** Set content from ProseMirror JSON. Returns render elements. */
+    setJson(doc) {
+        this.assertNotDestroyed();
+        const json = getNativeModule().editorSetJson(this._editorId, JSON.stringify(doc));
+        return parseRenderElements(json);
+    }
+    /** Get content as ProseMirror JSON. */
+    getJson() {
+        this.assertNotDestroyed();
+        const json = getNativeModule().editorGetJson(this._editorId);
+        return parseDocumentJSON(json);
+    }
+    /** Insert text at a document position. Returns the full update. */
+    insertText(pos, text) {
+        this.assertNotDestroyed();
+        const json = getNativeModule().editorInsertText(this._editorId, pos, text);
+        const update = parseEditorUpdateJson(json);
+        if (update)
+            this._lastSelection = update.selection;
+        return update;
+    }
+    /** Delete a range [from, to). Returns the full update. */
+    deleteRange(from, to) {
+        this.assertNotDestroyed();
+        const json = getNativeModule().editorDeleteRange(this._editorId, from, to);
+        const update = parseEditorUpdateJson(json);
+        if (update)
+            this._lastSelection = update.selection;
+        return update;
+    }
+    /** Replace the current selection with text atomically. */
+    replaceSelectionText(text) {
+        this.assertNotDestroyed();
+        const json = getNativeModule().editorReplaceSelectionText(this._editorId, text);
+        const update = parseEditorUpdateJson(json);
+        if (update)
+            this._lastSelection = update.selection;
+        return update;
+    }
+    /** Toggle a mark (bold, italic, etc.) on the current selection. */
+    toggleMark(markType) {
+        this.assertNotDestroyed();
+        const scalarSelection = this.currentScalarSelection();
+        const json = scalarSelection
+            ? getNativeModule().editorToggleMarkAtSelectionScalar(this._editorId, scalarSelection.anchor, scalarSelection.head, markType)
+            : getNativeModule().editorToggleMark(this._editorId, markType);
+        const update = parseEditorUpdateJson(json);
+        if (update)
+            this._lastSelection = update.selection;
+        return update;
+    }
+    /** Set a mark with attrs on the current selection. */
+    setMark(markType, attrs) {
+        this.assertNotDestroyed();
+        const attrsJson = JSON.stringify(attrs);
+        const scalarSelection = this.currentScalarSelection();
+        const json = scalarSelection
+            ? getNativeModule().editorSetMarkAtSelectionScalar(this._editorId, scalarSelection.anchor, scalarSelection.head, markType, attrsJson)
+            : getNativeModule().editorSetMark(this._editorId, markType, attrsJson);
+        const update = parseEditorUpdateJson(json);
+        if (update)
+            this._lastSelection = update.selection;
+        return update;
+    }
+    /** Remove a mark from the current selection. */
+    unsetMark(markType) {
+        this.assertNotDestroyed();
+        const scalarSelection = this.currentScalarSelection();
+        const json = scalarSelection
+            ? getNativeModule().editorUnsetMarkAtSelectionScalar(this._editorId, scalarSelection.anchor, scalarSelection.head, markType)
+            : getNativeModule().editorUnsetMark(this._editorId, markType);
+        const update = parseEditorUpdateJson(json);
+        if (update)
+            this._lastSelection = update.selection;
+        return update;
+    }
+    /** Toggle blockquote wrapping for the current block selection. */
+    toggleBlockquote() {
+        this.assertNotDestroyed();
+        const scalarSelection = this.currentScalarSelection();
+        const json = scalarSelection
+            ? getNativeModule().editorToggleBlockquoteAtSelectionScalar(this._editorId, scalarSelection.anchor, scalarSelection.head)
+            : getNativeModule().editorToggleBlockquote(this._editorId);
+        const update = parseEditorUpdateJson(json);
+        if (update)
+            this._lastSelection = update.selection;
+        return update;
+    }
+    /** 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 };
+    }
+    /** 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);
+        const update = parseEditorUpdateJson(json);
+        if (update)
+            this._lastSelection = update.selection;
+        return update;
+    }
+    /** Split the block at a position (Enter key). */
+    splitBlock(pos) {
+        this.assertNotDestroyed();
+        const json = getNativeModule().editorSplitBlock(this._editorId, pos);
+        const update = parseEditorUpdateJson(json);
+        if (update)
+            this._lastSelection = update.selection;
+        return update;
+    }
+    /** Insert HTML content at the current selection. */
+    insertContentHtml(html) {
+        this.assertNotDestroyed();
+        const json = getNativeModule().editorInsertContentHtml(this._editorId, html);
+        const update = parseEditorUpdateJson(json);
+        if (update)
+            this._lastSelection = update.selection;
+        return update;
+    }
+    /** Insert JSON content at the current selection. */
+    insertContentJson(doc) {
+        this.assertNotDestroyed();
+        const json = getNativeModule().editorInsertContentJson(this._editorId, JSON.stringify(doc));
+        const update = parseEditorUpdateJson(json);
+        if (update)
+            this._lastSelection = update.selection;
+        return update;
+    }
+    /** Insert JSON content at an explicit scalar selection. */
+    insertContentJsonAtSelectionScalar(scalarAnchor, scalarHead, doc) {
+        this.assertNotDestroyed();
+        const json = getNativeModule().editorInsertContentJsonAtSelectionScalar(this._editorId, scalarAnchor, scalarHead, JSON.stringify(doc));
+        const update = parseEditorUpdateJson(json);
+        if (update)
+            this._lastSelection = update.selection;
+        return update;
+    }
+    /** Replace entire document with HTML via transaction (preserves undo history). */
+    replaceHtml(html) {
+        this.assertNotDestroyed();
+        const json = getNativeModule().editorReplaceHtml(this._editorId, html);
+        const update = parseEditorUpdateJson(json);
+        if (update)
+            this._lastSelection = update.selection;
+        return update;
+    }
+    /** Replace entire document with JSON via transaction (preserves undo history). */
+    replaceJson(doc) {
+        this.assertNotDestroyed();
+        const json = getNativeModule().editorReplaceJson(this._editorId, JSON.stringify(doc));
+        const update = parseEditorUpdateJson(json);
+        if (update)
+            this._lastSelection = update.selection;
+        return update;
+    }
+    /** Undo the last operation. Returns update or null if nothing to undo. */
+    undo() {
+        this.assertNotDestroyed();
+        const json = getNativeModule().editorUndo(this._editorId);
+        const update = parseEditorUpdateJson(json);
+        if (update)
+            this._lastSelection = update.selection;
+        return update;
+    }
+    /** Redo the last undone operation. Returns update or null if nothing to redo. */
+    redo() {
+        this.assertNotDestroyed();
+        const json = getNativeModule().editorRedo(this._editorId);
+        const update = parseEditorUpdateJson(json);
+        if (update)
+            this._lastSelection = update.selection;
+        return update;
+    }
+    /** 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();
+        const isActive = this.getCurrentState()?.activeState?.nodes?.[listType] === true;
+        const scalarSelection = this.currentScalarSelection();
+        const json = 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);
+        const update = parseEditorUpdateJson(json);
+        if (update)
+            this._lastSelection = update.selection;
+        return update;
+    }
+    /** Unwrap the current list item back to a paragraph. */
+    unwrapFromList() {
+        this.assertNotDestroyed();
+        const scalarSelection = this.currentScalarSelection();
+        const json = scalarSelection
+            ? getNativeModule().editorUnwrapFromListAtSelectionScalar(this._editorId, scalarSelection.anchor, scalarSelection.head)
+            : getNativeModule().editorUnwrapFromList(this._editorId);
+        const update = parseEditorUpdateJson(json);
+        if (update)
+            this._lastSelection = update.selection;
+        return update;
+    }
+    /** Indent the current list item into a nested list. */
+    indentListItem() {
+        this.assertNotDestroyed();
+        const scalarSelection = this.currentScalarSelection();
+        const json = scalarSelection
+            ? getNativeModule().editorIndentListItemAtSelectionScalar(this._editorId, scalarSelection.anchor, scalarSelection.head)
+            : getNativeModule().editorIndentListItem(this._editorId);
+        const update = parseEditorUpdateJson(json);
+        if (update)
+            this._lastSelection = update.selection;
+        return update;
+    }
+    /** Outdent the current list item to the parent list level. */
+    outdentListItem() {
+        this.assertNotDestroyed();
+        const scalarSelection = this.currentScalarSelection();
+        const json = scalarSelection
+            ? getNativeModule().editorOutdentListItemAtSelectionScalar(this._editorId, scalarSelection.anchor, scalarSelection.head)
+            : getNativeModule().editorOutdentListItem(this._editorId);
+        const update = parseEditorUpdateJson(json);
+        if (update)
+            this._lastSelection = update.selection;
+        return update;
+    }
+    /** Insert a void node (e.g. 'horizontalRule') at the current selection. */
+    insertNode(nodeType) {
+        this.assertNotDestroyed();
+        const scalarSelection = this.currentScalarSelection();
+        const json = scalarSelection
+            ? getNativeModule().editorInsertNodeAtSelectionScalar(this._editorId, scalarSelection.anchor, scalarSelection.head, nodeType)
+            : getNativeModule().editorInsertNode(this._editorId, nodeType);
+        const update = parseEditorUpdateJson(json);
+        if (update)
+            this._lastSelection = update.selection;
+        return update;
+    }
+    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;