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

package/dist/useRichTextEditorCommands.js

@@ -22,7 +22,7 @@ function useRichTextEditorCommands(context) {
         if (!editableRef.current) {
             throw new atomInstances_1.AtomUpdateAttrsError('not-applicable', 'The editor is not editable');
         }
-        const instance = atomStateRef.current.instances.find((candidate) => candidate.key === atomKey && candidate.nodeType === nodeType);
+        const instance = atomStateRef.current.instances.find(candidate => candidate.key === atomKey && candidate.nodeType === nodeType);
         if (instance == null ||
             (!hasStableKey &&
                 (atomStateRef.current.documentVersion !== expectedDocumentVersion ||
@@ -60,20 +60,29 @@ function useRichTextEditorCommands(context) {
             throw new atomInstances_1.AtomUpdateAttrsError('engine-error', 'Unexpected atom update outcome');
         }
         afterLocalEngineMutation();
-    }, [afterLocalEngineMutation, bridge, document, documentHandle, refreshAtomsFromUpdate]);
+    }, [afterLocalEngineMutation,
+        atomStateRef,
+        bridge,
+        document,
+        documentHandle.isDestroyed,
+        latestRevisionRef,
+        refreshAtomsFromUpdate]);
     const runAtomAction = (0, react_1.useCallback)(async (owner, instance, documentVersion, action) => {
         if (owner !== atomOwnerRef.current ||
             documentHandle.isDestroyed ||
-            latestRevisionRef.current == null)
+            latestRevisionRef.current == null) {
             throw new atomInstances_1.AtomUpdateAttrsError('not-ready', 'The editor is not ready.');
-        if (action === 'delete' && !editableRef.current)
+        }
+        if (action === 'delete' && !editableRef.current) {
             throw new atomInstances_1.AtomUpdateAttrsError('not-applicable', 'The editor is not editable.');
-        const current = atomStateRef.current.instances.find((candidate) => candidate.key === instance.key && candidate.nodeType === instance.nodeType);
+        }
+        const current = atomStateRef.current.instances.find(candidate => candidate.key === instance.key && candidate.nodeType === instance.nodeType);
         if (!current ||
             (!instance.hasStableKey &&
                 (documentVersion !== atomStateRef.current.documentVersion ||
-                    current.docPos !== instance.docPos)))
+                    current.docPos !== instance.docPos))) {
             throw new atomInstances_1.AtomUpdateAttrsError('not-applicable', 'The atom no longer exists.');
+        }
         try {
             const baseDocumentRevision = latestRevisionRef.current;
             const selection = bridge.setSelection({
@@ -84,27 +93,31 @@ function useRichTextEditorCommands(context) {
                     edge: action === 'select' || action === 'delete' ? 'node' : action,
                 },
             });
-            if (selection.type !== 'transaction')
+            if (selection.type !== 'transaction') {
                 throw new atomInstances_1.AtomUpdateAttrsError('not-applicable', 'The atom could not be selected.');
+            }
             if (action === 'delete') {
                 const outcome = bridge.applyCommand({
                     baseDocumentRevision,
                     command: { type: 'deleteBackward' },
                 });
-                if (outcome.type !== 'transaction')
+                if (outcome.type !== 'transaction') {
                     throw new atomInstances_1.AtomUpdateAttrsError('not-applicable', 'The atom could not be deleted.');
+                }
                 afterLocalEngineMutation();
             }
             else {
                 pushEngineUpdateToView();
                 document.refresh();
-                if (action !== 'select')
+                if (action !== 'select') {
                     nativeViewRef.current?.focus?.();
+                }
             }
         }
         catch (error) {
-            if (error instanceof atomInstances_1.AtomUpdateAttrsError)
+            if (error instanceof atomInstances_1.AtomUpdateAttrsError) {
                 throw error;
+            }
             if ((0, RichTextEditorSerialization_1.isRevisionMismatchError)(error)) {
                 refreshAtomsFromUpdate(bridge.renderUpdate());
                 document.refresh();
@@ -112,14 +125,15 @@ function useRichTextEditorCommands(context) {
             }
             throw new atomInstances_1.AtomUpdateAttrsError('engine-error', error instanceof Error ? error.message : String(error));
         }
-    }, [
-        afterLocalEngineMutation,
+    }, [afterLocalEngineMutation,
+        atomStateRef,
         bridge,
         document,
-        documentHandle,
+        documentHandle.isDestroyed,
+        latestRevisionRef,
+        nativeViewRef,
         pushEngineUpdateToView,
-        refreshAtomsFromUpdate,
-    ]);
+        refreshAtomsFromUpdate]);
     const runEngineMutation = (0, react_1.useCallback)((invoke) => {
         if (!editableRef.current) {
             throw new NativeEditorBoundaryError_1.NativeEditorOperationError({
@@ -151,15 +165,16 @@ function useRichTextEditorCommands(context) {
             throw error;
         }
         afterLocalEngineMutation();
-    }, [afterLocalEngineMutation, document]);
+    }, [afterLocalEngineMutation, document, latestRevisionRef]);
     const applyEngineCommand = (0, react_1.useCallback)((command) => {
-        runEngineMutation((baseDocumentRevision) => bridge.applyCommand({ command, baseDocumentRevision }));
+        runEngineMutation(baseDocumentRevision => bridge.applyCommand({ command, baseDocumentRevision }));
     }, [bridge, runEngineMutation]);
     const commandToggleMark = (0, react_1.useCallback)((markType) => applyEngineCommand({ type: 'toggleMark', markType }), [applyEngineCommand]);
     const commandSetLink = (0, react_1.useCallback)((href) => {
         const trimmedHref = href.trim();
-        if (!trimmedHref)
+        if (!trimmedHref) {
             return;
+        }
         applyEngineCommand({
             type: 'setMark',
             markType: 'link',
@@ -183,7 +198,7 @@ function useRichTextEditorCommands(context) {
                     ? 'list_item'
                     : 'listItem',
         });
-    }, [applyEngineCommand]);
+    }, [activeStateRef, applyEngineCommand]);
     const commandIndentListItem = (0, react_1.useCallback)(() => applyEngineCommand({ type: 'indentListItem' }), [applyEngineCommand]);
     const commandOutdentListItem = (0, react_1.useCallback)(() => applyEngineCommand({ type: 'outdentListItem' }), [applyEngineCommand]);
     const commandInsertNode = (0, react_1.useCallback)((nodeType) => applyEngineCommand({ type: 'insertNode', nodeType }), [applyEngineCommand]);
