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

package/src/NativeEditorDocumentBridge.ts

@@ -1,5 +1,5 @@
 import {
-    NativeEditorErrorBase,
+    type NativeEditorErrorBase,
     NativeEditorNonRetryableError,
     nativeEditorV2ErrorToException,
     normalizeNativeEditorV2Error,
@@ -69,12 +69,18 @@ import {
  */
 export class NativeEditorDocumentBridge {
     private readonly _editorId: string;
+
     private _destroyed = false;
+
     /** @internal Reset intent waiting for the interactive view handoff. */
     _pendingViewReset: { json: string } | null = null;
+
     private _nextRequestId = 0n;
+
     private readonly _errorListeners = new Set<(error: NativeEditorErrorBase) => void>();
+
     private _collaborationProtocolAdapter: NativeCollaborationProtocolAdapter | null = null;
+
     private _collaborationProtocolAdapterSubscription: { remove(): void } | null = null;
 
     /** @internal Created by createNativeEditorDocumentHandle. */
@@ -91,15 +97,21 @@ export class NativeEditorDocumentBridge {
     }
 
     private assertAlive(): void {
-        if (this._destroyed) throw destroyedHandleError();
+        if (this._destroyed) {
+            throw destroyedHandleError();
+        }
     }
 
     private callV2<T>(invoke: () => unknown, normalizeValue: (value: unknown) => T | null): T {
         this.assertAlive();
         const raw = invoke();
+
         // A re-entrant destroy racing the native call makes any result
         // arriving now a result for a destroyed handle: non-retryable.
-        if (this._destroyed) throw destroyedHandleError();
+        if (this._destroyed) {
+            throw destroyedHandleError();
+        }
+
         return unwrapNativeEditorV2Result(raw, normalizeValue);
     }
 
@@ -107,7 +119,9 @@ export class NativeEditorDocumentBridge {
         if (this._nextRequestId >= 18_446_744_073_709_551_615n) {
             throw invalidV2RequestError('NativeEditorBridge: v2 request id exhausted');
         }
+
         this._nextRequestId += 1n;
+
         return this._nextRequestId.toString();
     }
 
@@ -122,19 +136,28 @@ export class NativeEditorDocumentBridge {
             `"version":${V2_ENVELOPE_VERSION}`,
             `"requestId":"${this.nextRequestId()}"`,
         ];
+
         if (baseDocumentRevision !== undefined) {
             const digits = requireV2DecimalId(baseDocumentRevision, 'baseDocumentRevision');
             parts.push(`"baseDocumentRevision":"${digits}"`);
         }
+
         const payloadJson = JSON.stringify(payload);
         const inner = payloadJson.slice(1, payloadJson.length - 1);
-        if (inner.length > 0) parts.push(inner);
+
+        if (inner.length > 0) {
+            parts.push(inner);
+        }
+
         return `{${parts.join(',')}}`;
     }
 
     /** Destroy the session. Repeated destroy is safe. */
     destroy(): void {
-        if (this._destroyed) return;
+        if (this._destroyed) {
+            return;
+        }
+
         try {
             unwrapNativeEditorV2Result(
                 invokeNativeEditorV2('editorV2Destroy', this._editorId),
@@ -153,6 +176,7 @@ export class NativeEditorDocumentBridge {
                 throw error;
             }
         }
+
         this._destroyed = true;
         this._collaborationProtocolAdapter = null;
         this._collaborationProtocolAdapterSubscription?.remove();
@@ -163,6 +187,7 @@ export class NativeEditorDocumentBridge {
     /** Subscribe to autonomous native failures; returns the unsubscribe. */
     addErrorListener(listener: (error: NativeEditorErrorBase) => void): () => void {
         this._errorListeners.add(listener);
+
         return () => {
             this._errorListeners.delete(listener);
         };
@@ -175,13 +200,18 @@ export class NativeEditorDocumentBridge {
      * contract violation so the view stays usable.
      */
     _emitAutonomousError(raw: unknown): void {
-        if (this._destroyed) return;
+        if (this._destroyed) {
+            return;
+        }
+
         const candidate = isPlainRecord(raw) && 'error' in raw ? raw : { error: raw };
         const normalized = normalizeNativeEditorV2Error(candidate);
+
         const exception =
             normalized == null
                 ? invalidV2ResultError()
                 : nativeEditorV2ErrorToException(normalized);
+
         for (const listener of this._errorListeners) {
             listener(exception);
         }
@@ -228,13 +258,21 @@ export class NativeEditorDocumentBridge {
         this.assertAlive();
         const mirrorAnchor = mirrorScalarSelection?.anchor ?? null;
         const mirrorHead = mirrorScalarSelection?.head ?? null;
+
         if ((mirrorAnchor == null) !== (mirrorHead == null)) {
             throw invalidV2RequestError(
                 'NativeEditorBridge: render update mirror requires both scalar anchor and head'
             );
         }
-        if (mirrorAnchor != null) requireNativeEditorV2U32(mirrorAnchor, 'mirrorScalarAnchor');
-        if (mirrorHead != null) requireNativeEditorV2U32(mirrorHead, 'mirrorScalarHead');
+
+        if (mirrorAnchor != null) {
+            requireNativeEditorV2U32(mirrorAnchor, 'mirrorScalarAnchor');
+        }
+
+        if (mirrorHead != null) {
+            requireNativeEditorV2U32(mirrorHead, 'mirrorScalarHead');
+        }
+
         return this.callV2(
             () =>
                 invokeNativeEditorV2(
@@ -250,14 +288,23 @@ export class NativeEditorDocumentBridge {
     replaceDocument(request: NativeEditorReplaceDocumentRequest): NativeEditorCommitInfo {
         this.assertAlive();
         const payload: Record<string, unknown> = {};
-        if (request.setJson !== undefined) payload.setJson = request.setJson;
-        if (request.setHtml !== undefined) payload.setHtml = request.setHtml;
+
+        if (request.setJson !== undefined) {
+            payload.setJson = request.setJson;
+        }
+
+        if (request.setHtml !== undefined) {
+            payload.setHtml = request.setHtml;
+        }
+
         payload.history = request.history;
         const requestJson = this.buildEnvelopeJson(payload);
+
         const result = this.callV2(
             () => invokeNativeEditorV2('editorV2ReplaceDocument', this._editorId, requestJson),
             normalizeNativeEditorV2CommitValue
         );
+
         if (request.history === 'resetAndClear' && 'documentRevision' in result) {
             this._pendingViewReset = {
                 json: JSON.stringify({ ...payload, documentRevision: result.documentRevision }),
@@ -265,15 +312,18 @@ export class NativeEditorDocumentBridge {
         } else {
             this._pendingViewReset = null;
         }
+
         return result;
     }
 
     applyInput(request: NativeEditorInputRequest): NativeEditorMutationOutcome {
         this.assertAlive();
+
         const requestJson = this.buildEnvelopeJson(
             { text: request.text },
             request.baseDocumentRevision
         );
+
         return this.callV2(
             () => invokeNativeEditorV2('editorV2ApplyInput', this._editorId, requestJson),
             normalizeNativeEditorV2MutationOutcomeValue
@@ -282,10 +332,12 @@ export class NativeEditorDocumentBridge {
 
     applyCommand(request: NativeEditorCommandRequest): NativeEditorMutationOutcome {
         this.assertAlive();
+
         const requestJson = this.buildEnvelopeJson(
             { command: request.command },
             request.baseDocumentRevision
         );
+
         return this.callV2(
             () => invokeNativeEditorV2('editorV2ApplyCommand', this._editorId, requestJson),
             normalizeNativeEditorV2MutationOutcomeValue
@@ -295,14 +347,23 @@ export class NativeEditorDocumentBridge {
     applyLocalApi(request: NativeEditorLocalApiRequest): NativeEditorMutationOutcome {
         this.assertAlive();
         const payload: Record<string, unknown> = {};
-        if (request.setJson !== undefined) payload.setJson = request.setJson;
-        if (request.setHtml !== undefined) payload.setHtml = request.setHtml;
+
+        if (request.setJson !== undefined) {
+            payload.setJson = request.setJson;
+        }
+
+        if (request.setHtml !== undefined) {
+            payload.setHtml = request.setHtml;
+        }
+
         payload.history = request.history;
         const requestJson = this.buildEnvelopeJson(payload, request.baseDocumentRevision);
+
         const result = this.callV2(
             () => invokeNativeEditorV2('editorV2ApplyLocalApi', this._editorId, requestJson),
             normalizeNativeEditorV2MutationOutcomeValue
         );
+
         if (request.history === 'resetAndClear' && 'documentRevision' in result) {
             this._pendingViewReset = {
                 json: JSON.stringify({ ...payload, documentRevision: result.documentRevision }),
@@ -310,15 +371,18 @@ export class NativeEditorDocumentBridge {
         } else {
             this._pendingViewReset = null;
         }
+
         return result;
     }
 
     setSelection(request: NativeEditorSelectionRequest): NativeEditorMutationOutcome {
         this.assertAlive();
+
         const requestJson = this.buildEnvelopeJson(
             { selection: request.selection },
             request.baseDocumentRevision
         );
+
         return this.callV2(
             () => invokeNativeEditorV2('editorV2SetSelection', this._editorId, requestJson),
             normalizeNativeEditorV2MutationOutcomeValue
@@ -328,6 +392,7 @@ export class NativeEditorDocumentBridge {
     undo(): boolean {
         this.assertAlive();
         const requestJson = this.buildEnvelopeJson({});
+
         return this.callV2(
             () => invokeNativeEditorV2('editorV2Undo', this._editorId, requestJson),
             normalizeNativeEditorV2ChangedValue
@@ -337,6 +402,7 @@ export class NativeEditorDocumentBridge {
     redo(): boolean {
         this.assertAlive();
         const requestJson = this.buildEnvelopeJson({});
+
         return this.callV2(
             () => invokeNativeEditorV2('editorV2Redo', this._editorId, requestJson),
             normalizeNativeEditorV2ChangedValue
@@ -356,6 +422,7 @@ export class NativeEditorDocumentBridge {
     ): NativeEditorCommitInfo {
         this.assertAlive();
         const bytes = requireV2Bytes(encodedState, 'snapshot encodedState');
+
         return this.callV2(
             () =>
                 invokeNativeEditorV2(
@@ -373,13 +440,16 @@ export class NativeEditorDocumentBridge {
         const wireConfig = config === null ? null : collaborationTransportWireConfig(config);
         const previousAdapter = this._collaborationProtocolAdapter;
         const nextAdapter = config?.protocolAdapter ?? null;
+
         if (nextAdapter !== null && this._collaborationProtocolAdapterSubscription === null) {
             this._collaborationProtocolAdapterSubscription = getNativeModule().addListener(
                 'onCollaborationTransportEvent',
-                (rawEvent) => this.handleCollaborationProtocolAdapterEvent(rawEvent)
+                rawEvent => this.handleCollaborationProtocolAdapterEvent(rawEvent)
             );
         }
+
         this._collaborationProtocolAdapter = nextAdapter;
+
         try {
             this.callV2(
                 () =>
@@ -392,6 +462,7 @@ export class NativeEditorDocumentBridge {
             );
         } catch (error) {
             this._collaborationProtocolAdapter = previousAdapter;
+
             if (
                 previousAdapter === null &&
                 this._collaborationProtocolAdapterSubscription !== null
@@ -399,8 +470,10 @@ export class NativeEditorDocumentBridge {
                 this._collaborationProtocolAdapterSubscription.remove();
                 this._collaborationProtocolAdapterSubscription = null;
             }
+
             throw error;
         }
+
         if (nextAdapter === null && this._collaborationProtocolAdapterSubscription !== null) {
             this._collaborationProtocolAdapterSubscription.remove();
             this._collaborationProtocolAdapterSubscription = null;
@@ -408,27 +481,38 @@ export class NativeEditorDocumentBridge {
     }
 
     private handleCollaborationProtocolAdapterEvent(rawEvent: unknown): void {
-        if (this._destroyed || this._collaborationProtocolAdapter === null) return;
+        if (this._destroyed || this._collaborationProtocolAdapter === null) {
+            return;
+        }
+
         const event = normalizeNativeCollaborationTransportEvent(rawEvent);
+
         if (event?.editorId !== this._editorId || event.kind !== 'protocolAdapter') {
             return;
         }
+
         const adapter = this._collaborationProtocolAdapter;
+
         const context: NativeCollaborationProtocolAdapterContext = {
             attemptId: event.attemptId,
             generation: event.generation,
             negotiatedProtocol: event.negotiatedProtocol,
         };
+
         const callback =
             event.phase === 'open'
                 ? () => adapter.onOpen(context)
                 : () => adapter.onMessage(context, event.frame!);
+
         void Promise.resolve()
             .then(callback)
-            .then((result) => serializeCollaborationProtocolAdapterResult(result))
+            .then(result => serializeCollaborationProtocolAdapterResult(result))
             .catch(() => '{"action":"reject"}')
-            .then((responseJson) => {
-                if (this._destroyed) return;
+            .then(responseJson => {
+                if (this._destroyed) {
+                    return;
+                }
+
                 try {
                     this.callV2(
                         () =>
@@ -451,10 +535,12 @@ export class NativeEditorDocumentBridge {
 
     setLocalAwareness(intent: NativeEditorLocalAwarenessIntent | null): void {
         this.assertAlive();
+
         const awarenessJson =
             intent === null
                 ? 'null'
                 : serializeLocalAwarenessIntent(validateLocalAwarenessIntent(intent));
+
         this.callV2(
             () =>
                 invokeNativeEditorV2(
@@ -470,16 +556,22 @@ export class NativeEditorDocumentBridge {
         listener: (event: NativeCollaborationTransportEvent) => void
     ): () => void {
         this.assertAlive();
+
         const subscription = getNativeModule().addListener(
             'onCollaborationTransportEvent',
-            (rawEvent) => {
-                if (this._destroyed) return;
+            rawEvent => {
+                if (this._destroyed) {
+                    return;
+                }
+
                 const event = normalizeNativeCollaborationTransportEvent(rawEvent);
+
                 if (event?.editorId === this._editorId) {
                     listener(event);
                 }
             }
         );
+
         return () => subscription.remove();
     }
 }

package/src/NativeEditorDocumentHandle.ts

@@ -1,5 +1,5 @@
 import { type ResolvedDocumentSchema } from './schemas';
-import { NativeEditorErrorBase } from './NativeEditorBoundaryError';
+import { type NativeEditorErrorBase } from './NativeEditorBoundaryError';
 import { NativeEditorDocumentBridge } from './NativeEditorDocumentBridge';
 import {
     type NativeCollaborationTransportConfig,
@@ -34,8 +34,8 @@ export const NATIVE_EDITOR_DOCUMENT_HANDLE_DESCRIPTORS = new WeakMap<
  * One native document session, shared by everything that touches the
  * document: the editor view, the headless `useNativeEditorDocument` binding,
  * and the collaboration controller. Obtain one from
- * {@link createNativeEditorDocumentHandle} — it cannot be constructed
- * directly — and `destroy()` it when its owner unmounts.
+ * {@link createNativeEditorDocumentHandle} : it cannot be constructed
+ * directly : and `destroy()` it when its owner unmounts.
  */
 export interface NativeEditorDocumentHandle {
     readonly [NATIVE_EDITOR_DOCUMENT_HANDLE_BRAND]: true;
@@ -72,6 +72,7 @@ export class NativeEditorDocumentHandleImpl implements NativeEditorDocumentHandl
                 'NativeEditorBridge: NativeEditorDocumentHandle cannot be constructed directly'
             );
         }
+
         AUTHENTIC_NATIVE_EDITOR_DOCUMENT_HANDLES.add(this);
         NATIVE_EDITOR_DOCUMENT_HANDLE_DESCRIPTORS.set(this, documentDescriptor);
     }
@@ -109,11 +110,13 @@ export function _getNativeEditorDocumentHandleDescriptor(
 ): ResolvedDocumentSchema {
     _assertNativeEditorDocumentHandle(handle);
     const documentDescriptor = NATIVE_EDITOR_DOCUMENT_HANDLE_DESCRIPTORS.get(handle);
+
     if (documentDescriptor === undefined) {
         throw invalidV2RequestError(
             'NativeEditorBridge: authentic NativeEditorDocumentHandle has no document descriptor'
         );
     }
+
     return documentDescriptor;
 }
 
@@ -134,7 +137,7 @@ export function _assertNativeEditorDocumentHandle(
 
 /**
  * Create the native document session every other API binds to. Create it once
- * per document — `useMemo`, not on each render — and destroy it when its
+ * per document : `useMemo`, not on each render : and destroy it when its
  * owner unmounts.
  *
  * @throws NativeEditorErrorBase when the config is rejected: a malformed
@@ -155,10 +158,12 @@ export function createNativeEditorDocumentHandle(
     config: NativeEditorCreateConfig
 ): NativeEditorDocumentHandle {
     const { configJson, snapshotState, documentDescriptor } = buildV2CreateRequest(config);
+
     const value = unwrapNativeEditorV2Result(
         invokeNativeEditorV2('editorV2Create', configJson, snapshotState),
         normalizeNativeEditorV2CreateValue
     );
+
     return new NativeEditorDocumentHandleImpl(
         NATIVE_EDITOR_DOCUMENT_HANDLE_TOKEN,
         value.editorId,

package/src/NativeEditorLocalAwareness.ts

@@ -6,7 +6,7 @@ import {
 } from './NativeEditorTypes';
 import { normalizeV2JsonValue, serializeV2CreateEnvelope } from './NativeEditorCreateJson';
 
-export const LOCAL_AWARENESS_INTENT_KEYS = new Set(['state', 'focused', 'selection']);
+export const LOCAL_AWARENESS_INTENT_KEYS = new Set([ 'state', 'focused', 'selection' ]);
 
 export const LOCAL_AWARENESS_SELECTION_VALUES = new WeakMap<
     object,
@@ -28,26 +28,37 @@ export function createNativeEditorLocalAwarenessSelection(
 ): NativeEditorLocalAwarenessSelection {
     const acceptedAnchor = nativeEditorV2U32(anchor);
     const acceptedHead = nativeEditorV2U32(head);
-    if (acceptedAnchor == null || acceptedHead == null) invalidLocalAwarenessIntent();
+
+    if (acceptedAnchor == null || acceptedHead == null) {
+        invalidLocalAwarenessIntent();
+    }
 
     const selection: NativeEditorLocalAwarenessSelection =
         new NativeEditorLocalAwarenessSelectionValue(acceptedAnchor, acceptedHead);
+
     Object.freeze(selection);
     LOCAL_AWARENESS_SELECTION_VALUES.set(selection, selection);
+
     return selection;
 }
 
 export function isLocalAwarenessRecord(value: unknown): value is Record<string, unknown> {
-    if (value == null || typeof value !== 'object' || Array.isArray(value)) return false;
+    if (value == null || typeof value !== 'object' || Array.isArray(value)) {
+        return false;
+    }
+
     const prototype = Object.getPrototypeOf(value);
+
     return prototype === Object.prototype || prototype === null;
 }
 
 export function localAwarenessOwnDataValue(record: Record<string, unknown>, key: string): unknown {
     const descriptor = Object.getOwnPropertyDescriptor(record, key);
+
     if (descriptor === undefined || !('value' in descriptor) || descriptor.enumerable !== true) {
         invalidLocalAwarenessIntent();
     }
+
     return descriptor.value;
 }
 
@@ -55,35 +66,58 @@ export function validateLocalAwarenessSelection(selection: unknown): {
     anchor: number;
     head: number;
 } {
-    if (selection == null || typeof selection !== 'object') invalidLocalAwarenessIntent();
+    if (selection == null || typeof selection !== 'object') {
+        invalidLocalAwarenessIntent();
+    }
 
     // Do not inspect caller-held values before provenance succeeds: a Proxy
     // can imitate every structural and own-data check, but it cannot inherit
     // this module's WeakMap identity.
     const factoryValue = LOCAL_AWARENESS_SELECTION_VALUES.get(selection);
-    if (factoryValue === undefined) invalidLocalAwarenessIntent();
+
+    if (factoryValue === undefined) {
+        invalidLocalAwarenessIntent();
+    }
 
     const anchor = nativeEditorV2U32(factoryValue.anchor);
     const head = nativeEditorV2U32(factoryValue.head);
+
     if (anchor == null || head == null) {
         invalidLocalAwarenessIntent();
     }
+
     return { anchor, head };
 }
 
 /** Reject caller-owned sticky cursor data before a native call can occur. */
 export function rejectReservedAwarenessCursor(value: unknown): void {
-    const pending: unknown[] = [value];
+    const pending: unknown[] = [ value ];
     const seen = new WeakSet<object>();
+
     while (pending.length > 0) {
         const current = pending.pop();
-        if (current == null || typeof current !== 'object') continue;
-        if (seen.has(current)) continue;
+
+        if (current == null || typeof current !== 'object') {
+            continue;
+        }
+
+        if (seen.has(current)) {
+            continue;
+        }
+
         seen.add(current);
+
         for (const key of Reflect.ownKeys(current)) {
-            if (key === 'cursor') invalidLocalAwarenessIntent('reserved cursor key is not allowed');
+            if (key === 'cursor') {
+                invalidLocalAwarenessIntent('reserved cursor key is not allowed');
+            }
+
             const descriptor = Object.getOwnPropertyDescriptor(current, key);
-            if (descriptor == null || !('value' in descriptor)) invalidLocalAwarenessIntent();
+
+            if (descriptor == null || !('value' in descriptor)) {
+                invalidLocalAwarenessIntent();
+            }
+
             pending.push(descriptor.value);
         }
     }
@@ -95,13 +129,19 @@ export function normalizeLocalAwarenessState(value: unknown): Record<string, unk
             seen: new WeakSet<object>(),
             work: 0,
         });
+
         if (!isLocalAwarenessRecord(normalized) || Object.getPrototypeOf(normalized) !== null) {
             invalidLocalAwarenessIntent();
         }
+
         rejectReservedAwarenessCursor(normalized);
+
         return normalized;
     } catch (error) {
-        if (error instanceof NativeEditorEngineBoundaryError) throw error;
+        if (error instanceof NativeEditorEngineBoundaryError) {
+            throw error;
+        }
+
         invalidLocalAwarenessIntent();
     }
 }
@@ -120,27 +160,40 @@ export function validateLocalAwarenessIntent(
         if (
             !isLocalAwarenessRecord(intent) ||
             Reflect.ownKeys(intent).some(
-                (key) => typeof key !== 'string' || !LOCAL_AWARENESS_INTENT_KEYS.has(key)
+                key => typeof key !== 'string' || !LOCAL_AWARENESS_INTENT_KEYS.has(key)
             ) ||
             !Object.prototype.hasOwnProperty.call(intent, 'state') ||
             !Object.prototype.hasOwnProperty.call(intent, 'focused')
         ) {
             invalidLocalAwarenessIntent();
         }
+
         const state = normalizeLocalAwarenessState(localAwarenessOwnDataValue(intent, 'state'));
         const focused = localAwarenessOwnDataValue(intent, 'focused');
-        if (typeof focused !== 'boolean') invalidLocalAwarenessIntent();
+
+        if (typeof focused !== 'boolean') {
+            invalidLocalAwarenessIntent();
+        }
 
         if (!Object.prototype.hasOwnProperty.call(intent, 'selection')) {
             // Absent: retain whatever cursor Rust already holds.
             return { state, focused };
         }
+
         const rawSelection = localAwarenessOwnDataValue(intent, 'selection');
-        if (rawSelection === null) return { state, focused, selection: null };
+
+        if (rawSelection === null) {
+            return { state, focused, selection: null };
+        }
+
         const selection = validateLocalAwarenessSelection(rawSelection);
+
         return { state, focused, selection: { type: 'text', ...selection } };
     } catch (error) {
-        if (error instanceof NativeEditorEngineBoundaryError) throw error;
+        if (error instanceof NativeEditorEngineBoundaryError) {
+            throw error;
+        }
+
         invalidLocalAwarenessIntent();
     }
 }
@@ -152,6 +205,7 @@ export function serializeLocalAwarenessIntent(
         const wire = Object.create(null) as Record<string, unknown>;
         wire.state = intent.state;
         wire.focused = intent.focused;
+
         if (intent.selection === null) {
             wire.selection = null;
         } else if (intent.selection !== undefined) {
@@ -161,6 +215,7 @@ export function serializeLocalAwarenessIntent(
             selection.head = intent.selection.head;
             wire.selection = selection;
         }
+
         return serializeV2CreateEnvelope(wire);
     } catch {
         invalidLocalAwarenessIntent();