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

package/dist/useRichTextEditorState.d.ts

@@ -0,0 +1,180 @@
+import { type EditorToolbarItem } from './EditorToolbar';
+import React from 'react';
+import { type ReadonlyActiveState, type Selection } from './NativeEditorBridge';
+import { type AtomComponent } from './atoms';
+import { ExternalTextCompositionManager } from './ExternalTextComposition';
+import { type MentionQueryChangeEvent } from './addons';
+import { type AtomViewport } from './AtomHost';
+import { type RichTextEditorProps, type RichTextEditorRef } from './RichTextEditorTypes';
+import { type AtomRenderState } from './RichTextEditorSerialization';
+import { type NativeEditorViewHandle, type NativeEditorErrorBinding, type NativeAtomPosition } from './RichTextEditorNativeTypes';
+export declare function useRichTextEditorState({ documentHandle, documentRevision, value, valueJSON, valueJSONRevision, valueJSONUpdateMode, placeholder, editable, autoFocus, autoCapitalize, autoCorrect, keyboardType, androidInputOptions, heightBehavior, showToolbar, toolbarPlacement, toolbarItems, onToolbarAction, onRequestLink, onRequestImage, imageLoadingPolicy, accessibilityLabel, accessibilityHint, style, containerStyle, theme, addons: addonDescriptors, atoms, atomsInteractive, virtualizeAtoms, atomViewport, remoteSelections, allowImageResizing, onContentChange, onContentChangeJSON, onSelectionChange, onActiveStateChange, onHistoryStateChange, onFocus, onBlur, focusPreservingRefs, onLocalCommit, }: RichTextEditorProps, ref: React.ForwardedRef<RichTextEditorRef>): {
+    atomStateRef: React.RefObject<AtomRenderState>;
+    setSelectedKeys: React.Dispatch<React.SetStateAction<ReadonlySet<string>>>;
+    bridge: import("./NativeEditorDocumentBridge").NativeEditorDocumentBridge;
+    registeredAtomTypes: Set<string>;
+    setAtomState: React.Dispatch<React.SetStateAction<AtomRenderState>>;
+    selectionRef: React.RefObject<Selection>;
+    document: import("./useNativeEditor").UseNativeEditorDocumentReturn;
+    documentHandle: import("./NativeEditorDocumentHandle").NativeEditorDocumentHandle;
+    atomSeedEditorIdRef: React.RefObject<string | null>;
+    editorId: string;
+    scalarSelectionRef: React.RefObject<{
+        anchor: number;
+        head: number;
+    }>;
+    activeStateRef: React.RefObject<{
+        readonly marks: {
+            readonly [x: string]: boolean;
+        };
+        readonly markAttrs: {
+            readonly [x: string]: {
+                readonly [x: string]: unknown;
+            };
+        };
+        readonly nodes: {
+            readonly [x: string]: boolean;
+        };
+        readonly commands: {
+            readonly [x: string]: boolean;
+        };
+        readonly allowedMarks: readonly string[];
+        readonly insertableNodes: readonly string[];
+    }>;
+    setActiveState: React.Dispatch<React.SetStateAction<{
+        readonly marks: {
+            readonly [x: string]: boolean;
+        };
+        readonly markAttrs: {
+            readonly [x: string]: {
+                readonly [x: string]: unknown;
+            };
+        };
+        readonly nodes: {
+            readonly [x: string]: boolean;
+        };
+        readonly commands: {
+            readonly [x: string]: boolean;
+        };
+        readonly allowedMarks: readonly string[];
+        readonly insertableNodes: readonly string[];
+    }>>;
+    activeStateKeyRef: React.RefObject<string | null>;
+    onActiveStateChangeRef: React.RefObject<((state: ReadonlyActiveState) => void) | undefined>;
+    pushedUpdateBindingGenerationRef: React.RefObject<number>;
+    currentPushedUpdateEditorIdRef: React.RefObject<string>;
+    pushRevisionRef: React.RefObject<number>;
+    lastPushedEngineRevisionRef: React.RefObject<string | null>;
+    setPushedUpdate: React.Dispatch<React.SetStateAction<{
+        json: string;
+        resetJson?: string;
+        revision: number;
+        editorId: string;
+    } | null>>;
+    pendingFocusedRebindRef: React.RefObject<{
+        editorId: string;
+        anchor: number;
+        head: number;
+    } | null>;
+    toolbarFrameOwnerId: number;
+    onFocusRef: React.RefObject<(() => void) | undefined>;
+    didRebindRevisionScope: boolean;
+    didObserveInitialRevisionRef: React.RefObject<boolean>;
+    lastNativeDrivenRevisionRef: React.RefObject<string | null>;
+    onLocalCommitRef: React.RefObject<(() => void) | undefined>;
+    editable: boolean;
+    latestRevisionRef: React.RefObject<string | null>;
+    nativeViewRef: React.RefObject<NativeEditorViewHandle | null>;
+    documentDescriptor: import("./schemaPresets").ResolvedDocumentSchema;
+    onRequestLinkRef: React.RefObject<((context: import("./RichTextEditorTypes").LinkRequestContext) => void) | undefined>;
+    onRequestImageRef: React.RefObject<((context: import("./RichTextEditorTypes").ImageRequestContext) => void) | undefined>;
+    ref: React.ForwardedRef<RichTextEditorRef>;
+    externalCompositionManager: ExternalTextCompositionManager;
+    lastAcceptedNativeCommitRevisionRef: React.RefObject<string | null>;
+    nativeErrorBindingRef: React.RefObject<NativeEditorErrorBinding>;
+    nativeErrorBinding: NativeEditorErrorBinding;
+    onSelectionChangeRef: React.RefObject<((selection: Selection) => void) | undefined>;
+    isFocusedRef: React.RefObject<boolean>;
+    setIsFocused: React.Dispatch<React.SetStateAction<boolean>>;
+    onBlurRef: React.RefObject<(() => void) | undefined>;
+    heightBehavior: import("./RichTextEditorTypes").RichTextEditorHeightBehavior;
+    setAutoGrowHeight: React.Dispatch<React.SetStateAction<number | null>>;
+    setAtomContentWidth: React.Dispatch<React.SetStateAction<number | null>>;
+    setNativeAtomViewport: React.Dispatch<React.SetStateAction<AtomViewport | undefined>>;
+    setAtomPositions: React.Dispatch<React.SetStateAction<ReadonlyMap<string, NativeAtomPosition>>>;
+    onToolbarActionRef: React.RefObject<((key: string) => void) | undefined>;
+    addonsRef: React.RefObject<import("./EditorAddonNormalization").NormalizedEditorAddons>;
+    setMentionQuery: React.Dispatch<React.SetStateAction<MentionQueryChangeEvent | null>>;
+    mentionQuery: MentionQueryChangeEvent | null;
+    addons: import("./EditorAddonNormalization").NormalizedEditorAddons;
+    isFocused: boolean;
+    theme: import("./EditorStyleSheetTypes").EditorTheme | undefined;
+    imageLoadingPolicy: import("./ImageLoadingPolicy").EditorImageLoadingPolicy | undefined;
+    androidInputOptions: import("./RichTextEditorTypes").RichTextEditorAndroidInputOptions | undefined;
+    remoteSelections: readonly import("./RichTextEditorTypes").RemoteSelectionDecoration[] | undefined;
+    atoms: readonly import("./atoms").AtomNodeDefinition<any, any>[] | undefined;
+    atomState: AtomRenderState;
+    atomComponents: Map<string, AtomComponent>;
+    warnedUnknownAtomTypesRef: React.RefObject<Set<string>>;
+    atomContentWidth: number | null;
+    atomPositions: ReadonlyMap<string, NativeAtomPosition>;
+    atomViewport: AtomViewport | undefined;
+    virtualizeAtoms: boolean;
+    nativeAtomViewport: AtomViewport | undefined;
+    selectedKeys: ReadonlySet<string>;
+    atomsInteractive: boolean;
+    activeState: {
+        readonly marks: {
+            readonly [x: string]: boolean;
+        };
+        readonly markAttrs: {
+            readonly [x: string]: {
+                readonly [x: string]: unknown;
+            };
+        };
+        readonly nodes: {
+            readonly [x: string]: boolean;
+        };
+        readonly commands: {
+            readonly [x: string]: boolean;
+        };
+        readonly allowedMarks: readonly string[];
+        readonly insertableNodes: readonly string[];
+    };
+    onRequestLink: ((context: import("./RichTextEditorTypes").LinkRequestContext) => void) | undefined;
+    onRequestImage: ((context: import("./RichTextEditorTypes").ImageRequestContext) => void) | undefined;
+    toolbarItemsSerializationCacheRef: React.RefObject<{
+        toolbarItems: readonly EditorToolbarItem[];
+        editable: boolean;
+        isLinkActive: boolean;
+        allowsLink: boolean;
+        canRequestLink: boolean;
+        canRequestImage: boolean;
+        canInsertImage: boolean;
+        serialized: string;
+    } | null>;
+    toolbarItems: readonly EditorToolbarItem[];
+    toolbarPlacement: import("./RichTextEditorTypes").RichTextEditorToolbarPlacement;
+    showToolbar: boolean;
+    containerStyle: RichTextEditorProps["containerStyle"];
+    style: RichTextEditorProps["style"];
+    autoGrowHeight: number | null;
+    pushedUpdate: {
+        json: string;
+        resetJson?: string;
+        revision: number;
+        editorId: string;
+    } | null;
+    registeredToolbarFrames: readonly import("./EditorToolbarRegistry").EditorToolbarFrame[];
+    suppliedFocusPreservingFrames: readonly import("./EditorToolbarRegistry").EditorToolbarFrame[];
+    refreshFocusPreservingFrames: () => void;
+    accessibilityLabel: string | undefined;
+    accessibilityHint: string | undefined;
+    placeholder: string | undefined;
+    autoFocus: boolean;
+    autoCapitalize: import("./RichTextEditorTypes").RichTextEditorAutoCapitalize | undefined;
+    autoCorrect: boolean | undefined;
+    keyboardType: import("./RichTextEditorTypes").RichTextEditorKeyboardType | undefined;
+    allowImageResizing: boolean;
+    onToolbarAction: ((key: string) => void) | undefined;
+};

