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

package/src/atomUpdates.ts

@@ -2,14 +2,21 @@ import type { AtomAttrsUpdate } from './atoms';
 import { AtomUpdateAttrsError } from './atomInstances';
 
 function copyJson(value: unknown, ancestors = new Set<object>()): unknown {
-    if (value === null || typeof value === 'string' || typeof value === 'boolean') return value;
-    if (typeof value === 'number' && Number.isFinite(value)) return value;
+    if (value === null || typeof value === 'string' || typeof value === 'boolean') {
+        return value;
+    }
+
+    if (typeof value === 'number' && Number.isFinite(value)) {
+        return value;
+    }
+
     if (typeof value !== 'object' || ancestors.has(value) || ancestors.size > 128) {
         throw new AtomUpdateAttrsError(
             'not-applicable',
             'Atom attributes must contain finite JSON values.'
         );
     }
+
     if (
         !Array.isArray(value) &&
         Object.getPrototypeOf(value) !== Object.prototype &&
@@ -20,13 +27,17 @@ function copyJson(value: unknown, ancestors = new Set<object>()): unknown {
             'Atom attributes must contain plain JSON objects.'
         );
     }
+
     ancestors.add(value);
+
     const result = Array.isArray(value)
-        ? Array.from(value, (entry) => copyJson(entry, ancestors))
+        ? Array.from(value, entry => copyJson(entry, ancestors))
         : Object.fromEntries(
-              Object.entries(value).map(([key, entry]) => [key, copyJson(entry, ancestors)])
-          );
+            Object.entries(value).map(([ key, entry ]) => [ key, copyJson(entry, ancestors) ])
+        );
+
     ancestors.delete(value);
+
     return Object.freeze(result);
 }
 
