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

package/src/schemaResolution.ts

@@ -39,13 +39,18 @@ export function admitSchemaCollections(
 
     for (let nodeIndex = 0; nodeIndex < schema.nodes.length; nodeIndex += 1) {
         const node = schema.nodes[nodeIndex];
-        if (node == null || typeof node !== 'object') return null;
+
+        if (node == null || typeof node !== 'object') {
+            return null;
+        }
+
         const groups: string[] = [];
+
         if (typeof node.group === 'string') {
             if (
                 !forEachGroupToken(
                     node.group,
-                    (group) => groups.push(group),
+                    group => groups.push(group),
                     () => consumeSchemaWork(budget),
                     () => consumeSchemaWork(budget)
                 )
@@ -53,16 +58,26 @@ export function admitSchemaCollections(
                 throw schemaBoundaryError(budget.limit, budget.limit + 1);
             }
         }
+
         const attrs = collectOwnAttrs(node.attrs, budget);
-        if (attrs == null) return null;
+
+        if (attrs == null) {
+            return null;
+        }
+
         const projectionAttrs = collectOwnAttrs(node.json?.attrs, budget);
-        if (projectionAttrs == null) return null;
+
+        if (projectionAttrs == null) {
+            return null;
+        }
+
         if (
             node.json != null &&
             ((typeof node.json.type === 'string' &&
                 !consumeSchemaStringWork(budget, node.json.type)) ||
-                projectionAttrs.some(([name, rawValue]) => {
+                projectionAttrs.some(([ name, rawValue ]) => {
                     const value: unknown = rawValue;
+
                     return (
                         !consumeSchemaStringWork(budget, name) ||
                         (typeof value === 'string'
@@ -73,21 +88,32 @@ export function admitSchemaCollections(
         ) {
             throw schemaBoundaryError(budget.limit, budget.limit + 1);
         }
+
         if (budget.exhausted) {
             throw schemaBoundaryError(budget.limit, budget.limit + 1);
         }
+
         groupsByNode.set(node, groups);
         attrsByNode.set(node, attrs);
     }
 
     for (let markIndex = 0; markIndex < schema.marks.length; markIndex += 1) {
         const mark = schema.marks[markIndex];
+
         if (!consumeSchemaWork(budget)) {
             throw schemaBoundaryError(budget.limit, budget.limit + 1);
         }
-        if (mark == null || typeof mark !== 'object') return null;
+
+        if (mark == null || typeof mark !== 'object') {
+            return null;
+        }
+
         const attrs = collectOwnAttrs(mark.attrs, budget);
-        if (attrs == null) return null;
+
+        if (attrs == null) {
+            return null;
+        }
+
         if (budget.exhausted) {
             throw schemaBoundaryError(budget.limit, budget.limit + 1);
         }
@@ -101,45 +127,70 @@ export function resolveDocumentSchema(
     schema?: SchemaDefinition,
     limits?: DocumentDescriptorLimits
 ): SchemaDefinition {
-    if (schema == null) return defaultSchema;
-    if (!Array.isArray(schema.nodes)) return defaultSchema;
+    if (schema == null) {
+        return defaultSchema;
+    }
+
+    if (!Array.isArray(schema.nodes)) {
+        return defaultSchema;
+    }
+
     if (!Array.isArray(schema.marks)) {
         schema = { ...schema, marks: [] };
     }
 
     const resolvedLimits = resolveDescriptorLimits(limits);
+
     if (schema.nodes.length > resolvedLimits.maxSchemaNodes) {
         throw schemaBoundaryError(resolvedLimits.maxSchemaNodes, schema.nodes.length);
     }
+
     let expressionBytes = 0;
+
     for (let nodeIndex = 0; nodeIndex < schema.nodes.length; nodeIndex += 1) {
         const node = schema.nodes[nodeIndex];
+
         if (node != null && typeof node.content === 'string') {
             expressionBytes += utf8ByteLengthUpTo(
                 node.content,
                 resolvedLimits.maxSchemaExpressionBytes - expressionBytes
             );
+
             if (expressionBytes > resolvedLimits.maxSchemaExpressionBytes) {
                 throw schemaBoundaryError(resolvedLimits.maxSchemaExpressionBytes, expressionBytes);
             }
         }
     }
+
     const schemaBudget = createSchemaWorkBudget(resolvedLimits);
-    if (admitSchemaCollections(schema, schemaBudget) == null) return defaultSchema;
+
+    if (admitSchemaCollections(schema, schemaBudget) == null) {
+        return defaultSchema;
+    }
+
     const normalizedSchema = normalizeSchemaDefinition(schema, schemaBudget);
-    if (normalizedSchema == null) return defaultSchema;
+
+    if (normalizedSchema == null) {
+        return defaultSchema;
+    }
+
     schema = normalizedSchema;
+
     const admittedCollections = admitSchemaCollections(schema, {
         limit: Number.MAX_SAFE_INTEGER,
         work: 0,
         exhausted: false,
     });
-    if (admittedCollections == null) return defaultSchema;
+
+    if (admittedCollections == null) {
+        return defaultSchema;
+    }
 
     const nodeNames = new Set<string>();
     const markNames = new Set<string>();
     let docRoles = 0;
     let textRoles = 0;
+
     for (const node of schema.nodes) {
         if (
             node == null ||
@@ -151,10 +202,18 @@ export function resolveDocumentSchema(
         ) {
             return defaultSchema;
         }
+
         nodeNames.add(node.name);
-        if (node.role === 'doc') docRoles += 1;
-        if (node.role === 'text') textRoles += 1;
+
+        if (node.role === 'doc') {
+            docRoles += 1;
+        }
+
+        if (node.role === 'text') {
+            textRoles += 1;
+        }
     }
+
     for (const mark of schema.marks) {
         if (
             mark == null ||
@@ -164,29 +223,42 @@ export function resolveDocumentSchema(
         ) {
             return defaultSchema;
         }
+
         markNames.add(mark.name);
     }
-    if (docRoles !== 1 || textRoles !== 1) return defaultSchema;
+
+    if (docRoles !== 1 || textRoles !== 1) {
+        return defaultSchema;
+    }
 
     const groups = new Set<string>();
     const nodesBySymbol = new Map<string, NodeSpec[]>();
+
     const addCandidate = (symbol: string, node: NodeSpec): void => {
         const candidates = nodesBySymbol.get(symbol);
-        if (candidates) candidates.push(node);
-        else nodesBySymbol.set(symbol, [node]);
+
+        if (candidates) {
+            candidates.push(node);
+        } else {
+            nodesBySymbol.set(symbol, [ node ]);
+        }
     };
+
     for (const node of schema.nodes) {
         addCandidate(node.name, node);
+
         for (const group of admittedCollections.groupsByNode.get(node) ?? []) {
             groups.add(group);
             addCandidate(group, node);
         }
     }
+
     for (const node of schema.nodes) {
         const symbols = contentExpressionSymbols(node.content);
+
         if (
             symbols == null ||
-            symbols.some((symbol) => !nodeNames.has(symbol) && !groups.has(symbol))
+            symbols.some(symbol => !nodeNames.has(symbol) && !groups.has(symbol))
         ) {
             return defaultSchema;
         }
@@ -194,49 +266,76 @@ export function resolveDocumentSchema(
 
     const generatable = new Set<string>();
     const consumeWork = (): boolean => consumeSchemaWork(schemaBudget);
+
     const contentIsConstructible = (node: NodeSpec): boolean => {
-        if (!consumeWork()) return false;
+        if (!consumeWork()) {
+            return false;
+        }
+
         return (
             minimalContentMatch(
                 node.content,
-                (symbol) => {
+                symbol => {
                     const candidates = nodesBySymbol.get(symbol) ?? [];
+
                     for (const candidate of candidates) {
-                        if (!consumeWork()) return undefined;
-                        if (generatable.has(candidate.name)) return { type: candidate.name };
+                        if (!consumeWork()) {
+                            return undefined;
+                        }
+
+                        if (generatable.has(candidate.name)) {
+                            return { type: candidate.name };
+                        }
                     }
+
                     return undefined;
                 },
                 consumeWork
             ) != null
         );
     };
+
     while (true) {
         const before = generatable.size;
+
         for (const node of schema.nodes) {
             const hasRequiredAttrs = (admittedCollections.attrsByNode.get(node) ?? []).some(
-                ([, attr]) => attr.default === undefined
+                ([ , attr ]) => attr.default === undefined
             );
+
             if (node.role !== 'text' && !hasRequiredAttrs && contentIsConstructible(node)) {
                 generatable.add(node.name);
             }
         }
-        if (generatable.size === before) break;
+
+        if (generatable.size === before) {
+            break;
+        }
     }
+
     if (schemaBudget.exhausted) {
         throw schemaBoundaryError(schemaBudget.limit, schemaBudget.limit + 1);
     }
-    const hasUnconstructibleNode = schema.nodes.some((node) => !contentIsConstructible(node));
+
+    const hasUnconstructibleNode = schema.nodes.some(node => !contentIsConstructible(node));
+
     if (schemaBudget.exhausted) {
         throw schemaBoundaryError(schemaBudget.limit, schemaBudget.limit + 1);
     }
-    if (hasUnconstructibleNode) return defaultSchema;
+
+    if (hasUnconstructibleNode) {
+        return defaultSchema;
+    }
 
     try {
         constructDefaultEmptyDocument(schema, resolvedLimits, admittedCollections);
+
         return schema;
     } catch (error) {
-        if (error instanceof NativeEditorBoundaryError) throw error;
+        if (error instanceof NativeEditorBoundaryError) {
+            throw error;
+        }
+
         return defaultSchema;
     }
 }

package/src/specs/PreparedProseViewerNativeComponent.ts

@@ -18,8 +18,10 @@ export interface NativeProps extends ViewProps {
     mentionInteractionsEnabled?: WithDefault<boolean, false>;
     fontEnvironmentRevision: Int32;
     onPressLink?: DirectEventHandler<{ href: string; text: string }>;
-    // React Native numbers are IEEE-754 doubles, which exactly represent every
-    // UInt32 document position. Int32 would corrupt positions above 2^31 - 1.
+    /**
+     * React Native numbers are IEEE-754 doubles, which exactly represent every
+     * UInt32 document position. Int32 would corrupt positions above 2^31 - 1.
+     */
     onPressMention?: DirectEventHandler<{ docPos: Double; label: string; attrsJson: string }>;
     onAtomLayout?: DirectEventHandler<{
         generation: string;

package/src/useEditorToolbarInteractions.tsx

@@ -1,7 +1,7 @@
 import { useCallback, useEffect } from 'react';
 import { Keyboard } from 'react-native';
-import { useEditorToolbarState } from './useEditorToolbarState';
-import { useEditorToolbarItems } from './useEditorToolbarItems';
+import { type useEditorToolbarState } from './useEditorToolbarState';
+import { type useEditorToolbarItems } from './useEditorToolbarItems';
 import {
     unregisterEditorToolbarFrame,
     registerEditorToolbarFrame,
@@ -80,10 +80,12 @@ export function useEditorToolbarInteractions(
     const publishToolbarFrame = useCallback(() => {
         const registrationId = registrationIdRef.current;
         const toolbar = rootRef.current;
+
         if (!publishesFocusFrames || registrationId == null || !toolbar) {
             if (registrationId != null) {
                 unregisterEditorToolbarFrame(registrationId);
             }
+
             return;
         }
 
@@ -92,6 +94,7 @@ export function useEditorToolbarInteractions(
         }
 
         const measuredFrameOwnerId = frameOwnerId;
+
         toolbar.measureInWindow((x, y, width, height) => {
             if (
                 !framePublisherMountedRef.current ||
@@ -100,21 +103,30 @@ export function useEditorToolbarInteractions(
             ) {
                 return;
             }
+
             registerEditorToolbarFrame(
                 registrationId,
                 { x, y, width, height },
                 measuredFrameOwnerId
             );
         });
-    }, [frameOwnerId, publishesFocusFrames]);
+    }, [ frameOwnerId,
+        frameOwnerIdRef,
+        framePublisherMountedRef,
+        publishesFocusFrames,
+        publishesFocusFramesRef,
+        registrationIdRef,
+        rootRef ]);
 
     const publishMenuFrame = useCallback(() => {
         const registrationId = menuRegistrationIdRef.current;
         const menuCard = menuCardRef.current;
+
         if (!publishesFocusFrames || menuState == null || registrationId == null || !menuCard) {
             if (registrationId != null) {
                 unregisterEditorToolbarFrame(registrationId);
             }
+
             return;
         }
 
@@ -124,6 +136,7 @@ export function useEditorToolbarInteractions(
 
         const measuredFrameOwnerId = frameOwnerId;
         const measuredMenuState = menuState;
+
         menuCard.measureInWindow((x, y, width, height) => {
             if (
                 !framePublisherMountedRef.current ||
@@ -133,25 +146,34 @@ export function useEditorToolbarInteractions(
             ) {
                 return;
             }
+
             registerEditorToolbarFrame(
                 registrationId,
                 { x, y, width, height },
                 measuredFrameOwnerId
             );
         });
-    }, [frameOwnerId, menuState, publishesFocusFrames]);
+    }, [ frameOwnerId,
+        frameOwnerIdRef,
+        framePublisherMountedRef,
+        menuCardRef,
+        menuRegistrationIdRef,
+        menuState,
+        menuStateRef,
+        publishesFocusFrames,
+        publishesFocusFramesRef ]);
 
     const publishToolbarFrames = useCallback(() => {
         publishToolbarFrame();
         publishMenuFrame();
-    }, [publishMenuFrame, publishToolbarFrame]);
+    }, [ publishMenuFrame, publishToolbarFrame ]);
 
     const cancelScheduledFramePublishes = useCallback(() => {
-        framePublishAnimationFramesRef.current.forEach((frame) => cancelAnimationFrame(frame));
+        framePublishAnimationFramesRef.current.forEach(frame => cancelAnimationFrame(frame));
         framePublishAnimationFramesRef.current = [];
-        framePublishTimeoutsRef.current.forEach((timeout) => clearTimeout(timeout));
+        framePublishTimeoutsRef.current.forEach(timeout => clearTimeout(timeout));
         framePublishTimeoutsRef.current = [];
-    }, []);
+    }, [ framePublishAnimationFramesRef, framePublishTimeoutsRef ]);
 
     const scheduleToolbarFramePublish = useCallback(() => {
         if (!publishesFocusFrames) {
@@ -162,32 +184,39 @@ export function useEditorToolbarInteractions(
         publishToolbarFrames();
 
         framePublishAnimationFramesRef.current.push(requestAnimationFrame(publishToolbarFrames));
-        KEYBOARD_FRAME_REMEASURE_DELAYS_MS.forEach((delay) => {
+
+        KEYBOARD_FRAME_REMEASURE_DELAYS_MS.forEach(delay => {
             framePublishTimeoutsRef.current.push(setTimeout(publishToolbarFrames, delay));
         });
-    }, [cancelScheduledFramePublishes, publishesFocusFrames, publishToolbarFrames]);
+    }, [ publishesFocusFrames,
+        cancelScheduledFramePublishes,
+        publishToolbarFrames,
+        framePublishAnimationFramesRef,
+        framePublishTimeoutsRef ]);
 
     const handleToolbarLayout = useCallback(() => {
         requestAnimationFrame(publishToolbarFrame);
-    }, [publishToolbarFrame]);
+    }, [ publishToolbarFrame ]);
 
     const handleMenuLayout = useCallback(() => {
         requestAnimationFrame(publishMenuFrame);
-    }, [publishMenuFrame]);
+    }, [ publishMenuFrame ]);
 
     useEffect(() => {
         if (!publishesFocusFrames) {
             const registrationId = registrationIdRef.current;
+
             if (registrationId != null) {
                 unregisterEditorToolbarFrame(registrationId);
             }
+
             return;
         }
 
         const frame = requestAnimationFrame(publishToolbarFrame);
+
         return () => cancelAnimationFrame(frame);
-    }, [
-        expandedGroupKey,
+    }, [ expandedGroupKey,
         menuState?.groupKey,
         publishesFocusFrames,
         publishToolbarFrame,
@@ -196,42 +225,55 @@ export function useEditorToolbarInteractions(
         endItems.length,
         windowHeight,
         windowWidth,
-    ]);
+        registrationIdRef ]);
 
     useEffect(() => {
         if (!publishesFocusFrames || menuState == null) {
             const registrationId = menuRegistrationIdRef.current;
+
             if (registrationId != null) {
                 unregisterEditorToolbarFrame(registrationId);
             }
+
             return;
         }
 
         const frame = requestAnimationFrame(publishMenuFrame);
+
         return () => cancelAnimationFrame(frame);
-    }, [menuState, publishesFocusFrames, publishMenuFrame, windowHeight, windowWidth]);
+    }, [ menuState,
+        publishesFocusFrames,
+        publishMenuFrame,
+        windowHeight,
+        windowWidth,
+        menuRegistrationIdRef ]);
 
     useEffect(() => {
         const registrationId = registrationIdRef.current;
         const menuRegistrationId = menuRegistrationIdRef.current;
+
         return () => {
             cancelScheduledFramePublishes();
+
             if (toolbarInteractionActiveRef.current) {
                 toolbarInteractionActiveRef.current = false;
                 endEditorToolbarInteraction();
             }
+
             if (registrationId != null) {
                 unregisterEditorToolbarFrame(registrationId);
             }
+
             if (menuRegistrationId != null) {
                 unregisterEditorToolbarFrame(menuRegistrationId);
             }
         };
-    }, [cancelScheduledFramePublishes]);
+    }, [ cancelScheduledFramePublishes, menuRegistrationIdRef, registrationIdRef, toolbarInteractionActiveRef ]);
 
     useEffect(() => {
         if (!publishesFocusFrames) {
             cancelScheduledFramePublishes();
+
             return;
         }
 
@@ -242,81 +284,88 @@ export function useEditorToolbarInteractions(
         ];
 
         return () => {
-            subscriptions.forEach((subscription) => subscription.remove());
+            subscriptions.forEach(subscription => subscription.remove());
             cancelScheduledFramePublishes();
         };
-    }, [cancelScheduledFramePublishes, publishesFocusFrames, scheduleToolbarFramePublish]);
+    }, [ cancelScheduledFramePublishes, publishesFocusFrames, scheduleToolbarFramePublish ]);
 
     useEffect(() => {
         if (expandedGroupKey != null && !groupsByKey.has(expandedGroupKey)) {
             setExpandedGroupKey(null);
         }
-    }, [expandedGroupKey, groupsByKey]);
+    }, [ expandedGroupKey, groupsByKey, setExpandedGroupKey ]);
 
     useEffect(() => {
         if (menuState != null && !groupsByKey.has(menuState.groupKey)) {
             setMenuState(null);
         }
-    }, [groupsByKey, menuState]);
+    }, [ groupsByKey, menuState, setMenuState ]);
 
     useEffect(() => {
         if (shouldRenderMentionSuggestions) {
             setExpandedGroupKey(null);
             setMenuState(null);
         }
-    }, [shouldRenderMentionSuggestions]);
+    }, [ setExpandedGroupKey, setMenuState, shouldRenderMentionSuggestions ]);
 
     const handleButtonPress = useCallback((button: ToolbarButton) => {
         button.action();
+
         if (button.groupKey) {
-            setExpandedGroupKey((current) => (current === button.groupKey ? null : current));
+            setExpandedGroupKey(current => (current === button.groupKey ? null : current));
         }
+
         setMenuState(null);
-    }, []);
+    }, [ setExpandedGroupKey, setMenuState ]);
 
     const handleToolbarPressIn = useCallback(() => {
         if (preserveEditorFocus && !toolbarInteractionActiveRef.current) {
             toolbarInteractionActiveRef.current = true;
             beginEditorToolbarInteraction();
         }
-    }, [preserveEditorFocus]);
+    }, [ preserveEditorFocus, toolbarInteractionActiveRef ]);
 
     const handleToolbarPressOut = useCallback(() => {
         if (preserveEditorFocus && toolbarInteractionActiveRef.current) {
             toolbarInteractionActiveRef.current = false;
             endEditorToolbarInteraction();
         }
-    }, [preserveEditorFocus]);
+    }, [ preserveEditorFocus, toolbarInteractionActiveRef ]);
 
     const handleGroupPress = useCallback((group: ToolbarGroupButton) => {
         if (group.isDisabled) {
             return;
         }
+
         if (group.presentation === 'expand') {
             setMenuState(null);
-            setExpandedGroupKey((current) => (current === group.key ? null : group.key));
+            setExpandedGroupKey(current => (current === group.key ? null : group.key));
+
             return;
         }
 
         const anchor = groupButtonRefs.current.get(group.key);
+
         if (!anchor) {
             return;
         }
+
         anchor.measureInWindow((x, y, width, height) => {
             setExpandedGroupKey(null);
-            setMenuState((current) =>
+
+            setMenuState(current =>
                 current?.groupKey === group.key
                     ? null
                     : {
-                          groupKey: group.key,
-                          x,
-                          y,
-                          width,
-                          height,
-                      }
-            );
+                        groupKey: group.key,
+                        x,
+                        y,
+                        width,
+                        height,
+                    });
         });
-    }, []);
+    }, [ groupButtonRefs, setExpandedGroupKey, setMenuState ]);
+
     return {
         handleToolbarPressIn,
         handleToolbarPressOut,