package/dist/useRichTextEditorState.js

@@ -0,0 +1,405 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useRichTextEditorState = useRichTextEditorState;
+const EditorToolbar_1 = require("./EditorToolbar");
+const react_1 = require("react");
+const NativeEditorBridge_1 = require("./NativeEditorBridge");
+const schemas_1 = require("./schemas");
+const ExternalTextComposition_1 = require("./ExternalTextComposition");
+const useNativeEditor_1 = require("./useNativeEditor");
+const addons_1 = require("./addons");
+const useFocusPreservingFrames_1 = require("./useFocusPreservingFrames");
+const RichTextEditorSerialization_1 = require("./RichTextEditorSerialization");
+function useRichTextEditorState({ documentHandle, documentRevision, value, valueJSON, valueJSONRevision, valueJSONUpdateMode = 'replace', placeholder, editable = true, autoFocus = false, autoCapitalize, autoCorrect, keyboardType, androidInputOptions, heightBehavior = 'autoGrow', showToolbar = true, toolbarPlacement = 'keyboard', toolbarItems = EditorToolbar_1.DEFAULT_EDITOR_TOOLBAR_ITEMS, onToolbarAction, onRequestLink, onRequestImage, imageLoadingPolicy, accessibilityLabel, accessibilityHint, style, containerStyle, theme, addons: addonDescriptors, atoms, atomsInteractive = true, virtualizeAtoms = false, atomViewport, remoteSelections, allowImageResizing = true, onContentChange, onContentChangeJSON, onSelectionChange, onActiveStateChange, onHistoryStateChange, onFocus, onBlur, focusPreservingRefs, onLocalCommit, }, ref) {
+    const addons = (0, react_1.useMemo)(() => (0, addons_1.normalizeEditorAddons)(addonDescriptors), [addonDescriptors]);
+    (0, NativeEditorBridge_1._assertNativeEditorDocumentHandle)(documentHandle);
+    const documentDescriptor = (0, NativeEditorBridge_1._getNativeEditorDocumentHandleDescriptor)(documentHandle);
+    const registeredAtomTypeKey = JSON.stringify((atoms ?? []).map((atom) => atom.name));
+    const registeredAtomTypes = (0, react_1.useMemo)(() => new Set((atoms ?? []).map((atom) => atom.name)), [registeredAtomTypeKey]);
+    const atomComponents = (0, react_1.useMemo)(() => {
+        const components = new Map();
+        for (const atom of atoms ?? []) {
+            if (!components.has(atom.name))
+                components.set(atom.name, atom.component);
+        }
+        return components;
+    }, [atoms]);
+    const serializedValueJson = (0, RichTextEditorSerialization_1.useSerializedValue)(valueJSON, (doc) => (0, RichTextEditorSerialization_1.stringifyCachedJson)((0, schemas_1.normalizeDocumentJson)(doc, documentDescriptor)), valueJSONRevision);
+    const controlledValueJSON = (0, react_1.useMemo)(() => serializedValueJson == null
+        ? undefined
+        : JSON.parse(serializedValueJson), [serializedValueJson]);
+    const bridge = documentHandle.bridge;
+    const editorId = documentHandle.editorId;
+    const nativeViewRef = (0, react_1.useRef)(null);
+    const externalCompositionManager = (0, react_1.useMemo)(() => new ExternalTextComposition_1.ExternalTextCompositionManager(editorId, () => nativeViewRef.current), [editorId]);
+    const managerDisposalsRef = (0, react_1.useRef)(new Map());
+    (0, react_1.useEffect)(() => {
+        const pendingDisposal = managerDisposalsRef.current.get(externalCompositionManager);
+        if (pendingDisposal != null) {
+            pendingDisposal.cancelled = true;
+            managerDisposalsRef.current.delete(externalCompositionManager);
+        }
+        return () => {
+            const token = { cancelled: false };
+            managerDisposalsRef.current.set(externalCompositionManager, token);
+            void Promise.resolve().then(() => {
+                if (token.cancelled ||
+                    managerDisposalsRef.current.get(externalCompositionManager) !== token) {
+                    return;
+                }
+                managerDisposalsRef.current.delete(externalCompositionManager);
+                externalCompositionManager.dispose();
+            });
+        };
+    }, [externalCompositionManager]);
+    const controlledValueKey = value != null
+        ? `html:${value}`
+        : serializedValueJson == null
+            ? null
+            : `json:${serializedValueJson}`;
+    const currentControlledValue = {
+        manager: externalCompositionManager,
+        key: controlledValueKey,
+        value,
+        valueJSON: controlledValueJSON,
+    };
+    const deliveredControlledValueRef = (0, react_1.useRef)(currentControlledValue);
+    if (deliveredControlledValueRef.current.manager !== externalCompositionManager ||
+        valueJSONUpdateMode !== 'reset' ||
+        controlledValueKey == null ||
+        deliveredControlledValueRef.current.key === controlledValueKey) {
+        deliveredControlledValueRef.current = currentControlledValue;
+    }
+    const latestControlledValueRef = (0, react_1.useRef)({
+        ...currentControlledValue,
+        mode: valueJSONUpdateMode,
+        handle: documentHandle,
+    });
+    latestControlledValueRef.current = {
+        ...currentControlledValue,
+        mode: valueJSONUpdateMode,
+        handle: documentHandle,
+    };
+    const pendingResetCancellationRef = (0, react_1.useRef)(null);
+    const blockedControlledResetRef = (0, react_1.useRef)(null);
+    const [, setControlledResetRevision] = (0, react_1.useState)(0);
+    (0, react_1.useLayoutEffect)(() => {
+        if (valueJSONUpdateMode !== 'reset' ||
+            controlledValueKey == null ||
+            deliveredControlledValueRef.current.manager !== externalCompositionManager ||
+            deliveredControlledValueRef.current.key === controlledValueKey ||
+            pendingResetCancellationRef.current?.manager === externalCompositionManager ||
+            (blockedControlledResetRef.current?.manager === externalCompositionManager &&
+                blockedControlledResetRef.current.key === controlledValueKey)) {
+            return;
+        }
+        const pending = { manager: externalCompositionManager };
+        pendingResetCancellationRef.current = pending;
+        void externalCompositionManager.cancelForDocumentChange().then(() => {
+            if (pendingResetCancellationRef.current !== pending)
+                return;
+            pendingResetCancellationRef.current = null;
+            const latest = latestControlledValueRef.current;
+            if (latest.manager !== externalCompositionManager ||
+                latest.mode !== 'reset' ||
+                latest.key == null ||
+                deliveredControlledValueRef.current.key === latest.key ||
+                latest.handle.isDestroyed ||
+                managerDisposalsRef.current.has(externalCompositionManager)) {
+                return;
+            }
+            blockedControlledResetRef.current = null;
+            deliveredControlledValueRef.current = {
+                manager: latest.manager,
+                key: latest.key,
+                value: latest.value,
+                valueJSON: latest.valueJSON,
+            };
+            setControlledResetRevision((revision) => revision + 1);
+        }, (error) => {
+            if (pendingResetCancellationRef.current !== pending)
+                return;
+            pendingResetCancellationRef.current = null;
+            const latest = latestControlledValueRef.current;
+            if (latest.manager !== externalCompositionManager ||
+                latest.mode !== 'reset' ||
+                latest.key == null ||
+                deliveredControlledValueRef.current.key === latest.key ||
+                latest.handle.isDestroyed ||
+                managerDisposalsRef.current.has(externalCompositionManager)) {
+                return;
+            }
+            blockedControlledResetRef.current = {
+                manager: externalCompositionManager,
+                key: latest.key,
+            };
+            latest.handle.bridge._emitAutonomousError((0, RichTextEditorSerialization_1.externalCompositionErrorPayload)(error));
+        });
+    }, [controlledValueKey, externalCompositionManager, valueJSONUpdateMode]);
+    const deliveredControlledValue = deliveredControlledValueRef.current;
+    const document = (0, useNativeEditor_1.useNativeEditorDocument)({
+        handle: documentHandle,
+        value: deliveredControlledValue.value,
+        valueJSON: deliveredControlledValue.valueJSON,
+        valueJSONUpdateMode,
+        revisionSignal: documentRevision ?? null,
+        onContentChange,
+        onContentChangeJSON,
+        onHistoryStateChange,
+        onLocalCommit,
+    });
+    const nativeErrorBindingRef = (0, react_1.useRef)({
+        handle: documentHandle,
+        editorId,
+        generation: 0,
+        mounted: true,
+    });
+    if (nativeErrorBindingRef.current.handle !== documentHandle) {
+        nativeErrorBindingRef.current = {
+            handle: documentHandle,
+            editorId,
+            generation: nativeErrorBindingRef.current.generation + 1,
+            mounted: true,
+        };
+    }
+    const nativeErrorBinding = nativeErrorBindingRef.current;
+    (0, react_1.useEffect)(() => {
+        const currentBinding = nativeErrorBindingRef.current;
+        if (currentBinding !== nativeErrorBinding &&
+            !currentBinding.mounted &&
+            currentBinding.handle === nativeErrorBinding.handle &&
+            currentBinding.editorId === nativeErrorBinding.editorId &&
+            currentBinding.generation === nativeErrorBinding.generation + 1) {
+            nativeErrorBindingRef.current = nativeErrorBinding;
+        }
+        return () => {
+            if (nativeErrorBindingRef.current !== nativeErrorBinding)
+                return;
+            nativeErrorBindingRef.current = {
+                ...nativeErrorBinding,
+                generation: nativeErrorBinding.generation + 1,
+                mounted: false,
+            };
+        };
+    }, [nativeErrorBinding]);
+    const onSelectionChangeRef = (0, react_1.useRef)(onSelectionChange);
+    onSelectionChangeRef.current = onSelectionChange;
+    const onActiveStateChangeRef = (0, react_1.useRef)(onActiveStateChange);
+    onActiveStateChangeRef.current = onActiveStateChange;
+    const onFocusRef = (0, react_1.useRef)(onFocus);
+    onFocusRef.current = onFocus;
+    const onBlurRef = (0, react_1.useRef)(onBlur);
+    onBlurRef.current = onBlur;
+    const onToolbarActionRef = (0, react_1.useRef)(onToolbarAction);
+    onToolbarActionRef.current = onToolbarAction;
+    const onRequestLinkRef = (0, react_1.useRef)(onRequestLink);
+    onRequestLinkRef.current = onRequestLink;
+    const onRequestImageRef = (0, react_1.useRef)(onRequestImage);
+    onRequestImageRef.current = onRequestImage;
+    const onLocalCommitRef = (0, react_1.useRef)(onLocalCommit);
+    onLocalCommitRef.current = onLocalCommit;
+    const addonsRef = (0, react_1.useRef)(addons);
+    addonsRef.current = addons;
+    const [activeState, setActiveState] = (0, react_1.useState)(RichTextEditorSerialization_1.EMPTY_ACTIVE_STATE);
+    const [pushedUpdate, setPushedUpdate] = (0, react_1.useState)(null);
+    const [autoGrowHeight, setAutoGrowHeight] = (0, react_1.useState)(null);
+    const [isFocused, setIsFocused] = (0, react_1.useState)(false);
+    const [mentionQuery, setMentionQuery] = (0, react_1.useState)(null);
+    const [atomState, setAtomState] = (0, react_1.useState)({
+        blocks: [],
+        instanceBlocks: [],
+        instances: [],
+        documentVersion: null,
+        hasOnlyStableAtomKeys: true,
+    });
+    const atomStateRef = (0, react_1.useRef)(atomState);
+    const [selectedKeys, setSelectedKeys] = (0, react_1.useState)(new Set());
+    const [atomContentWidth, setAtomContentWidth] = (0, react_1.useState)(null);
+    const [atomPositions, setAtomPositions] = (0, react_1.useState)(new Map());
+    const [nativeAtomViewport, setNativeAtomViewport] = (0, react_1.useState)();
+    const warnedUnknownAtomTypesRef = (0, react_1.useRef)(new Set());
+    const atomSeedEditorIdRef = (0, react_1.useRef)(null);
+    const activeStateRef = (0, react_1.useRef)(RichTextEditorSerialization_1.EMPTY_ACTIVE_STATE);
+    const activeStateKeyRef = (0, react_1.useRef)(null);
+    const selectionRef = (0, react_1.useRef)({ type: 'text', anchor: 0, head: 0 });
+    const scalarSelectionRef = (0, react_1.useRef)({ anchor: 0, head: 0 });
+    const isFocusedRef = (0, react_1.useRef)(false);
+    const toolbarFrameOwnerIdRef = (0, react_1.useRef)(null);
+    if (toolbarFrameOwnerIdRef.current == null) {
+        toolbarFrameOwnerIdRef.current = (0, RichTextEditorSerialization_1.allocateToolbarFrameOwnerId)();
+    }
+    const toolbarFrameOwnerId = toolbarFrameOwnerIdRef.current;
+    const registeredToolbarFrames = (0, EditorToolbar_1.useEditorToolbarFrames)(toolbarFrameOwnerId);
+    const { frames: suppliedFocusPreservingFrames, refresh: refreshFocusPreservingFrames } = (0, useFocusPreservingFrames_1.useFocusPreservingFrames)(focusPreservingRefs, editable && isFocused);
+    const latestRevisionRef = (0, react_1.useRef)(null);
+    const currentPushedUpdateEditorIdRef = (0, react_1.useRef)(editorId);
+    currentPushedUpdateEditorIdRef.current = editorId;
+    const pushedUpdateBindingGenerationRef = (0, react_1.useRef)(0);
+    const pushRevisionRef = (0, react_1.useRef)(0);
+    const lastPushedEngineRevisionRef = (0, react_1.useRef)(null);
+    const lastNativeDrivenRevisionRef = (0, react_1.useRef)(null);
+    const lastAcceptedNativeCommitRevisionRef = (0, react_1.useRef)(null);
+    const didObserveInitialRevisionRef = (0, react_1.useRef)(false);
+    const toolbarItemsSerializationCacheRef = (0, react_1.useRef)(null);
+    const revisionScopeEditorIdRef = (0, react_1.useRef)(editorId);
+    const latestRevisionScopeEditorIdRef = (0, react_1.useRef)(editorId);
+    const pendingFocusedRebindRef = (0, react_1.useRef)(null);
+    const didRebindRevisionScope = revisionScopeEditorIdRef.current !== editorId;
+    if (didRebindRevisionScope) {
+        pendingFocusedRebindRef.current = null;
+        if (isFocusedRef.current && document.isReady) {
+            pendingFocusedRebindRef.current = {
+                editorId,
+                ...scalarSelectionRef.current,
+            };
+        }
+        else if (isFocusedRef.current) {
+            isFocusedRef.current = false;
+            setIsFocused(false);
+        }
+        pushedUpdateBindingGenerationRef.current += 1;
+        revisionScopeEditorIdRef.current = editorId;
+        latestRevisionScopeEditorIdRef.current = null;
+        latestRevisionRef.current = null;
+        selectionRef.current = { type: 'text', anchor: 0, head: 0 };
+        activeStateRef.current = RichTextEditorSerialization_1.EMPTY_ACTIVE_STATE;
+        activeStateKeyRef.current = null;
+        toolbarItemsSerializationCacheRef.current = null;
+        setActiveState(RichTextEditorSerialization_1.EMPTY_ACTIVE_STATE);
+        setPushedUpdate(null);
+        setAutoGrowHeight(null);
+        const emptyAtomState = {
+            blocks: [],
+            instanceBlocks: [],
+            instances: [],
+            documentVersion: null,
+            hasOnlyStableAtomKeys: true,
+        };
+        atomStateRef.current = emptyAtomState;
+        atomSeedEditorIdRef.current = null;
+        setAtomState(emptyAtomState);
+        setSelectedKeys(new Set());
+        setAtomContentWidth(null);
+        setAtomPositions(new Map());
+        pushRevisionRef.current = 0;
+        lastPushedEngineRevisionRef.current = null;
+        lastNativeDrivenRevisionRef.current = null;
+        lastAcceptedNativeCommitRevisionRef.current = null;
+        didObserveInitialRevisionRef.current = false;
+    }
+    else if (latestRevisionScopeEditorIdRef.current === editorId) {
+        latestRevisionRef.current = document.documentRevision;
+    }
+    (0, react_1.useEffect)(() => {
+        if (heightBehavior !== 'autoGrow') {
+            setAutoGrowHeight(null);
+        }
+    }, [heightBehavior]);
+    // A changed handle initially shares the previous hook render. Do not
+    // trust that render's revision: establish the new mutation base only by
+    // reading the currently bound handle after the rebind commits.
+    (0, react_1.useEffect)(() => {
+        if (latestRevisionScopeEditorIdRef.current === editorId || documentHandle.isDestroyed) {
+            return;
+        }
+        latestRevisionRef.current = documentHandle.bridge.getState().documentRevision;
+        latestRevisionScopeEditorIdRef.current = editorId;
+    }, [documentHandle, editorId]);
+    (0, react_1.useEffect)(() => () => {
+        (0, EditorToolbar_1.setActiveEditorToolbarFrameOwnerForEditor)(toolbarFrameOwnerId, false);
+        (0, EditorToolbar_1.setEditorToolbarMentionState)(toolbarFrameOwnerId, null);
+    }, [editorId, toolbarFrameOwnerId]);
+    return {
+        atomStateRef,
+        setSelectedKeys,
+        bridge,
+        registeredAtomTypes,
+        setAtomState,
+        selectionRef,
+        document,
+        documentHandle,
+        atomSeedEditorIdRef,
+        editorId,
+        scalarSelectionRef,
+        activeStateRef,
+        setActiveState,
+        activeStateKeyRef,
+        onActiveStateChangeRef,
+        pushedUpdateBindingGenerationRef,
+        currentPushedUpdateEditorIdRef,
+        pushRevisionRef,
+        lastPushedEngineRevisionRef,
+        setPushedUpdate,
+        pendingFocusedRebindRef,
+        toolbarFrameOwnerId,
+        onFocusRef,
+        didRebindRevisionScope,
+        didObserveInitialRevisionRef,
+        lastNativeDrivenRevisionRef,
+        onLocalCommitRef,
+        editable,
+        latestRevisionRef,
+        nativeViewRef,
+        documentDescriptor,
+        onRequestLinkRef,
+        onRequestImageRef,
+        ref,
+        externalCompositionManager,
+        lastAcceptedNativeCommitRevisionRef,
+        nativeErrorBindingRef,
+        nativeErrorBinding,
+        onSelectionChangeRef,
+        isFocusedRef,
+        setIsFocused,
+        onBlurRef,
+        heightBehavior,
+        setAutoGrowHeight,
+        setAtomContentWidth,
+        setNativeAtomViewport,
+        setAtomPositions,
+        onToolbarActionRef,
+        addonsRef,
+        setMentionQuery,
+        mentionQuery,
+        addons,
+        isFocused,
+        theme,
+        imageLoadingPolicy,
+        androidInputOptions,
+        remoteSelections,
+        atoms,
+        atomState,
+        atomComponents,
+        warnedUnknownAtomTypesRef,
+        atomContentWidth,
+        atomPositions,
+        atomViewport,
+        virtualizeAtoms,
+        nativeAtomViewport,
+        selectedKeys,
+        atomsInteractive,
+        activeState,
+        onRequestLink,
+        onRequestImage,
+        toolbarItemsSerializationCacheRef,
+        toolbarItems,
+        toolbarPlacement,
+        showToolbar,
+        containerStyle: containerStyle,
+        style: style,
+        autoGrowHeight,
+        pushedUpdate,
+        registeredToolbarFrames,
+        suppliedFocusPreservingFrames,
+        refreshFocusPreservingFrames,
+        accessibilityLabel,
+        accessibilityHint,
+        placeholder,
+        autoFocus,
+        autoCapitalize,
+        autoCorrect,
+        keyboardType,
+        allowImageResizing,
+        onToolbarAction,
+    };
+}