@@ -36,17 +47,23 @@ export function resolveAtomAttrsUpdate(
 ): Record<string, unknown> {
     let current = copyJson(attrs) as Record<string, unknown>;
     let patch: Record<string, unknown> = {};
-    for (const entry of Array.isArray(update) ? update : [update]) {
+
+    const updates: readonly (Record<string, unknown> | ((current: Readonly<Record<string, unknown>>) => Record<string, unknown>))[] = Array.isArray(update) ? update : [ update ];
+
+    for (const entry of updates) {
         const value: unknown = typeof entry === 'function' ? entry(current) : entry;
+
         if (value == null || typeof value !== 'object' || Array.isArray(value)) {
             throw new AtomUpdateAttrsError(
                 'not-applicable',
                 'Atom updates must return an attribute object.'
             );
         }
+
         const partial = copyJson(value) as Record<string, unknown>;
         patch = { ...patch, ...partial };
         current = Object.freeze({ ...current, ...partial });
     }
+
     return patch;
 }

package/src/atoms.ts

@@ -128,8 +128,14 @@ export interface SerializedEditorAtoms {
 }
 
 function isAtomComponent(value: unknown): value is AtomComponent {
-    if (typeof value === 'function') return true;
-    if (value == null || typeof value !== 'object' || !('$$typeof' in value)) return false;
+    if (typeof value === 'function') {
+        return true;
+    }
+
+    if (value == null || typeof value !== 'object' || !('$$typeof' in value)) {
+        return false;
+    }
+
     return (
         value.$$typeof === Symbol.for('react.memo') ||
         value.$$typeof === Symbol.for('react.forward_ref') ||
@@ -153,13 +159,17 @@ function stringRecord(value: unknown, label: string): Record<string, string> {
     if (value == null || typeof value !== 'object' || Array.isArray(value)) {
         throw new Error(`${label} must be an object`);
     }
+
     const result: Record<string, string> = {};
-    for (const [key, entry] of Object.entries(value)) {
+
+    for (const [ key, entry ] of Object.entries(value)) {
         if (typeof entry !== 'string') {
             throw new Error(`${label} '${key}' must be a string`);
         }
+
         result[key] = entry;
     }
+
     return result;
 }
 
@@ -175,17 +185,23 @@ function normalizedHtmlRules(config: AtomNodeConfig<any>): NodeHtmlRules {
     if (config.html == null || typeof config.html !== 'object' || Array.isArray(config.html)) {
         throw new Error(`atom '${config.name}' requires HTML rules`);
     }
+
     const raw = config.html as NodeHtmlRules & Record<string, unknown>;
-    if (Object.keys(raw).some((key) => !['tag', 'staticAttrs', 'attrMap'].includes(key))) {
+
+    if (Object.keys(raw).some(key => ![ 'tag', 'staticAttrs', 'attrMap' ].includes(key))) {
         throw new Error(`atom '${config.name}' has an unknown HTML rule field`);
     }
+
     if (typeof raw.tag !== 'string' || !isSafeTag(raw.tag)) {
         throw new Error(`atom '${config.name}' has an invalid HTML tag '${String(raw.tag)}'`);
     }
+
     const staticAttrs = stringRecord(raw.staticAttrs, `atom '${config.name}' staticAttrs`);
+
     if (Object.keys(staticAttrs).length === 0) {
         throw new Error(`atom '${config.name}' requires a static attribute discriminator`);
     }
+
     for (const name of Object.keys(staticAttrs)) {
         if (!isSafeAttr(name)) {
             throw new Error(`atom '${config.name}' has an invalid HTML attribute '${name}'`);
@@ -193,35 +209,44 @@ function normalizedHtmlRules(config: AtomNodeConfig<any>): NodeHtmlRules {
     }
 
     const attrs = config.attrs ?? {};
+
     const attrMap =
         raw.attrMap == null
             ? Object.fromEntries(
-                  Object.keys(attrs).map((name) => [name, `data-${kebabCase(name)}`])
-              )
+                Object.keys(attrs).map(name => [ name, `data-${kebabCase(name)}` ])
+            )
             : stringRecord(raw.attrMap, `atom '${config.name}' attrMap`);
+
     for (const name of Object.keys(attrMap)) {
         if (!Object.prototype.hasOwnProperty.call(attrs, name)) {
             throw new Error(`atom '${config.name}' maps undeclared attribute '${name}'`);
         }
     }
+
     for (const name of Object.keys(attrs)) {
         if (!Object.prototype.hasOwnProperty.call(attrMap, name)) {
             throw new Error(`atom '${config.name}' attrMap is missing '${name}'`);
         }
     }
+
     const targets = new Set<string>();
+
     for (const target of Object.values(attrMap)) {
         if (!isSafeAttr(target)) {
             throw new Error(`atom '${config.name}' has an invalid HTML attribute '${target}'`);
         }
+
         if (targets.has(target)) {
             throw new Error(`atom '${config.name}' repeats HTML attribute '${target}'`);
         }
+
         if (Object.prototype.hasOwnProperty.call(staticAttrs, target)) {
             throw new Error(`atom '${config.name}' collides on HTML attribute '${target}'`);
         }
+
         targets.add(target);
     }
+
     return { tag: raw.tag, staticAttrs, attrMap };
 }
 
@@ -231,37 +256,49 @@ export function defineAtomNode<const S extends Record<string, AttrSpec>>(
 export function defineAtomNode<A = Record<string, unknown>>(
     config: AtomNodeConfig<A> & (string extends keyof A ? {} : { attrs: AtomAttributeSpecs<A> })
 ): AtomNodeDefinition<A, Required<A>>;
+
 export function defineAtomNode(config: AtomNodeConfig<any>): AtomNodeDefinition<any> {
     if (config == null || typeof config !== 'object') {
         throw new Error('atom config must be an object');
     }
+
     if (typeof config.name !== 'string' || config.name.length === 0) {
         throw new Error('atom name must be a non-empty string');
     }
+
     if (RESERVED_WIRE_NODE_TYPES.has(config.name)) {
         throw new Error(`atom name '${config.name}' is reserved`);
     }
+
     if (!isAtomComponent(config.component)) {
         throw new Error(`atom '${config.name}' requires a component`);
     }
+
     if (
         config.estimatedHeight != null &&
         (!Number.isFinite(config.estimatedHeight) || config.estimatedHeight < 0)
     ) {
         throw new Error(`atom '${config.name}' estimatedHeight must be non-negative`);
     }
-    if ('allowUndeclaredAttrs' in (config as unknown as Record<string, unknown>)) {
+
+    if ('allowUndeclaredAttrs' in config) {
         throw new Error(`atom '${config.name}' cannot allow undeclared attributes`);
     }
+
     if (config.attrs != null && (typeof config.attrs !== 'object' || Array.isArray(config.attrs))) {
         throw new Error(`atom '${config.name}' attrs must be an object`);
     }
 
-    for (const [name, spec] of Object.entries(config.attrs ?? {}))
+    for (const [ name, spec ] of Object.entries(config.attrs ?? {})) {
         validateAttributeSpec(spec, name);
-    if (config.idAttribute !== undefined && config.attrs?.[config.idAttribute]?.type !== 'string')
+    }
+
+    if (config.idAttribute !== undefined && config.attrs?.[config.idAttribute]?.type !== 'string') {
         throw new Error(`atom '${config.name}' identifier attribute must declare type string`);
+    }
+
     const html = normalizedHtmlRules(config);
+
     const nodeSpec: NodeSpec = {
         name: config.name,
         content: '',
@@ -271,6 +308,7 @@ export function defineAtomNode(config: AtomNodeConfig<any>): AtomNodeDefinition<
         ...(config.attrs == null ? {} : { attrs: config.attrs }),
         html,
     };
+
     return {
         name: config.name,
         ...(config.attrs == null ? {} : { attrs: config.attrs }),
@@ -279,8 +317,9 @@ export function defineAtomNode(config: AtomNodeConfig<any>): AtomNodeDefinition<
         ...(config.idAttribute === undefined ? {} : { idAttribute: config.idAttribute }),
         estimatedHeight: config.estimatedHeight ?? DEFAULT_ATOM_CHIP_HEIGHT,
         nodeSpec,
-        buildFragmentJson(attrs, descriptor) {
+        buildFragmentJson(attrs: Record<string, unknown> | undefined, descriptor) {
             validateAttributes(attrs ?? {}, config.attrs ?? {});
+
             return {
                 type: descriptor?.documentNodeName ?? 'doc',
                 content: [
@@ -295,10 +334,14 @@ export function defineAtomNode(config: AtomNodeConfig<any>): AtomNodeDefinition<
 }
 
 function schemaValuesEqual(left: unknown, right: unknown): boolean {
-    if (Object.is(left, right)) return true;
+    if (Object.is(left, right)) {
+        return true;
+    }
+
     if (left == null || right == null || typeof left !== 'object' || typeof right !== 'object') {
         return false;
     }
+
     if (Array.isArray(left) || Array.isArray(right)) {
         return (
             Array.isArray(left) &&
@@ -307,10 +350,12 @@ function schemaValuesEqual(left: unknown, right: unknown): boolean {
             left.every((value, index) => schemaValuesEqual(value, right[index]))
         );
     }
+
     const leftRecord = left as Record<string, unknown>;
     const rightRecord = right as Record<string, unknown>;
     const leftKeys = Object.keys(leftRecord).sort();
     const rightKeys = Object.keys(rightRecord).sort();
+
     return (
         leftKeys.length === rightKeys.length &&
         leftKeys.every(
@@ -321,19 +366,27 @@ function schemaValuesEqual(left: unknown, right: unknown): boolean {
 }
 
 function assertUnambiguousHtmlRules(nodes: readonly NodeSpec[]): void {
-    const ruled = nodes.filter((node) => node.html != null);
+    const ruled = nodes.filter(node => node.html != null);
+
     for (let rightIndex = 1; rightIndex < ruled.length; rightIndex += 1) {
         const right = ruled[rightIndex];
+
         for (let leftIndex = 0; leftIndex < rightIndex; leftIndex += 1) {
             const left = ruled[leftIndex];
-            if (left.html?.tag !== right.html?.tag) continue;
+
+            if (left.html?.tag !== right.html?.tag) {
+                continue;
+            }
+
             const leftStatic = left.html?.staticAttrs ?? {};
             const rightStatic = right.html?.staticAttrs ?? {};
+
             const conflicts = Object.entries(leftStatic).some(
-                ([name, value]) =>
+                ([ name, value ]) =>
                     Object.prototype.hasOwnProperty.call(rightStatic, name) &&
                     rightStatic[name] !== value
             );
+
             if (!conflicts) {
                 throw new Error(`ambiguous atom HTML rules for '${left.name}' and '${right.name}'`);
             }
@@ -345,35 +398,49 @@ export function withAtomsSchema(
     schema: SchemaDefinition,
     atoms: readonly AtomNodeDefinition<any>[]
 ): SchemaDefinition {
-    const nodes = [...schema.nodes];
+    const nodes = [ ...schema.nodes ];
     let changed = false;
+
     for (const atom of atoms) {
-        const existing = nodes.find((node) => node.name === atom.name);
+        const existing = nodes.find(node => node.name === atom.name);
+
         if (existing != null) {
             if (!schemaValuesEqual(existing, atom.nodeSpec)) {
                 throw new Error(`schema already declares conflicting node '${atom.name}'`);
             }
+
             continue;
         }
+
         nodes.push(atom.nodeSpec);
         changed = true;
     }
+
     assertUnambiguousHtmlRules(nodes);
+
     return changed ? { ...schema, nodes } : schema;
 }
 
 export function serializeEditorAtoms(
     atoms?: readonly AtomNodeDefinition<any>[]
 ): string | undefined {
-    if (atoms == null || atoms.length === 0) return undefined;
+    if (atoms == null || atoms.length === 0) {
+        return undefined;
+    }
+
     const serialized: SerializedEditorAtoms = {
         nodeTypes: [],
         estimatedHeights: {},
     };
+
     for (const atom of atoms) {
-        if (Object.prototype.hasOwnProperty.call(serialized.estimatedHeights, atom.name)) continue;
+        if (Object.prototype.hasOwnProperty.call(serialized.estimatedHeights, atom.name)) {
+            continue;
+        }
+
         serialized.nodeTypes.push(atom.name);
         serialized.estimatedHeights[atom.name] = atom.estimatedHeight ?? DEFAULT_ATOM_CHIP_HEIGHT;
     }
+
     return JSON.stringify(serialized);
 }

package/src/attributeValidation.ts

@@ -5,33 +5,56 @@ function jsonType(value: unknown): string {
 }
 
 function validateJson(value: unknown, ancestors = new Set<object>()): void {
-    if (value === null || typeof value === 'string' || typeof value === 'boolean') return;
-    if (typeof value === 'number' && Number.isFinite(value)) return;
-    if (typeof value !== 'object' || ancestors.has(value) || ancestors.size > 128)
+    if (value === null || typeof value === 'string' || typeof value === 'boolean') {
+        return;
+    }
+
+    if (typeof value === 'number' && Number.isFinite(value)) {
+        return;
+    }
+
+    if (typeof value !== 'object' || ancestors.has(value) || ancestors.size > 128) {
         throw new Error('Attribute values must be finite, acyclic JSON.');
+    }
+
     if (
         !Array.isArray(value) &&
         Object.getPrototypeOf(value) !== Object.prototype &&
         Object.getPrototypeOf(value) !== null
-    )
+    ) {
         throw new Error('Attribute values must be plain JSON objects.');
+    }
+
     ancestors.add(value);
     const entries = Array.isArray(value) ? value : Object.values(value);
-    for (let index = 0; index < entries.length; index += 1) validateJson(entries[index], ancestors);
+
+    for (let index = 0; index < entries.length; index += 1) {
+        validateJson(entries[index], ancestors);
+    }
+
     ancestors.delete(value);
 }
 
 function equal(left: unknown, right: unknown): boolean {
-    if (left === right) return true;
-    if (left == null || right == null || typeof left !== 'object' || typeof right !== 'object')
+    if (left === right) {
+        return true;
+    }
+
+    if (left == null || right == null || typeof left !== 'object' || typeof right !== 'object') {
+        return false;
+    }
+
+    if (Array.isArray(left) !== Array.isArray(right)) {
         return false;
-    if (Array.isArray(left) !== Array.isArray(right)) return false;
+    }
+
     const a = Object.keys(left),
         b = Object.keys(right);
+
     return (
         a.length === b.length &&
         a.every(
-            (key) =>
+            key =>
                 Object.prototype.hasOwnProperty.call(right, key) &&
                 equal(
                     (left as Record<string, unknown>)[key],
@@ -44,73 +67,114 @@ function equal(left: unknown, right: unknown): boolean {
 export function validateAttribute(value: unknown, spec: AttrSpec, name: string): void {
     validateJson(value);
     const type = jsonType(value);
-    if ((spec.type != null && type !== spec.type) || (type === 'number' && !Number.isFinite(value)))
+
+    if ((spec.type != null && type !== spec.type) || (type === 'number' && !Number.isFinite(value))) {
         throw new Error(`invalid attribute '${name}': expected ${spec.type ?? 'finite number'}`);
-    if (spec.enum != null && !spec.enum.some((entry) => equal(entry, value)))
+    }
+
+    if (spec.enum != null && !spec.enum.some(entry => equal(entry, value))) {
         throw new Error(`invalid attribute '${name}': outside enum`);
+    }
+
     const size =
         typeof value === 'number'
             ? value
             : typeof value === 'string'
-              ? [...value].length
-              : Array.isArray(value)
-                ? value.length
-                : undefined;
+                ? [ ...value ].length
+                : Array.isArray(value)
+                    ? value.length
+                    : undefined;
+
     if (
         (spec.min != null && (size == null || size < spec.min)) ||
         (spec.max != null && (size == null || size > spec.max))
-    )
+    ) {
         throw new Error(`invalid attribute '${name}': outside bounds`);
+    }
 }
 
 export function validateAttributeSpec(spec: AttrSpec, name: string): void {
-    if (spec == null || typeof spec !== 'object' || Array.isArray(spec))
+    if (spec == null || typeof spec !== 'object' || Array.isArray(spec)) {
         throw new Error(`invalid attribute '${name}' declaration`);
-    if (Object.keys(spec).some((key) => !['default', 'type', 'enum', 'min', 'max'].includes(key)))
+    }
+
+    if (Object.keys(spec).some(key => ![ 'default',
+        'type',
+        'enum',
+        'min',
+        'max' ].includes(key))) {
         throw new Error(`invalid attribute '${name}' declaration field`);
+    }
+
     if (
         spec.type !== undefined &&
-        !['string', 'number', 'boolean', 'object', 'array'].includes(spec.type)
-    )
+        ![ 'string',
+            'number',
+            'boolean',
+            'object',
+            'array' ].includes(spec.type)
+    ) {
         throw new Error(`invalid attribute '${name}' type`);
+    }
+
     if (spec.min !== undefined || spec.max !== undefined) {
         if (
-            !['number', 'string', 'array'].includes(spec.type ?? '') ||
+            ![ 'number', 'string', 'array' ].includes(spec.type ?? '') ||
             (spec.min !== undefined && !Number.isFinite(spec.min)) ||
             (spec.max !== undefined && !Number.isFinite(spec.max)) ||
             (spec.min !== undefined && spec.max !== undefined && spec.min > spec.max)
-        )
+        ) {
             throw new Error(`invalid attribute '${name}' bounds`);
+        }
+
         if (
             spec.type !== 'number' &&
-            [spec.min, spec.max].some(
-                (bound) => bound !== undefined && (!Number.isInteger(bound) || bound < 0)
+            [ spec.min, spec.max ].some(
+                bound => bound !== undefined && (!Number.isInteger(bound) || bound < 0)
             )
-        )
+        ) {
             throw new Error(`invalid attribute '${name}' length bounds`);
+        }
     }
+
     if (spec.enum !== undefined) {
-        if (!Array.isArray(spec.enum) || spec.enum.length === 0)
+        if (!Array.isArray(spec.enum) || spec.enum.length === 0) {
             throw new Error(`invalid attribute '${name}' enum`);
-        if (new Set(spec.enum.map(jsonType)).size !== 1)
+        }
+
+        if (new Set(spec.enum.map(jsonType)).size !== 1) {
             throw new Error(`invalid attribute '${name}': enum values must share one JSON type`);
-        for (const entry of spec.enum) validateAttribute(entry, { ...spec, enum: undefined }, name);
+        }
+
+        for (const entry of spec.enum) {
+            validateAttribute(entry, { ...spec, enum: undefined }, name);
+        }
+    }
+
+    if (spec.default !== undefined) {
+        validateAttribute(spec.default, spec, name);
     }
-    if (spec.default !== undefined) validateAttribute(spec.default, spec, name);
 }
 
 export function validateAttributes(
     attrs: Record<string, unknown>,
     specs: Record<string, AttrSpec>
 ): void {
-    for (const name of Object.keys(attrs))
-        if (!Object.prototype.hasOwnProperty.call(specs, name))
+    for (const name of Object.keys(attrs)) {
+        if (!Object.prototype.hasOwnProperty.call(specs, name)) {
             throw new Error(`undeclared attribute '${name}'`);
-    for (const [name, spec] of Object.entries(specs)) {
+        }
+    }
+
+    for (const [ name, spec ] of Object.entries(specs)) {
         const value = Object.prototype.hasOwnProperty.call(attrs, name)
             ? attrs[name]
             : spec.default;
-        if (value === undefined) throw new Error(`required attribute '${name}' missing`);
+
+        if (value === undefined) {
+            throw new Error(`required attribute '${name}' missing`);
+        }
+
         validateAttribute(value, spec, name);
     }
 }