@@ -194,9 +209,10 @@ function useRichTextEditorCommands(context) {
         });
     }, [applyEngineCommand, documentDescriptor]);
     const commandInsertText = (0, react_1.useCallback)((text) => {
-        if (!text)
+        if (!text) {
             return;
-        runEngineMutation((baseDocumentRevision) => bridge.applyInput({ text, baseDocumentRevision }));
+        }
+        runEngineMutation(baseDocumentRevision => bridge.applyInput({ text, baseDocumentRevision }));
     }, [bridge, runEngineMutation]);
     const commandInsertContentHtml = (0, react_1.useCallback)((html) => applyEngineCommand({ type: 'insertContentHtml', html }), [applyEngineCommand]);
     const commandInsertContentJson = (0, react_1.useCallback)((doc) => applyEngineCommand({ type: 'insertContentJson', json: doc }), [applyEngineCommand]);
@@ -209,13 +225,17 @@ function useRichTextEditorCommands(context) {
             setLink: commandSetLink,
             unsetLink: commandUnsetLink,
         });
-    }, [commandSetLink, commandUnsetLink]);
+    }, [activeStateRef,
+        commandSetLink,
+        commandUnsetLink,
+        onRequestLinkRef,
+        selectionRef]);
     const openImageRequest = (0, react_1.useCallback)(() => {
         onRequestImageRef.current?.({
             selection: selectionRef.current,
             insertImage: commandInsertImage,
         });
-    }, [commandInsertImage]);
+    }, [commandInsertImage, onRequestImageRef, selectionRef]);
     (0, react_1.useImperativeHandle)(ref, () => ({
         focus() {
             nativeViewRef.current?.focus?.();
@@ -254,8 +274,9 @@ function useRichTextEditorCommands(context) {
         getTextContent: document.getTextContent,
         async getCaretRect() {
             const nativeView = nativeViewRef.current;
-            if (!nativeView?.getCaretRect)
+            if (!nativeView?.getCaretRect) {
                 return null;
+            }
             const raw = await Promise.resolve(nativeView.getCaretRect());
             return (0, RichTextEditorSerialization_1.parseCaretRectJson)(raw);
         },
@@ -263,9 +284,7 @@ function useRichTextEditorCommands(context) {
         redo: document.redo,
         canUndo: document.canUndo,
         canRedo: document.canRedo,
-    }), [
-        document,
-        commandToggleMark,
+    }), [commandToggleMark,
         commandSetLink,
         commandUnsetLink,
         commandToggleBlockquote,
@@ -278,9 +297,20 @@ function useRichTextEditorCommands(context) {
         commandInsertText,
         commandInsertContentHtml,
         commandInsertContentJson,
-        editable,
+        document.setContent,
+        document.setContentJson,
+        document.clearContent,
+        document.getContent,
+        document.getContentJson,
+        document.getIsEmpty,
+        document.getTextContent,
+        document.undo,
+        document.redo,
+        document.canUndo,
+        document.canRedo,
+        nativeViewRef,
         externalCompositionManager,
-    ]);
+        editable]);
     return {
         openLinkRequest,
         openImageRequest,

package/dist/useRichTextEditorEvents.d.ts

@@ -1,7 +1,7 @@
 import { type NativeSyntheticEvent } from 'react-native';
-import { useRichTextEditorState } from './useRichTextEditorState';
-import { useRichTextEditorUpdates } from './useRichTextEditorUpdates';
-import { useRichTextEditorCommands } from './useRichTextEditorCommands';
+import { type useRichTextEditorState } from './useRichTextEditorState';
+import { type useRichTextEditorUpdates } from './useRichTextEditorUpdates';
+import { type useRichTextEditorCommands } from './useRichTextEditorCommands';
 import { type NativeUpdateEvent, type NativeErrorEvent, type NativeExternalTextCompositionEvent, type NativeSelectionEvent, type NativeFocusEvent, type NativeContentHeightEvent, type NativeAtomLayoutEvent, type NativeToolbarActionEvent } from './RichTextEditorNativeTypes';
 export declare function useRichTextEditorEvents(context: Pick<ReturnType<typeof useRichTextEditorState>, 'editorId' | 'documentHandle' | 'lastAcceptedNativeCommitRevisionRef' | 'lastNativeDrivenRevisionRef' | 'document' | 'onLocalCommitRef' | 'nativeErrorBindingRef' | 'nativeErrorBinding' | 'externalCompositionManager' | 'scalarSelectionRef' | 'selectionRef' | 'onSelectionChangeRef' | 'isFocusedRef' | 'toolbarFrameOwnerId' | 'setIsFocused' | 'onFocusRef' | 'onBlurRef' | 'heightBehavior' | 'setAutoGrowHeight' | 'setAtomContentWidth' | 'setNativeAtomViewport' | 'setAtomPositions' | 'onToolbarActionRef'> & Pick<ReturnType<typeof useRichTextEditorUpdates>, 'refreshAtomsFromUpdate' | 'applyTypedUpdateState' | 'applyUpdateState' | 'updateAtomSelection'> & Pick<ReturnType<typeof useRichTextEditorCommands>, 'openLinkRequest' | 'openImageRequest'>): {
     isForThisEditor: (payload: {

package/dist/useRichTextEditorEvents.js

@@ -10,11 +10,13 @@ function useRichTextEditorEvents(context) {
     const { editorId, documentHandle, lastAcceptedNativeCommitRevisionRef, lastNativeDrivenRevisionRef, refreshAtomsFromUpdate, applyTypedUpdateState, document, onLocalCommitRef, nativeErrorBindingRef, nativeErrorBinding, externalCompositionManager, scalarSelectionRef, applyUpdateState, selectionRef, updateAtomSelection, onSelectionChangeRef, isFocusedRef, toolbarFrameOwnerId, setIsFocused, onFocusRef, onBlurRef, heightBehavior, setAutoGrowHeight, setAtomContentWidth, setNativeAtomViewport, setAtomPositions, openLinkRequest, openImageRequest, onToolbarActionRef, } = context;
     const isForThisEditor = (0, react_1.useCallback)((payload) => payload.editorId === editorId, [editorId]);
     const handleEditorUpdate = (0, react_1.useCallback)((event) => {
-        if (documentHandle.isDestroyed)
+        if (documentHandle.isDestroyed) {
             return;
+        }
         const accepted = (0, RichTextEditorSerialization_1.acceptNativeCommitPayload)(event.nativeEvent, documentHandle.editorId, lastAcceptedNativeCommitRevisionRef.current);
-        if (accepted == null)
+        if (accepted == null) {
             return;
+        }
         // Record both native-scoped revisions before any observable
         // state/callback/refresh work. This makes duplicate delivery and
         // the handle's same-revision signal deterministic.
@@ -25,10 +27,18 @@ function useRichTextEditorEvents(context) {
         // The adapter already committed; re-read for content callbacks.
         document.refresh();
         onLocalCommitRef.current?.();
-    }, [applyTypedUpdateState, document, documentHandle, refreshAtomsFromUpdate]);
+    }, [applyTypedUpdateState,
+        document,
+        documentHandle.editorId,
+        documentHandle.isDestroyed,
+        lastAcceptedNativeCommitRevisionRef,
+        lastNativeDrivenRevisionRef,
+        onLocalCommitRef,
+        refreshAtomsFromUpdate]);
     const admitNativeBindingEvent = (0, react_1.useCallback)((payload) => {
-        if (!(0, RichTextEditorSerialization_1.isRecord)(payload))
+        if (!(0, RichTextEditorSerialization_1.isRecord)(payload)) {
             return null;
+        }
         const currentBinding = nativeErrorBindingRef.current;
         if (currentBinding !== nativeErrorBinding ||
             !currentBinding.mounted ||
@@ -45,21 +55,24 @@ function useRichTextEditorEvents(context) {
             return null;
         }
         return currentBinding;
-    }, [nativeErrorBinding]);
+    }, [nativeErrorBinding, nativeErrorBindingRef]);
     const handleEditorError = (0, react_1.useCallback)((event) => {
         const payload = event?.nativeEvent;
         const binding = admitNativeBindingEvent(payload);
-        if (binding == null || !(0, RichTextEditorSerialization_1.isRecord)(payload))
+        if (binding == null || !(0, RichTextEditorSerialization_1.isRecord)(payload)) {
             return;
+        }
         binding.handle.bridge._emitAutonomousError(payload.error);
     }, [admitNativeBindingEvent]);
     const handleExternalTextCompositionEnd = (0, react_1.useCallback)((event) => {
         const payload = event?.nativeEvent;
         const binding = admitNativeBindingEvent(payload);
-        if (binding == null || !(0, RichTextEditorSerialization_1.isRecord)(payload))
+        if (binding == null || !(0, RichTextEditorSerialization_1.isRecord)(payload)) {
             return;
-        if (typeof payload.resultJson !== 'string')
+        }
+        if (typeof payload.resultJson !== 'string') {
             return;
+        }
         try {
             externalCompositionManager.handleNativeEnd(binding.editorId, payload.resultJson);
         }
@@ -68,8 +81,9 @@ function useRichTextEditorEvents(context) {
         }
     }, [admitNativeBindingEvent, externalCompositionManager]);
     const handleSelectionChange = (0, react_1.useCallback)((event) => {
-        if (documentHandle.isDestroyed || !isForThisEditor(event.nativeEvent))
+        if (documentHandle.isDestroyed || !isForThisEditor(event.nativeEvent)) {
             return;
+        }
         const { anchor, head, stateJson } = event.nativeEvent;
         scalarSelectionRef.current = { anchor, head };
         let selection = { type: 'text', anchor, head };
@@ -81,10 +95,17 @@ function useRichTextEditorEvents(context) {
         selectionRef.current = selection;
         updateAtomSelection(selection);
         onSelectionChangeRef.current?.(selection);
-    }, [applyUpdateState, documentHandle, isForThisEditor, updateAtomSelection]);
+    }, [applyUpdateState,
+        documentHandle.isDestroyed,
+        isForThisEditor,
+        onSelectionChangeRef,
+        scalarSelectionRef,
+        selectionRef,
+        updateAtomSelection]);
     const handleFocusChange = (0, react_1.useCallback)((event) => {
-        if (documentHandle.isDestroyed || !isForThisEditor(event.nativeEvent))
+        if (documentHandle.isDestroyed || !isForThisEditor(event.nativeEvent)) {
             return;
+        }
         const focused = event.nativeEvent.isFocused;
         const wasFocused = isFocusedRef.current;
         isFocusedRef.current = focused;
@@ -96,37 +117,49 @@ function useRichTextEditorEvents(context) {
         else if (!focused && wasFocused) {
             onBlurRef.current?.();
         }
-    }, [documentHandle, isForThisEditor, toolbarFrameOwnerId]);
+    }, [documentHandle.isDestroyed,
+        isFocusedRef,
+        isForThisEditor,
+        onBlurRef,
+        onFocusRef,
+        setIsFocused,
+        toolbarFrameOwnerId]);
     const handleContentHeightChange = (0, react_1.useCallback)((event) => {
-        if (documentHandle.isDestroyed || !isForThisEditor(event.nativeEvent))
+        if (documentHandle.isDestroyed || !isForThisEditor(event.nativeEvent)) {
             return;
-        if (heightBehavior !== 'autoGrow')
+        }
+        if (heightBehavior !== 'autoGrow') {
             return;
+        }
         const density = react_native_1.Platform.OS === 'android' ? react_native_1.PixelRatio.get() : 1;
         const nextHeight = Math.ceil(event.nativeEvent.contentHeight / density);
-        if (!(nextHeight > 0))
+        if (!(nextHeight > 0)) {
             return;
-        setAutoGrowHeight((prev) => (prev === nextHeight ? prev : nextHeight));
-    }, [documentHandle, heightBehavior, isForThisEditor]);
+        }
+        setAutoGrowHeight(prev => (prev === nextHeight ? prev : nextHeight));
+    }, [documentHandle.isDestroyed, heightBehavior, isForThisEditor, setAutoGrowHeight]);
     const handleAtomLayout = (0, react_1.useCallback)((event) => {
-        if (documentHandle.isDestroyed || !isForThisEditor(event.nativeEvent))
+        if (documentHandle.isDestroyed || !isForThisEditor(event.nativeEvent)) {
             return;
+        }
         const width = event.nativeEvent.width;
-        if (!Number.isFinite(width) || width < 0)
+        if (!Number.isFinite(width) || width < 0) {
             return;
-        setAtomContentWidth((current) => (current === width ? current : width));
+        }
+        setAtomContentWidth(current => (current === width ? current : width));
         const viewport = event.nativeEvent.viewport;
         if (viewport &&
             Number.isFinite(viewport.y) &&
             Number.isFinite(viewport.height) &&
             viewport.height >= 0) {
-            setNativeAtomViewport((previous) => previous?.y === viewport.y && previous.height === viewport.height
+            setNativeAtomViewport(previous => previous?.y === viewport.y && previous.height === viewport.height
                 ? previous
                 : viewport);
         }
         const positions = event.nativeEvent.positions;
-        if (!Array.isArray(positions))
+        if (!Array.isArray(positions)) {
             return;
+        }
         const next = new Map();
         for (const position of positions) {
             if (typeof position?.key !== 'string' ||
@@ -140,9 +173,10 @@ function useRichTextEditorEvents(context) {
             }
             next.set(position.key, position);
         }
-        setAtomPositions((current) => {
-            if (current.size !== next.size)
+        setAtomPositions(current => {
+            if (current.size !== next.size) {
                 return next;
+            }
             for (const [key, position] of next) {
                 const previous = current.get(key);
                 if (previous?.x !== position.x ||
@@ -150,15 +184,21 @@ function useRichTextEditorEvents(context) {
                     previous.hostY !== position.hostY ||
                     previous.y !== position.y ||
                     previous.height !== position.height ||
-                    previous.width !== position.width)
+                    previous.width !== position.width) {
                     return next;
+                }
             }
             return current;
         });
-    }, [documentHandle, isForThisEditor]);
+    }, [documentHandle.isDestroyed,
+        isForThisEditor,
+        setAtomContentWidth,
+        setAtomPositions,
+        setNativeAtomViewport]);
     const handleToolbarAction = (0, react_1.useCallback)((event) => {
-        if (documentHandle.isDestroyed || !isForThisEditor(event.nativeEvent))
+        if (documentHandle.isDestroyed || !isForThisEditor(event.nativeEvent)) {
             return;
+        }
         const { key, updateJson, stateJson, documentRevision } = event.nativeEvent;
         // A toolbar event carrying update data is a native commit. It
         // must satisfy the same atomic admission path as typing; a pure
@@ -192,16 +232,19 @@ function useRichTextEditorEvents(context) {
             return;
         }
         onToolbarActionRef.current?.(key);
-    }, [
-        applyTypedUpdateState,
+    }, [applyTypedUpdateState,
         applyUpdateState,
         document,
-        documentHandle,
+        documentHandle.editorId,
+        documentHandle.isDestroyed,
         isForThisEditor,
+        lastAcceptedNativeCommitRevisionRef,
+        lastNativeDrivenRevisionRef,
+        onLocalCommitRef,
+        onToolbarActionRef,
         openImageRequest,
         openLinkRequest,
-        refreshAtomsFromUpdate,
-    ]);
+        refreshAtomsFromUpdate]);
     return {
         isForThisEditor,
         handleEditorUpdate,

package/dist/useRichTextEditorMentions.d.ts

@@ -1,9 +1,9 @@
 import { type EditorMentionTheme } from './EditorTheme';
 import { type NativeSyntheticEvent } from 'react-native';
-import { useRichTextEditorState } from './useRichTextEditorState';
-import { useRichTextEditorCommands } from './useRichTextEditorCommands';
-import { useRichTextEditorUpdates } from './useRichTextEditorUpdates';
-import { useRichTextEditorEvents } from './useRichTextEditorEvents';
+import { type useRichTextEditorState } from './useRichTextEditorState';
+import { type useRichTextEditorCommands } from './useRichTextEditorCommands';
+import { type useRichTextEditorUpdates } from './useRichTextEditorUpdates';
+import { type useRichTextEditorEvents } from './useRichTextEditorEvents';
 import { type NativeAddonEvent } from './RichTextEditorNativeTypes';
 export declare function useRichTextEditorMentions(context: Pick<ReturnType<typeof useRichTextEditorState>, 'addonsRef' | 'bridge' | 'documentHandle' | 'currentPushedUpdateEditorIdRef' | 'documentDescriptor' | 'latestRevisionRef' | 'document' | 'setMentionQuery' | 'mentionQuery' | 'addons' | 'editable' | 'isFocused' | 'activeStateRef' | 'toolbarFrameOwnerId'> & Pick<ReturnType<typeof useRichTextEditorCommands>, 'editableRef'> & Pick<ReturnType<typeof useRichTextEditorUpdates>, 'afterLocalEngineMutation'> & Pick<ReturnType<typeof useRichTextEditorEvents>, 'isForThisEditor'>): {
     mentionSuggestionTheme: EditorMentionTheme | undefined;

package/dist/useRichTextEditorMentions.js

@@ -23,7 +23,7 @@ function useRichTextEditorMentions(context) {
         return (0, RichTextEditorSerialization_1.isRecord)(resolvedAttrs)
             ? { ...selectionEvent.attrs, ...resolvedAttrs }
             : selectionEvent.attrs;
-    }, []);
+    }, [addonsRef]);
     const resolveMentionTheme = (0, react_1.useCallback)((selectionEvent) => {
         let resolvedTheme;
         try {
@@ -34,8 +34,9 @@ function useRichTextEditorMentions(context) {
                 console.error('NativeRichTextEditor: mentions.resolveTheme threw', error);
             }
         }
-        if (resolvedTheme === undefined || resolvedTheme === null)
+        if (resolvedTheme === undefined || resolvedTheme === null) {
             return undefined;
+        }
         // A rejected theme is dropped rather than written into the
         // document: every later renderUpdate revalidates it, so one bad
         // value would make the content permanently unrenderable.
@@ -46,7 +47,7 @@ function useRichTextEditorMentions(context) {
             return undefined;
         }
         return resolvedTheme;
-    }, []);
+    }, [addonsRef]);
     const resolveMentionInsertionAttrs = (0, react_1.useCallback)((selectionEvent) => {
         const attrs = resolveMentionSelectionAttrs(selectionEvent);
         const resolvedTheme = resolveMentionTheme({ ...selectionEvent, attrs });
@@ -56,8 +57,9 @@ function useRichTextEditorMentions(context) {
     }, [resolveMentionSelectionAttrs, resolveMentionTheme]);
     const insertMentionSuggestion = (0, react_1.useCallback)((request) => {
         const mentions = addonsRef.current?.mentions;
-        if (!mentions || !editableRef.current)
+        if (!mentions || !editableRef.current) {
             return;
+        }
         const snapshot = bridge.renderUpdate({
             anchor: request.range.anchor,
             head: request.range.head,
@@ -93,7 +95,7 @@ function useRichTextEditorMentions(context) {
         // own cursor resolution: a collapsed caret prefers After with a
         // deterministic Before fallback at text-boundary positions; a
         // range uses Before. The fallback changes only the stickiness
-        // of the SAME position — it is not a guessed-position retry.
+        // of the SAME position : it is not a guessed-position retry.
         const collapsed = anchorScalar === headScalar;
         const syncSelection = (affinity) => bridge.setSelection({
             baseDocumentRevision: snapshot.documentVersion,
@@ -108,8 +110,9 @@ function useRichTextEditorMentions(context) {
                 syncSelection(collapsed ? 'after' : 'before');
             }
             catch (error) {
-                if (!collapsed || !(0, RichTextEditorSerialization_1.isPositionInvalidError)(error))
+                if (!collapsed || !(0, RichTextEditorSerialization_1.isPositionInvalidError)(error)) {
                     throw error;
+                }
                 syncSelection('before');
             }
             const outcome = bridge.applyCommand({
@@ -121,8 +124,9 @@ function useRichTextEditorMentions(context) {
                     }),
                 },
             });
-            if (outcome.type !== 'transaction' || !outcome.changed)
+            if (outcome.type !== 'transaction' || !outcome.changed) {
                 return;
+            }
             latestRevisionRef.current = outcome.documentRevision;
         }
         catch (error) {
@@ -139,30 +143,36 @@ function useRichTextEditorMentions(context) {
             attrs,
             documentVersion: snapshot.documentVersion,
         });
-    }, [
+    }, [addonsRef,
         afterLocalEngineMutation,
         bridge,
+        currentPushedUpdateEditorIdRef,
         document,
         documentDescriptor,
-        documentHandle,
-        resolveMentionInsertionAttrs,
-    ]);
+        documentHandle.editorId,
+        documentHandle.isDestroyed,
+        editableRef,
+        latestRevisionRef,
+        resolveMentionInsertionAttrs]);
     const handleAddonEvent = (0, react_1.useCallback)((event) => {
-        if (documentHandle.isDestroyed || !isForThisEditor(event.nativeEvent))
+        if (documentHandle.isDestroyed || !isForThisEditor(event.nativeEvent)) {
             return;
+        }
         let parsed;
         try {
             const value = JSON.parse(event.nativeEvent.eventJson);
-            if (!(0, RichTextEditorSerialization_1.isRecord)(value) || typeof value.type !== 'string')
+            if (!(0, RichTextEditorSerialization_1.isRecord)(value) || typeof value.type !== 'string') {
                 return;
+            }
             parsed = value;
         }
         catch {
             return;
         }
         const mentions = addonsRef.current?.mentions;
-        if (!mentions)
+        if (!mentions) {
             return;
+        }
         const documentVersion = typeof parsed.documentVersion === 'string' ? parsed.documentVersion : undefined;
         if (parsed.type === 'mentionsQueryChange') {
             if (typeof parsed.query !== 'string' ||
@@ -190,9 +200,10 @@ function useRichTextEditorMentions(context) {
                 !(0, RichTextEditorSerialization_1.isRecord)(parsed.attrs)) {
                 return;
             }
-            const suggestion = mentions.suggestions?.find((candidate) => candidate.key === parsed.suggestionKey);
-            if (!suggestion)
+            const suggestion = mentions.suggestions?.find(candidate => candidate.key === parsed.suggestionKey);
+            if (!suggestion) {
                 return;
+            }
             mentions.onSelect?.({
                 trigger: parsed.trigger,
                 suggestion,
@@ -214,9 +225,10 @@ function useRichTextEditorMentions(context) {
             parsed.range.head > 4294967295) {
             return;
         }
-        const suggestion = mentions.suggestions?.find((candidate) => candidate.key === parsed.suggestionKey);
-        if (!suggestion)
+        const suggestion = mentions.suggestions?.find(candidate => candidate.key === parsed.suggestionKey);
+        if (!suggestion) {
             return;
+        }
         insertMentionSuggestion({
             trigger: parsed.trigger,
             suggestion,
@@ -224,13 +236,19 @@ function useRichTextEditorMentions(context) {
             range: parsed.range,
             documentVersion,
         });
-    }, [documentHandle, insertMentionSuggestion, isForThisEditor]);
+    }, [addonsRef,
+        documentHandle.isDestroyed,
+        insertMentionSuggestion,
+        isForThisEditor,
+        setMentionQuery]);
     const handleMentionSuggestionPress = (0, react_1.useCallback)((suggestion) => {
-        if (mentionQuery == null)
+        if (mentionQuery == null) {
             return;
-        const normalized = (0, addons_1.normalizeNativeEditorAddons)(addonsRef.current)?.mentions?.suggestions.find((candidate) => candidate.key === suggestion.key);
-        if (normalized == null)
+        }
+        const normalized = (0, addons_1.normalizeNativeEditorAddons)(addonsRef.current)?.mentions?.suggestions.find(candidate => candidate.key === suggestion.key);
+        if (normalized == null) {
             return;
+        }
         setMentionQuery(null);
         insertMentionSuggestion({
             trigger: mentionQuery.trigger,
@@ -239,7 +257,7 @@ function useRichTextEditorMentions(context) {
             range: mentionQuery.range,
             documentVersion: mentionQuery.documentVersion,
         });
-    }, [insertMentionSuggestion, mentionQuery]);
+    }, [addonsRef, insertMentionSuggestion, mentionQuery, setMentionQuery]);
     const mentionsEnabled = addons.mentions != null;
     const mentionTrigger = addons.mentions?.trigger?.trim() || '@';
     (0, react_1.useEffect)(() => {
@@ -257,13 +275,15 @@ function useRichTextEditorMentions(context) {
             return undefined;
         }
         const normalized = (0, addons_1.normalizeNativeEditorAddons)(addons)?.mentions?.suggestions;
-        if (normalized == null)
+        if (normalized == null) {
             return undefined;
+        }
         const themes = {};
         for (const suggestion of mentionSuggestions) {
-            const normalizedSuggestion = normalized.find((candidate) => candidate.key === suggestion.key);
-            if (normalizedSuggestion == null)
+            const normalizedSuggestion = normalized.find(candidate => candidate.key === suggestion.key);
+            if (normalizedSuggestion == null) {
                 continue;
+            }
             const selectionEvent = {
                 trigger: mentionQuery.trigger,
                 suggestion,
@@ -281,14 +301,13 @@ function useRichTextEditorMentions(context) {
             }
         }
         return Object.keys(themes).length > 0 ? themes : undefined;
-    }, [
+    }, [activeStateRef,
         addons,
         mentionQuery,
         mentionSuggestionTheme,
         mentionSuggestions,
         resolveMentionSelectionAttrs,
-        resolveMentionTheme,
-    ]);
+        resolveMentionTheme]);
     (0, react_1.useEffect)(() => {
         if (!shouldPublishMentionSuggestions ||
             mentionQuery == null ||