package/dist/useRichTextEditorUpdates.d.ts

@@ -0,0 +1,10 @@
+import { type NativeEditorAtomicRenderSnapshot, type Selection } from './NativeEditorBridge';
+import { useRichTextEditorState } from './useRichTextEditorState';
+export declare function useRichTextEditorUpdates(context: Pick<ReturnType<typeof useRichTextEditorState>, 'atomStateRef' | 'setSelectedKeys' | 'bridge' | 'registeredAtomTypes' | 'setAtomState' | 'selectionRef' | 'document' | 'documentHandle' | 'atomSeedEditorIdRef' | 'editorId' | 'scalarSelectionRef' | 'activeStateRef' | 'setActiveState' | 'activeStateKeyRef' | 'onActiveStateChangeRef' | 'pushedUpdateBindingGenerationRef' | 'currentPushedUpdateEditorIdRef' | 'pushRevisionRef' | 'lastPushedEngineRevisionRef' | 'setPushedUpdate' | 'pendingFocusedRebindRef' | 'toolbarFrameOwnerId' | 'onFocusRef' | 'didRebindRevisionScope' | 'didObserveInitialRevisionRef' | 'lastNativeDrivenRevisionRef' | 'onLocalCommitRef'>): {
+    refreshAtomsFromUpdate: (update: NativeEditorAtomicRenderSnapshot) => void;
+    afterLocalEngineMutation: () => void;
+    pushEngineUpdateToView: () => void;
+    applyTypedUpdateState: (update: Pick<NativeEditorAtomicRenderSnapshot, "selection" | "activeState">, isCurrent?: () => boolean) => boolean;
+    applyUpdateState: (updateJson: string | null | undefined) => Record<string, unknown> | null;
+    updateAtomSelection: (selection: Selection, instances?: import("./atomInstances").AtomInstance[]) => void;
+};