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

package/src/NativeEditorCreateConfig.ts

@@ -3,7 +3,7 @@ import {
     type ResolvedDocumentSchema,
     type SchemaDefinition,
 } from './schemas';
-import { type EditorResourceLimits } from './ResourceLimits';
+
 import {
     normalizeV2CreateRecord,
     V2_CREATE_POLICY_KEYS,
@@ -36,6 +36,7 @@ import { requireV2Bytes, invalidV2RequestError } from './NativeEditorResultNorma
 export function normalizeV2CreatePolicy(value: Record<string, unknown>): Record<string, unknown> {
     const policy = normalizeV2CreateRecord(value, V2_CREATE_POLICY_KEYS, 'policy');
     const maxLength = ownV2CreateValue(policy, 'maxLength');
+
     if (
         maxLength !== undefined &&
         (typeof maxLength !== 'number' ||
@@ -45,16 +46,21 @@ export function normalizeV2CreatePolicy(value: Record<string, unknown>): Record<
     ) {
         invalidV2JsonValue('policy.maxLength');
     }
-    for (const key of ['readOnly', 'allowBase64Images']) {
+
+    for (const key of [ 'readOnly', 'allowBase64Images' ]) {
         const value = ownV2CreateValue(policy, key);
+
         if (value !== undefined && typeof value !== 'boolean') {
             invalidV2JsonValue(`policy.${key}`);
         }
     }
+
     const inputFilter = ownV2CreateValue(policy, 'inputFilter');
+
     if (inputFilter !== undefined && typeof inputFilter !== 'string') {
         invalidV2JsonValue('policy.inputFilter');
     }
+
     return policy;
 }
 
@@ -64,7 +70,9 @@ export function normalizeV2SnapshotMetadata(value: unknown): Record<string, unkn
         V2_CREATE_SNAPSHOT_METADATA_KEYS,
         'snapshot metadata'
     );
+
     const formatVersion = ownV2CreateValue(metadata, 'formatVersion');
+
     if (
         typeof formatVersion !== 'number' ||
         !Number.isSafeInteger(formatVersion) ||
@@ -73,11 +81,13 @@ export function normalizeV2SnapshotMetadata(value: unknown): Record<string, unkn
     ) {
         invalidV2JsonValue('snapshot metadata.formatVersion');
     }
-    for (const key of ['documentId', 'lineageId', 'fragmentName', 'schemaFingerprint']) {
+
+    for (const key of [ 'documentId', 'lineageId', 'fragmentName', 'schemaFingerprint' ]) {
         if (typeof ownV2CreateValue(metadata, key) !== 'string') {
             invalidV2JsonValue(`snapshot metadata.${key}`);
         }
     }
+
     return metadata;
 }
 
@@ -89,17 +99,21 @@ export function buildV2CreateRequestUnchecked(config: NativeEditorCreateConfig):
     if (!isV2CreateRecord(config)) {
         throw invalidV2CreateRequestError('NativeEditorBridge: invalid v2 create config');
     }
+
     requireKnownV2CreateKeys(config, V2_CREATE_CONFIG_KEYS, 'config');
     const initializationValue = ownV2CreateValue(config, 'initialization');
+
     if (!isV2CreateRecord(initializationValue)) {
         throw invalidV2CreateRequestError('NativeEditorBridge: invalid v2 create config');
     }
+
     const jsonTraversal: V2JsonNormalizationTraversal = {
         seen: new WeakSet<object>(),
         work: 0,
     };
 
     const policyValue = ownV2CreateValue(config, 'policy');
+
     const policy =
         policyValue === undefined
             ? undefined
@@ -107,15 +121,18 @@ export function buildV2CreateRequestUnchecked(config: NativeEditorCreateConfig):
 
     const limitsValue = ownV2CreateValue(config, 'limits');
     let limits: Record<string, unknown> | undefined;
+
     if (limitsValue !== undefined) {
         requireKnownV2CreateKeys(limitsValue, V2_CREATE_LIMIT_KEYS, 'limits');
         limits = emptyV2CreateRecord();
-        for (const [group, keys] of [
-            ['resource', V2_CREATE_RESOURCE_LIMIT_KEYS],
-            ['editing', V2_CREATE_EDITING_LIMIT_KEYS],
-            ['collaboration', V2_CREATE_COLLABORATION_LIMIT_KEYS],
+
+        for (const [ group, keys ] of [
+            [ 'resource', V2_CREATE_RESOURCE_LIMIT_KEYS ],
+            [ 'editing', V2_CREATE_EDITING_LIMIT_KEYS ],
+            [ 'collaboration', V2_CREATE_COLLABORATION_LIMIT_KEYS ],
         ] as const) {
             const overrides = ownV2CreateValue(limitsValue, group);
+
             if (overrides !== undefined) {
                 limits[group] = normalizeV2CreateRecord(
                     overrides as Record<string, unknown>,
@@ -125,34 +142,47 @@ export function buildV2CreateRequestUnchecked(config: NativeEditorCreateConfig):
             }
         }
     }
+
     const envelope = emptyV2CreateRecord();
     const schema = ownV2CreateValue(config, 'schema');
+
     if (schema === null) {
         throw invalidV2CreateRequestError('NativeEditorBridge: invalid schema for v2 create');
     }
+
     if (schema !== undefined) {
         if (!isV2CreateRecord(schema)) {
             throw invalidV2CreateRequestError('NativeEditorBridge: invalid schema for v2 create');
         }
+
         envelope.schema = normalizeV2JsonValue(schema, 'schema', jsonTraversal);
     }
+
     const fragmentName = ownV2CreateValue(config, 'fragmentName');
+
     if (fragmentName !== undefined && typeof fragmentName !== 'string') {
         throw invalidV2CreateRequestError('NativeEditorBridge: invalid fragmentName for v2 create');
     }
-    if (fragmentName !== undefined) envelope.fragmentName = fragmentName;
+
+    if (fragmentName !== undefined) {
+        envelope.fragmentName = fragmentName;
+    }
 
     let snapshotState: Uint8Array | null = null;
     const initialization = initializationValue;
     const initializationType = ownV2CreateValue(initialization, 'type');
+
     const initializationKeys =
         typeof initializationType === 'string'
             ? V2_CREATE_INITIALIZATION_KEYS[initializationType]
             : undefined;
+
     if (initializationKeys === undefined) {
         throw invalidV2CreateRequestError('NativeEditorBridge: unknown v2 initialization type');
     }
+
     requireKnownV2CreateKeys(initialization, initializationKeys, 'initialization');
+
     switch (initializationType) {
         case 'localEmpty': {
             const localEmpty = emptyV2CreateRecord();
@@ -160,74 +190,97 @@ export function buildV2CreateRequestUnchecked(config: NativeEditorCreateConfig):
             envelope.initialization = localEmpty;
             break;
         }
+
         case 'localJson': {
             const json = ownV2CreateValue(initialization, 'json');
+
             if (!isV2CreateRecord(json)) {
                 throw invalidV2CreateRequestError(
                     'NativeEditorBridge: invalid localJson initialization for v2 create'
                 );
             }
+
             const localJson = emptyV2CreateRecord();
             localJson.type = 'localJson';
             localJson.json = normalizeV2JsonValue(json, 'localJson initialization', jsonTraversal);
             envelope.initialization = localJson;
             break;
         }
+
         case 'localHtml': {
             const html = ownV2CreateValue(initialization, 'html');
+
             if (typeof html !== 'string') {
                 throw invalidV2CreateRequestError(
                     'NativeEditorBridge: invalid localHtml initialization for v2 create'
                 );
             }
+
             const localHtml = emptyV2CreateRecord();
             localHtml.type = 'localHtml';
             localHtml.html = html;
             envelope.initialization = localHtml;
             break;
         }
+
         case 'room': {
             const documentId = ownV2CreateValue(initialization, 'documentId');
             const lineageId = ownV2CreateValue(initialization, 'lineageId');
+
             if (typeof documentId !== 'string' || typeof lineageId !== 'string') {
                 throw invalidV2CreateRequestError(
                     'NativeEditorBridge: invalid room initialization for v2 create'
                 );
             }
+
             const room = emptyV2CreateRecord();
             room.type = 'room';
             room.documentId = documentId;
             room.lineageId = lineageId;
             const snapshot = ownV2CreateValue(initialization, 'snapshot');
+
             if (snapshot !== undefined) {
                 requireKnownV2CreateKeys(snapshot, V2_CREATE_ROOM_SNAPSHOT_KEYS, 'room snapshot');
                 const metadataValue = ownV2CreateValue(snapshot, 'metadata');
                 const metadata = normalizeV2SnapshotMetadata(metadataValue);
                 room.snapshot = metadata;
+
                 snapshotState = requireV2Bytes(
                     ownV2CreateValue(snapshot, 'encodedState'),
                     'snapshot encodedState'
                 );
             }
+
             envelope.initialization = room;
             break;
         }
+
         default:
             throw invalidV2CreateRequestError('NativeEditorBridge: unknown v2 initialization type');
     }
-    if (policy !== undefined) envelope.policy = policy;
-    if (limits !== undefined) envelope.limits = limits;
+
+    if (policy !== undefined) {
+        envelope.policy = policy;
+    }
+
+    if (limits !== undefined) {
+        envelope.limits = limits;
+    }
+
     return {
         envelope,
-        limits: limits as NativeEditorCreateConfig['limits'],
+        limits,
         snapshotState,
     };
 }
 
 export function cloneAndFreezeDescriptorValue<T>(value: T): T {
-    if (value == null || typeof value !== 'object') return value;
+    if (value == null || typeof value !== 'object') {
+        return value;
+    }
 
     type MutableDescriptorValue = Record<string, unknown>;
+
     const setOwnValue = (target: MutableDescriptorValue, key: string, child: unknown): void => {
         Object.defineProperty(target, key, {
             value: child,
@@ -236,41 +289,55 @@ export function cloneAndFreezeDescriptorValue<T>(value: T): T {
             configurable: true,
         });
     };
+
     const cloneRoot: MutableDescriptorValue = (
         Array.isArray(value) ? [] : {}
     ) as MutableDescriptorValue;
-    const clones = new Map<object, MutableDescriptorValue>([[value, cloneRoot]]);
+
+    const clones = new Map<object, MutableDescriptorValue>([ [ value, cloneRoot ] ]);
+
     const pending: Array<{
         source: Record<string, unknown>;
         target: MutableDescriptorValue;
-    }> = [{ source: value as Record<string, unknown>, target: cloneRoot }];
-    const created = [cloneRoot];
+    }> = [ { source: value as Record<string, unknown>, target: cloneRoot } ];
+
+    const created = [ cloneRoot ];
 
     while (pending.length > 0) {
         const current = pending.pop();
-        if (current === undefined) break;
+
+        if (current === undefined) {
+            break;
+        }
+
         const keys = Array.isArray(current.source)
             ? Array.from({ length: (current.source as unknown[]).length }, (_, index) =>
-                  String(index)
-              )
+                String(index))
             : Object.keys(current.source);
+
         for (const key of keys) {
             const child = current.source[key];
+
             if (child == null || typeof child !== 'object') {
                 setOwnValue(current.target, key, child);
                 continue;
             }
+
             const existing = clones.get(child);
+
             if (existing !== undefined) {
                 setOwnValue(current.target, key, existing);
                 continue;
             }
+
             const childClone: MutableDescriptorValue = (
                 Array.isArray(child) ? [] : {}
             ) as MutableDescriptorValue;
+
             clones.set(child, childClone);
             created.push(childClone);
             setOwnValue(current.target, key, childClone);
+
             pending.push({
                 source: child as Record<string, unknown>,
                 target: childClone,
@@ -281,6 +348,7 @@ export function cloneAndFreezeDescriptorValue<T>(value: T): T {
     for (let index = created.length - 1; index >= 0; index -= 1) {
         Object.freeze(created[index]);
     }
+
     return cloneRoot as T;
 }
 
@@ -300,6 +368,7 @@ export function buildV2CreateRequest(config: NativeEditorCreateConfig): {
     documentDescriptor: ResolvedDocumentSchema;
 } {
     let normalized: ReturnType<typeof buildV2CreateRequestUnchecked>;
+
     try {
         normalized = buildV2CreateRequestUnchecked(config);
     } catch (error) {
@@ -307,18 +376,22 @@ export function buildV2CreateRequest(config: NativeEditorCreateConfig): {
             error instanceof NativeEditorCreateConfigError
                 ? error.message
                 : 'NativeEditorBridge: invalid v2 create config';
+
         throw invalidV2RequestError(message);
     }
 
     validateV2CreateLimits(normalized.limits);
+
     const documentDescriptor = cloneAndFreezeDocumentDescriptor(
         resolveDocumentDescriptor(
             normalized.envelope.schema as SchemaDefinition | undefined,
-            normalized.limits?.resource as EditorResourceLimits | undefined
+            normalized.limits?.resource
         )
     );
+
     try {
         const configJson = serializeV2CreateEnvelope(normalized.envelope);
+
         return { configJson, snapshotState: normalized.snapshotState, documentDescriptor };
     } catch {
         throw invalidV2RequestError('NativeEditorBridge: invalid v2 create config');