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

package/src/NativeEditorNativeModule.ts

@@ -7,6 +7,7 @@ export function getNativeModule(): NativeEditorModule {
     if (!_nativeModule) {
         _nativeModule = requireNativeModule<NativeEditorModule>('NativeEditor');
     }
+
     return _nativeModule;
 }
 
@@ -15,12 +16,13 @@ export function _resetNativeModuleCache(): void {
     _nativeModule = null;
 }
 
-// The only construction path. Consumes the frozen v2 result records
-// ({ value, error }, exactly one side set), normalizes them at the JS boundary
-// (decimal-string u64s, direct binaries, unsafe-integer rejection), and raises
-// typed per-domain errors with a non-retryable class for
-// ENGINE_INVARIANT_FAILED and destroyed lifecycles.
-
+/**
+ * The only construction path. Consumes the frozen v2 result records
+ * ({ value, error }, exactly one side set), normalizes them at the JS boundary
+ * (decimal-string u64s, direct binaries, unsafe-integer rejection), and raises
+ * typed per-domain errors with a non-retryable class for
+ * ENGINE_INVARIANT_FAILED and destroyed lifecycles.
+ */
 export const ERR_V2_NATIVE_RESPONSE =
     'NativeEditorBridge: invalid v2 result record from native module';
 
@@ -29,7 +31,7 @@ export const ERR_V2_DESTROYED = 'NativeEditorBridge: v2 editor handle has been d
 export const V2_ENVELOPE_VERSION = 1;
 
 /**
- * The v2 surface of the NativeEditor native module — the complete
+ * The v2 surface of the NativeEditor native module : the complete
  * production ABI. Every call resolves the method lazily and fails clearly
  * when the v2 surface is absent. Decimal-string identifiers keep full u64
  * fidelity across the JavaScript boundary, and binaries travel as direct
@@ -81,13 +83,15 @@ export function invokeNativeEditorV2<K extends keyof NativeEditorModule>(
     name: K,
     ...args: Parameters<NativeEditorModule[K]>
 ): unknown {
-    const nativeModule = getNativeModule() as unknown as Record<string, unknown>;
-    const method = nativeModule[name as string];
+    const nativeModule = getNativeModule();
+    const method = nativeModule[name];
+
     if (typeof method !== 'function') {
         throw new Error(
             `NativeEditorBridge: native module does not expose the v2 entry ${String(name)}`
         );
     }
+
     return (method as (...fnArgs: unknown[]) => unknown).apply(nativeModule, args);
 }
 

package/src/NativeEditorRenderNormalization.ts

@@ -28,7 +28,10 @@ import {
 import { validEditorMentionTheme } from './EditorMentionThemeValidation';
 
 export function validListContext(value: unknown): value is ListContext {
-    if (!isPlainRecord(value)) return false;
+    if (!isPlainRecord(value)) {
+        return false;
+    }
+
     return (
         hasOnlyOwnKeys(value, [
             'ordered',
@@ -55,34 +58,43 @@ export function validRenderElement(value: unknown): value is RenderElement {
     if (!isPlainRecord(value) || !RENDER_ELEMENT_TYPES.has(value.type as RenderElement['type'])) {
         return false;
     }
+
     switch (value.type) {
         case 'textRun':
             return (
-                hasExactOwnKeys(value, ['type', 'text', 'marks']) &&
+                hasExactOwnKeys(value, [ 'type', 'text', 'marks' ]) &&
                 typeof value.text === 'string' &&
                 Array.isArray(value.marks) &&
                 value.marks.every(validRenderMark)
             );
         case 'blockStart':
             return (
-                hasOnlyOwnKeys(value, ['type', 'nodeType', 'depth', 'listContext', 'language']) &&
+                hasOnlyOwnKeys(value, [ 'type',
+                    'nodeType',
+                    'depth',
+                    'listContext',
+                    'language' ]) &&
                 typeof value.nodeType === 'string' &&
                 nativeEditorV2U32(value.depth) != null &&
                 (value.language === undefined || typeof value.language === 'string') &&
                 (value.listContext === undefined || validListContext(value.listContext))
             );
         case 'blockEnd':
-            return hasExactOwnKeys(value, ['type']);
+            return hasExactOwnKeys(value, [ 'type' ]);
         case 'voidInline':
             return (
-                hasOnlyOwnKeys(value, ['type', 'nodeType', 'docPos', 'attrs']) &&
+                hasOnlyOwnKeys(value, [ 'type', 'nodeType', 'docPos', 'attrs' ]) &&
                 typeof value.nodeType === 'string' &&
                 nativeEditorV2U32(value.docPos) != null &&
                 (value.attrs === undefined || isPlainRecord(value.attrs))
             );
         case 'voidBlock':
             return (
-                hasOnlyOwnKeys(value, ['type', 'nodeType', 'docPos', 'attrs', 'atomId']) &&
+                hasOnlyOwnKeys(value, [ 'type',
+                    'nodeType',
+                    'docPos',
+                    'attrs',
+                    'atomId' ]) &&
                 typeof value.nodeType === 'string' &&
                 nativeEditorV2U32(value.docPos) != null &&
                 (value.attrs === undefined || isPlainRecord(value.attrs)) &&
@@ -106,27 +118,38 @@ export function validRenderElement(value: unknown): value is RenderElement {
             );
         case 'opaqueBlockAtom':
             return (
-                hasOnlyOwnKeys(value, ['type', 'nodeType', 'label', 'docPos', 'attrs']) &&
+                hasOnlyOwnKeys(value, [ 'type',
+                    'nodeType',
+                    'label',
+                    'docPos',
+                    'attrs' ]) &&
                 typeof value.nodeType === 'string' &&
                 typeof value.label === 'string' &&
                 nativeEditorV2U32(value.docPos) != null &&
                 (value.attrs === undefined || isPlainRecord(value.attrs))
             );
     }
+
     return false;
 }
 
 export function normalizeRenderBlocks(value: unknown): RenderElement[][] | null {
-    if (!Array.isArray(value)) return null;
+    if (!Array.isArray(value)) {
+        return null;
+    }
+
     return value.every(
-        (block) => Array.isArray(block) && block.every((element) => validRenderElement(element))
+        block => Array.isArray(block) && block.every(element => validRenderElement(element))
     )
-        ? (value as RenderElement[][])
+        ? (value)
         : null;
 }
 
 export function normalizeRenderPatch(value: unknown): RenderBlocksPatch | null | undefined {
-    if (value === null) return null;
+    if (value === null) {
+        return null;
+    }
+
     if (
         !isPlainRecord(value) ||
         !hasExactOwnKeys(value, [
@@ -138,10 +161,12 @@ export function normalizeRenderPatch(value: unknown): RenderBlocksPatch | null |
     ) {
         return undefined;
     }
+
     const renderBlocks = normalizeRenderBlocks(value.renderBlocks);
     const baseDocumentVersion = normalizeNativeEditorV2DecimalId(value.baseDocumentVersion);
     const startIndex = nativeEditorV2U32(value.startIndex);
     const deleteCount = nativeEditorV2U32(value.deleteCount);
+
     if (
         renderBlocks == null ||
         baseDocumentVersion == null ||
@@ -150,36 +175,65 @@ export function normalizeRenderPatch(value: unknown): RenderBlocksPatch | null |
     ) {
         return undefined;
     }
+
     return { baseDocumentVersion, startIndex, deleteCount, renderBlocks };
 }
 
 export function normalizeRenderSelection(value: unknown): Selection | null {
-    if (!isPlainRecord(value)) return null;
-    if (value.type === 'all') return hasExactOwnKeys(value, ['type']) ? { type: 'all' } : null;
+    if (!isPlainRecord(value)) {
+        return null;
+    }
+
+    if (value.type === 'all') {
+        return hasExactOwnKeys(value, [ 'type' ]) ? { type: 'all' } : null;
+    }
+
     if (value.type === 'text') {
-        if (!hasExactOwnKeys(value, ['type', 'anchor', 'head', 'anchorScalar', 'headScalar'])) {
+        if (!hasExactOwnKeys(value, [ 'type',
+            'anchor',
+            'head',
+            'anchorScalar',
+            'headScalar' ])) {
             return null;
         }
+
         const anchor = nativeEditorV2U32(value.anchor);
         const head = nativeEditorV2U32(value.head);
         const anchorScalar = nativeEditorV2U32(value.anchorScalar);
         const headScalar = nativeEditorV2U32(value.headScalar);
-        if (anchor == null || head == null || anchorScalar == null || headScalar == null)
+
+        if (anchor == null || head == null || anchorScalar == null || headScalar == null) {
             return null;
-        return { type: 'text', anchor, head, anchorScalar, headScalar };
+        }
+
+        return {
+            type: 'text', anchor, head, anchorScalar, headScalar,
+        };
     }
+
     if (value.type === 'node') {
-        if (!hasExactOwnKeys(value, ['type', 'pos', 'posScalar'])) return null;
+        if (!hasExactOwnKeys(value, [ 'type', 'pos', 'posScalar' ])) {
+            return null;
+        }
+
         const pos = nativeEditorV2U32(value.pos);
         const posScalar = nativeEditorV2U32(value.posScalar);
-        if (pos == null || posScalar == null) return null;
+
+        if (pos == null || posScalar == null) {
+            return null;
+        }
+
         return { type: 'node', pos, posScalar };
     }
+
     return null;
 }
 
 export function normalizeRenderActiveState(value: unknown): ActiveState | null {
-    if (!isPlainRecord(value)) return null;
+    if (!isPlainRecord(value)) {
+        return null;
+    }
+
     if (
         !hasExactOwnKeys(value, [
             'marks',
@@ -199,13 +253,25 @@ export function normalizeRenderActiveState(value: unknown): ActiveState | null {
     ) {
         return null;
     }
-    return value as unknown as ActiveState;
+
+    return {
+        marks: value.marks,
+        markAttrs: value.markAttrs as ActiveState['markAttrs'],
+        nodes: value.nodes,
+        commands: value.commands,
+        allowedMarks: value.allowedMarks,
+        insertableNodes: value.insertableNodes,
+    };
 }
 
 export function normalizeRenderHistoryState(value: unknown): HistoryState | null {
-    if (!isPlainRecord(value) || !hasExactOwnKeys(value, ['canUndo', 'canRedo'])) return null;
+    if (!isPlainRecord(value) || !hasExactOwnKeys(value, [ 'canUndo', 'canRedo' ])) {
+        return null;
+    }
+
     const canUndo = optionalBoolean(value.canUndo);
     const canRedo = optionalBoolean(value.canRedo);
+
     return canUndo == null || canRedo == null ? null : { canUndo, canRedo };
 }
 
@@ -214,8 +280,10 @@ export function deepFreezeV2Value<T>(value: T): T {
         for (const child of Object.values(value as Record<string, unknown>)) {
             deepFreezeV2Value(child);
         }
+
         Object.freeze(value);
     }
+
     return value;
 }
 
@@ -224,7 +292,11 @@ export function normalizeNativeEditorV2RenderUpdateValue(
     value: unknown
 ): NativeEditorAtomicRenderSnapshot | null {
     const parsed = parseNativeEditorV2JsonValue(value);
-    if (!isPlainRecord(parsed)) return null;
+
+    if (!isPlainRecord(parsed)) {
+        return null;
+    }
+
     if (
         !hasExactOwnKeys(parsed, [
             'renderBlocks',
@@ -240,8 +312,10 @@ export function normalizeNativeEditorV2RenderUpdateValue(
     ) {
         return null;
     }
+
     const renderBlocks =
         parsed.renderBlocks === null ? null : normalizeRenderBlocks(parsed.renderBlocks);
+
     const renderPatch = normalizeRenderPatch(parsed.renderPatch);
     const selection = normalizeRenderSelection(parsed.selection);
     const activeState = normalizeRenderActiveState(parsed.activeState);
@@ -250,6 +324,7 @@ export function normalizeNativeEditorV2RenderUpdateValue(
     const stateRevision = normalizeRevisionField(parsed, 'stateRevision');
     const scalarLength = nativeEditorV2U32(parsed.scalarLength);
     const documentIsEmpty = parsed.documentIsEmpty;
+
     if (
         renderPatch === undefined ||
         selection == null ||
@@ -262,14 +337,23 @@ export function normalizeNativeEditorV2RenderUpdateValue(
     ) {
         return null;
     }
+
     let renderPayload: NativeEditorAtomicRenderPayload;
+
     if (renderBlocks == null) {
-        if (parsed.renderBlocks !== null || renderPatch == null) return null;
+        if (parsed.renderBlocks !== null || renderPatch == null) {
+            return null;
+        }
+
         renderPayload = { renderBlocks: null, renderPatch };
     } else {
-        if (renderPatch !== null) return null;
+        if (renderPatch !== null) {
+            return null;
+        }
+
         renderPayload = { renderBlocks, renderPatch: null };
     }
+
     return deepFreezeV2Value({
         ...renderPayload,
         selection,
@@ -284,17 +368,20 @@ export function normalizeNativeEditorV2RenderUpdateValue(
 
 export function normalizeNativeEditorV2DocumentJsonValue(value: unknown): DocumentJSON | null {
     const parsed = parseNativeEditorV2JsonValue(value);
-    return isPlainRecord(parsed) ? (parsed as DocumentJSON) : null;
+
+    return isPlainRecord(parsed) ? (parsed) : null;
 }
 
 export function normalizeNativeEditorV2ContentSnapshotValue(
     value: unknown
 ): ContentSnapshot | null {
     const parsed = parseNativeEditorV2JsonValue(value);
+
     if (!isPlainRecord(parsed) || typeof parsed.html !== 'string' || !isPlainRecord(parsed.json)) {
         return null;
     }
-    return { html: parsed.html, json: parsed.json as DocumentJSON };
+
+    return { html: parsed.html, json: parsed.json };
 }
 
 export interface NativeEditorSnapshotExport {
@@ -306,15 +393,27 @@ export interface NativeEditorSnapshotExport {
 export function normalizeNativeEditorV2SnapshotExportValue(
     value: unknown
 ): NativeEditorSnapshotExport | null {
-    if (!isPlainRecord(value) || typeof value.metadataJson !== 'string') return null;
+    if (!isPlainRecord(value) || typeof value.metadataJson !== 'string') {
+        return null;
+    }
+
     const encodedState = normalizeNativeEditorV2Bytes(value.encodedState);
-    if (encodedState == null) return null;
+
+    if (encodedState == null) {
+        return null;
+    }
+
     return { metadataJson: value.metadataJson, encodedState };
 }
 
 export function normalizeNativeEditorV2CreateValue(value: unknown): { editorId: string } | null {
     const parsed = parseNativeEditorV2JsonValue(value);
-    if (!isPlainRecord(parsed)) return null;
+
+    if (!isPlainRecord(parsed)) {
+        return null;
+    }
+
     const editorId = normalizeNativeEditorV2DecimalId(parsed.editorId);
+
     return editorId == null ? null : { editorId };
 }