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

package/dist/useRichTextEditorUpdates.js

@@ -0,0 +1,308 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useRichTextEditorUpdates = useRichTextEditorUpdates;
+const react_1 = require("react");
+const atomInstances_1 = require("./atomInstances");
+const EditorUpdateRevision_1 = require("./EditorUpdateRevision");
+const EditorToolbar_1 = require("./EditorToolbar");
+const RichTextEditorSerialization_1 = require("./RichTextEditorSerialization");
+function useRichTextEditorUpdates(context) {
+    const { 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, } = context;
+    const updateAtomSelection = (0, react_1.useCallback)((selection, instances = atomStateRef.current.instances) => {
+        const next = (0, RichTextEditorSerialization_1.selectedAtomKeys)(selection, instances);
+        setSelectedKeys((current) => ((0, RichTextEditorSerialization_1.equalStringSets)(current, next) ? current : next));
+    }, []);
+    const refreshAtomsFromUpdate = (0, react_1.useCallback)((update) => {
+        const previous = atomStateRef.current;
+        const source = update.renderPatch != null &&
+            update.renderPatch.baseDocumentVersion !== previous.documentVersion
+            ? bridge.renderUpdate()
+            : update;
+        if (source.renderPatch != null &&
+            source.renderPatch.baseDocumentVersion !== previous.documentVersion) {
+            return;
+        }
+        const blocks = source.renderBlocks != null
+            ? source.renderBlocks
+            : (0, atomInstances_1.applyRenderPatch)(previous.blocks, {
+                startIndex: source.renderPatch.startIndex,
+                deleteCount: source.renderPatch.deleteCount,
+                renderBlocks: source.renderPatch.renderBlocks,
+            });
+        const patchedCollection = source.renderPatch != null && previous.hasOnlyStableAtomKeys
+            ? (0, atomInstances_1.collectAtomInstanceBlocks)(source.renderPatch.renderBlocks, registeredAtomTypes)
+            : null;
+        const collection = source.renderPatch != null && patchedCollection?.hasOnlyStableKeys
+            ? {
+                instanceBlocks: (0, atomInstances_1.applyRenderPatch)(previous.instanceBlocks, {
+                    startIndex: source.renderPatch.startIndex,
+                    deleteCount: source.renderPatch.deleteCount,
+                    renderBlocks: patchedCollection.instanceBlocks,
+                }),
+                hasOnlyStableKeys: true,
+            }
+            : (0, atomInstances_1.collectAtomInstanceBlocks)(blocks, registeredAtomTypes);
+        const instances = collection.instanceBlocks.flat();
+        const next = {
+            blocks,
+            instanceBlocks: collection.instanceBlocks,
+            instances,
+            documentVersion: source.documentVersion,
+            hasOnlyStableAtomKeys: collection.hasOnlyStableKeys,
+        };
+        atomStateRef.current = next;
+        if (!(0, RichTextEditorSerialization_1.equalAtomInstances)(previous.instances, next.instances)) {
+            setAtomState(next);
+        }
+        updateAtomSelection(selectionRef.current, next.instances);
+    }, [bridge, registeredAtomTypes, updateAtomSelection]);
+    (0, react_1.useEffect)(() => {
+        const current = atomStateRef.current;
+        const collection = (0, atomInstances_1.collectAtomInstanceBlocks)(current.blocks, registeredAtomTypes);
+        const instances = collection.instances;
+        const next = {
+            blocks: current.blocks,
+            instanceBlocks: collection.instanceBlocks,
+            instances,
+            documentVersion: current.documentVersion,
+            hasOnlyStableAtomKeys: collection.hasOnlyStableKeys,
+        };
+        atomStateRef.current = next;
+        if (!(0, RichTextEditorSerialization_1.equalAtomInstances)(current.instances, instances)) {
+            setAtomState(next);
+        }
+        updateAtomSelection(selectionRef.current, instances);
+    }, [registeredAtomTypes, updateAtomSelection]);
+    (0, react_1.useLayoutEffect)(() => {
+        if (!document.isReady ||
+            documentHandle.isDestroyed ||
+            atomSeedEditorIdRef.current === editorId) {
+            return;
+        }
+        atomSeedEditorIdRef.current = editorId;
+        refreshAtomsFromUpdate(bridge.renderUpdate());
+    }, [bridge, document.isReady, documentHandle, editorId, refreshAtomsFromUpdate]);
+    const applyTypedUpdateState = (0, react_1.useCallback)((update, isCurrent = () => true) => {
+        if (!isCurrent())
+            return false;
+        selectionRef.current = update.selection;
+        updateAtomSelection(update.selection);
+        if (update.selection.type === 'text' &&
+            update.selection.anchorScalar != null &&
+            update.selection.headScalar != null) {
+            scalarSelectionRef.current = {
+                anchor: update.selection.anchorScalar,
+                head: update.selection.headScalar,
+            };
+        }
+        if (!isCurrent())
+            return false;
+        const nextActiveState = update.activeState;
+        activeStateRef.current = nextActiveState;
+        if (!isCurrent())
+            return false;
+        setActiveState(nextActiveState);
+        if (!isCurrent())
+            return false;
+        const key = (0, RichTextEditorSerialization_1.stringifyCachedJson)(nextActiveState);
+        if (key !== activeStateKeyRef.current) {
+            if (!isCurrent())
+                return false;
+            activeStateKeyRef.current = key;
+            if (!isCurrent())
+                return false;
+            onActiveStateChangeRef.current?.(nextActiveState);
+        }
+        return isCurrent();
+    }, [updateAtomSelection]);
+    const applyUpdateState = (0, react_1.useCallback)((updateJson) => {
+        if (typeof updateJson !== 'string' || updateJson.length === 0)
+            return null;
+        let parsed;
+        try {
+            const candidate = JSON.parse(updateJson);
+            if (!(0, RichTextEditorSerialization_1.isRecord)(candidate))
+                return null;
+            parsed = candidate;
+        }
+        catch {
+            return null;
+        }
+        const nextSelection = (0, RichTextEditorSerialization_1.parseSelectionFromUpdate)(parsed.selection);
+        const nextActiveState = (0, RichTextEditorSerialization_1.parseActiveStateFromUpdate)(parsed.activeState);
+        if (nextSelection && nextActiveState) {
+            applyTypedUpdateState({
+                selection: nextSelection,
+                activeState: nextActiveState,
+            });
+        }
+        else if (nextSelection) {
+            selectionRef.current = nextSelection;
+        }
+        else if (nextActiveState) {
+            activeStateRef.current = nextActiveState;
+            setActiveState(nextActiveState);
+            const key = (0, RichTextEditorSerialization_1.stringifyCachedJson)(nextActiveState);
+            if (key !== activeStateKeyRef.current) {
+                activeStateKeyRef.current = key;
+                onActiveStateChangeRef.current?.(nextActiveState);
+            }
+        }
+        return parsed;
+    }, [applyTypedUpdateState]);
+    const pushEngineUpdateToView = (0, react_1.useCallback)(() => {
+        if (documentHandle.isDestroyed)
+            return;
+        const sourceEditorId = documentHandle.editorId;
+        const sourceBindingGeneration = pushedUpdateBindingGenerationRef.current;
+        const isCurrentSource = () => {
+            const current = sourceEditorId === currentPushedUpdateEditorIdRef.current &&
+                sourceBindingGeneration === pushedUpdateBindingGenerationRef.current;
+            return current;
+        };
+        const allocation = (0, EditorUpdateRevision_1.allocateEditorUpdateRevision)(pushRevisionRef.current);
+        if ('error' in allocation) {
+            bridge._emitAutonomousError(allocation.error);
+            return;
+        }
+        const reset = bridge._pendingViewReset;
+        const snapshot = bridge.renderUpdate();
+        // renderUpdate can synchronously re-enter React and bind this
+        // component to another handle. Do not let any side effect from A
+        // reach B once that happens.
+        if (!isCurrentSource())
+            return;
+        refreshAtomsFromUpdate(snapshot);
+        if (!isCurrentSource())
+            return;
+        const updateJson = JSON.stringify(snapshot);
+        if (!isCurrentSource())
+            return;
+        if (!applyTypedUpdateState(snapshot, isCurrentSource)) {
+            return;
+        }
+        if (!isCurrentSource())
+            return;
+        lastPushedEngineRevisionRef.current = snapshot.documentVersion;
+        if (!isCurrentSource())
+            return;
+        pushRevisionRef.current = allocation.revision;
+        if (!isCurrentSource())
+            return;
+        setPushedUpdate({
+            json: updateJson,
+            resetJson: reset?.json,
+            revision: allocation.revision,
+            editorId: sourceEditorId,
+        });
+        if (bridge._pendingViewReset === reset)
+            bridge._pendingViewReset = null;
+    }, [applyTypedUpdateState, bridge, documentHandle, refreshAtomsFromUpdate]);
+    (0, react_1.useLayoutEffect)(() => {
+        const pending = pendingFocusedRebindRef.current;
+        if (pending?.editorId !== editorId || !document.isReady)
+            return;
+        pendingFocusedRebindRef.current = null;
+        const snapshot = bridge.renderUpdate();
+        const anchor = Math.min(pending.anchor, snapshot.scalarLength);
+        const head = Math.min(pending.head, snapshot.scalarLength);
+        const collapsed = anchor === head;
+        const setSelection = (affinity) => bridge.setSelection({
+            baseDocumentRevision: snapshot.documentVersion,
+            selection: {
+                type: 'text',
+                anchor: { offset: anchor, kind: 'scalar', affinity },
+                head: { offset: head, kind: 'scalar', affinity },
+            },
+        });
+        try {
+            try {
+                setSelection(collapsed ? 'after' : 'before');
+            }
+            catch (error) {
+                if (!collapsed || !(0, RichTextEditorSerialization_1.isPositionInvalidError)(error))
+                    throw error;
+                setSelection('before');
+            }
+            pushEngineUpdateToView();
+        }
+        catch (error) {
+            if (!(0, RichTextEditorSerialization_1.isPositionInvalidError)(error))
+                throw error;
+        }
+        (0, EditorToolbar_1.setActiveEditorToolbarFrameOwnerForEditor)(toolbarFrameOwnerId, true);
+        onFocusRef.current?.();
+    }, [bridge, document.isReady, editorId, pushEngineUpdateToView, toolbarFrameOwnerId]);
+    // A pending update is owned by the handle that produced its snapshot.
+    // Drop it when this component rebinds, so no old session state reaches
+    // the next native view binding.
+    (0, react_1.useEffect)(() => {
+        setPushedUpdate((current) => {
+            if (current == null || current.editorId === editorId)
+                return current;
+            return null;
+        });
+    }, [editorId]);
+    const pendingViewReset = bridge._pendingViewReset;
+    // After a JS-driven engine change (controlled apply, remote commit,
+    // document-API mutation) the view learns the new state here. Native-
+    // driven commits (typing, native toolbar) already updated the view
+    // through the adapter and are never echoed back. The first observed
+    // revision is skipped: the view pulls the initial state natively on bind.
+    (0, react_1.useEffect)(() => {
+        // The document hook refreshes its state after the rebind commit. Its
+        // first render can therefore still contain A's revision; do not let
+        // that stale snapshot establish B's initial-observation state.
+        if (didRebindRevisionScope) {
+            return;
+        }
+        if (!document.isReady || document.documentRevision == null)
+            return;
+        const revision = document.documentRevision;
+        if (!pendingViewReset && !didObserveInitialRevisionRef.current) {
+            didObserveInitialRevisionRef.current = true;
+            lastPushedEngineRevisionRef.current = revision;
+            return;
+        }
+        if (!pendingViewReset &&
+            lastPushedEngineRevisionRef.current != null &&
+            BigInt(revision) <= BigInt(lastPushedEngineRevisionRef.current)) {
+            return;
+        }
+        if (!pendingViewReset &&
+            (revision === lastNativeDrivenRevisionRef.current ||
+                document.documentOrigin === 'nativeView' ||
+                document.documentOrigin === 'remoteCollaboration')) {
+            if (document.documentOrigin === 'remoteCollaboration' && !documentHandle.isDestroyed) {
+                refreshAtomsFromUpdate(bridge.renderUpdate());
+            }
+            lastPushedEngineRevisionRef.current = revision;
+            return;
+        }
+        lastNativeDrivenRevisionRef.current = null;
+        pushEngineUpdateToView();
+    }, [
+        pendingViewReset,
+        didRebindRevisionScope,
+        document.isReady,
+        document.documentRevision,
+        document.documentOrigin,
+        bridge,
+        documentHandle,
+        pushEngineUpdateToView,
+        refreshAtomsFromUpdate,
+    ]);
+    const afterLocalEngineMutation = (0, react_1.useCallback)(() => {
+        onLocalCommitRef.current?.();
+        pushEngineUpdateToView();
+        document.refresh();
+    }, [document, pushEngineUpdateToView]);
+    return {
+        refreshAtomsFromUpdate,
+        afterLocalEngineMutation,
+        pushEngineUpdateToView,
+        applyTypedUpdateState,
+        applyUpdateState,
+        updateAtomSelection,
+    };
+}

package/dist/useViewerAtoms.d.ts

@@ -0,0 +1,38 @@
+import { type LayoutChangeEvent, type NativeSyntheticEvent } from 'react-native';
+import { type AtomNodeDefinition } from './atoms';
+import { type AtomViewport } from './AtomHost';
+import type { RichTextViewerErrorEvent } from './NativeProseViewer';
+export interface RichTextViewerAtomAttrsUpdateEvent {
+    nodeType: string;
+    atomId?: string;
+    /** Position in the content snapshot rendered by this viewer. */
+    docPos: number;
+    attrs: Readonly<Record<string, unknown>>;
+    partial: Readonly<Record<string, unknown>>;
+}
+export interface ViewerAtomLayoutEvent {
+    generation: string;
+    revision: string;
+    layoutWidth: number;
+    atomsJson: string;
+}
+type UpdateHandler = (event: RichTextViewerAtomAttrsUpdateEvent) => void | Promise<void>;
+export declare function useViewerAtoms({ atoms, identity, themeJson, readOnly, interactive, viewport, onUpdateAtomAttrs, onError, }: {
+    atoms?: readonly AtomNodeDefinition<any>[];
+    identity: object;
+    themeJson?: string;
+    readOnly: boolean;
+    interactive?: boolean;
+    viewport?: AtomViewport;
+    onUpdateAtomAttrs?: UpdateHandler;
+    onError?: (event: RichTextViewerErrorEvent) => void;
+}): {
+    enabled: boolean;
+    themeJson: string | undefined;
+    onAtomLayout: (event: NativeSyntheticEvent<ViewerAtomLayoutEvent>) => void;
+    onContainerLayout: (event: LayoutChangeEvent) => void;
+    children: (import("react/jsx-runtime").JSX.Element | null)[];
+};
+/** @deprecated Use RichTextViewerAtomAttrsUpdateEvent instead. */
+export type NativeProseViewerAtomAttrsUpdateEvent = RichTextViewerAtomAttrsUpdateEvent;
+export {};

package/dist/useViewerAtoms.js

@@ -0,0 +1,288 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useViewerAtoms = useViewerAtoms;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
+const react_native_1 = require("react-native");
+const atoms_1 = require("./atoms");
+const AtomHost_1 = require("./AtomHost");
+const atomUpdates_1 = require("./atomUpdates");
+const attributeValidation_1 = require("./attributeValidation");
+const atomInstances_1 = require("./atomInstances");
+let nextGeneration = 0;
+function isRecord(value) {
+    return value != null && typeof value === 'object' && !Array.isArray(value);
+}
+function parsePositions(json, definitions, snapshot) {
+    const values = JSON.parse(json);
+    if (!Array.isArray(values))
+        throw new Error('Atom positions must be an array.');
+    const seen = new Set();
+    const identities = new Set();
+    return values.map((value) => {
+        if (!isRecord(value) ||
+            typeof value.nodeType !== 'string' ||
+            !definitions.has(value.nodeType) ||
+            !Number.isInteger(value.docPos) ||
+            Number(value.docPos) < 0 ||
+            Number(value.docPos) > 0xffffffff ||
+            typeof value.attrsJson !== 'string' ||
+            !['x', 'y', 'width', 'height'].every((key) => typeof value[key] === 'number' && Number.isFinite(value[key])) ||
+            Number(value.width) <= 0 ||
+            Number(value.height) < 0 ||
+            seen.has(Number(value.docPos))) {
+            throw new Error('Invalid prepared atom position.');
+        }
+        const attrs = JSON.parse(value.attrsJson);
+        if (!isRecord(attrs))
+            throw new Error('Atom attributes must be a JSON object.');
+        const idAttribute = definitions.get(value.nodeType)?.idAttribute;
+        const atomId = idAttribute == null ? undefined : attrs[idAttribute];
+        if (idAttribute != null && (typeof atomId !== 'string' || atomId.length === 0))
+            throw new Error('Atom identity must be a non-empty string.');
+        const key = typeof atomId === 'string'
+            ? JSON.stringify([value.nodeType, atomId])
+            : `${snapshot}:${value.docPos}:${value.nodeType}`;
+        if (identities.has(key))
+            throw new Error('Duplicate atom identity.');
+        identities.add(key);
+        seen.add(Number(value.docPos));
+        return { ...value, attrs, key, atomId };
+    });
+}
+function useViewerAtoms({ atoms, identity, themeJson, readOnly, interactive = true, viewport, onUpdateAtomAttrs, onError, }) {
+    const [width, setWidth] = (0, react_1.useState)(null);
+    const snapshot = (0, react_1.useMemo)(() => String(++nextGeneration), [identity]);
+    const serializedAtoms = (0, atoms_1.serializeEditorAtoms)(atoms);
+    const identifiers = JSON.stringify((atoms ?? []).map((atom) => [atom.name, atom.idAttribute]));
+    const generation = (0, react_1.useMemo)(() => String(++nextGeneration), [identity, identifiers, serializedAtoms, width]);
+    const definitions = (0, react_1.useMemo)(() => new Map((atoms ?? []).map((atom) => [atom.name, atom])), [atoms]);
+    const enabled = definitions.size > 0;
+    const [measurementState, setMeasurementState] = (0, react_1.useState)({
+        generation,
+        revision: 0,
+        values: {},
+    });
+    const measurements = measurementState.generation === generation ? measurementState.values : {};
+    const revision = String(measurementState.generation === generation ? measurementState.revision : 0);
+    const [layout, setLayout] = (0, react_1.useState)(null);
+    const pendingLayout = layout?.generation !== generation;
+    const renderedPositions = layout?.positions ?? [];
+    const positions = pendingLayout ? [] : renderedPositions;
+    const mountedMeasurements = (0, react_1.useRef)(new Map());
+    (0, react_1.useLayoutEffect)(() => {
+        for (const [key, measured] of mountedMeasurements.current) {
+            if (!definitions.has(measured.nodeType))
+                mountedMeasurements.current.delete(key);
+        }
+    }, [definitions]);
+    const mounted = (0, react_1.useRef)(false);
+    (0, react_1.useLayoutEffect)(() => {
+        mounted.current = true;
+        return () => {
+            mounted.current = false;
+        };
+    }, []);
+    const current = (0, react_1.useRef)({
+        generation,
+        snapshot,
+        revision,
+        positions,
+        renderedPositions,
+        pendingLayout,
+        definitions,
+        readOnly,
+        onUpdateAtomAttrs,
+        onError,
+        width,
+    });
+    current.current = {
+        generation,
+        snapshot,
+        revision,
+        positions,
+        renderedPositions,
+        pendingLayout,
+        definitions,
+        readOnly,
+        onUpdateAtomAttrs,
+        onError,
+        width,
+    };
+    const configuredThemeJson = (0, react_1.useMemo)(() => enabled
+        ? JSON.stringify({
+            ...(themeJson ? JSON.parse(themeJson) : {}),
+            viewerAtoms: {
+                ...JSON.parse(serializedAtoms),
+                generation,
+                revision,
+                measurements,
+            },
+        })
+        : themeJson, [enabled, themeJson, serializedAtoms, generation, revision, measurements]);
+    const onAtomLayout = (0, react_1.useCallback)((event) => {
+        const value = event.nativeEvent;
+        const latest = current.current;
+        if (!mounted.current ||
+            value.generation !== latest.generation ||
+            value.revision !== latest.revision ||
+            !Number.isFinite(value.layoutWidth) ||
+            value.layoutWidth <= 0 ||
+            (latest.width != null && Math.abs(latest.width - value.layoutWidth) > 1))
+            return;
+        try {
+            const next = parsePositions(value.atomsJson, latest.definitions, latest.snapshot);
+            const retainedMeasurements = {};
+            const retainedKeys = new Set();
+            for (const atom of next) {
+                const key = atom.key;
+                retainedKeys.add(key);
+                const measured = mountedMeasurements.current.get(key);
+                if (measured?.size.width === atom.width) {
+                    retainedMeasurements[String(atom.docPos)] = measured.size;
+                }
+            }
+            for (const key of mountedMeasurements.current.keys()) {
+                if (!retainedKeys.has(key))
+                    mountedMeasurements.current.delete(key);
+            }
+            // Unchanged mounted sizes do not emit another Yoga onLayout event.
+            setMeasurementState((previous) => previous.generation === value.generation
+                ? previous
+                : {
+                    generation: value.generation,
+                    revision: Object.keys(retainedMeasurements).length > 0 ? 1 : 0,
+                    values: retainedMeasurements,
+                });
+            setLayout((previous) => previous?.generation === value.generation && previous.json === value.atomsJson
+                ? previous
+                : { generation: value.generation, json: value.atomsJson, positions: next });
+        }
+        catch {
+            mountedMeasurements.current.clear();
+            setLayout(null);
+            latest.onError?.({
+                domain: 'viewer',
+                code: 'INVALID_ATOM_LAYOUT',
+                message: 'The prepared atom layout or attributes are invalid.',
+                fatal: false,
+            });
+        }
+    }, []);
+    const onContainerLayout = (0, react_1.useCallback)((event) => {
+        const next = event.nativeEvent.layout.width;
+        if (Number.isFinite(next) && next > 0)
+            setWidth((previous) => (previous === next ? previous : next));
+    }, []);
+    const updateQueues = (0, react_1.useRef)(new Map());
+    const acknowledged = (0, react_1.useRef)(new Map());
+    (0, react_1.useLayoutEffect)(() => {
+        acknowledged.current.clear();
+    }, [generation]);
+    const updateAttrs = (0, react_1.useCallback)((owner, atom, update) => {
+        const execute = async () => {
+            const latest = current.current;
+            if (!mounted.current)
+                throw new atomInstances_1.AtomUpdateAttrsError('not-ready', 'The viewer is unmounted.');
+            if (owner !== latest.generation ||
+                !latest.positions.some((position) => position.key === atom.key && position.attrsJson === atom.attrsJson)) {
+                throw new atomInstances_1.AtomUpdateAttrsError('stale-revision', 'The viewer content has changed.');
+            }
+            if (latest.readOnly || !latest.onUpdateAtomAttrs)
+                throw new atomInstances_1.AtomUpdateAttrsError('not-applicable', 'Viewer updates require readOnly={false} and onUpdateAtomAttrs.');
+            const accepted = acknowledged.current.get(atom.key);
+            const attrs = accepted?.generation === owner ? accepted.attrs : atom.attrs;
+            const partial = (0, atomUpdates_1.resolveAtomAttrsUpdate)(attrs, update);
+            const definition = latest.definitions.get(atom.nodeType);
+            try {
+                (0, attributeValidation_1.validateAttributes)({ ...attrs, ...partial }, definition.attrs ?? {});
+                if (definition.idAttribute &&
+                    Object.prototype.hasOwnProperty.call(partial, definition.idAttribute) &&
+                    partial[definition.idAttribute] !== attrs[definition.idAttribute])
+                    throw new Error('An atom identity cannot be changed.');
+            }
+            catch (error) {
+                throw new atomInstances_1.AtomUpdateAttrsError('not-applicable', error instanceof Error ? error.message : String(error));
+            }
+            await latest.onUpdateAtomAttrs({
+                nodeType: atom.nodeType,
+                atomId: atom.atomId,
+                docPos: atom.docPos,
+                attrs,
+                partial,
+            });
+            if (mounted.current && current.current.generation === owner)
+                acknowledged.current.set(atom.key, {
+                    generation: owner,
+                    attrs: { ...attrs, ...partial },
+                });
+        };
+        const previous = updateQueues.current.get(atom.key);
+        const result = previous ? previous.catch(() => { }).then(execute) : execute();
+        updateQueues.current.set(atom.key, result);
+        const clean = () => {
+            if (updateQueues.current.get(atom.key) === result)
+                updateQueues.current.delete(atom.key);
+        };
+        void result.then(clean, clean);
+        return result;
+    }, []);
+    const measure = (0, react_1.useCallback)((owner, atom, component, event) => {
+        const latest = current.current;
+        const measured = event.nativeEvent.layout;
+        if (!mounted.current ||
+            owner !== latest.generation ||
+            component !== latest.definitions.get(atom.nodeType)?.component ||
+            !Number.isFinite(measured.width) ||
+            measured.width <= 0 ||
+            !Number.isFinite(measured.height) ||
+            measured.height < 0 ||
+            Math.abs(measured.width - atom.width) > 1 ||
+            !latest.renderedPositions.some((position) => position.docPos === atom.docPos &&
+                position.nodeType === atom.nodeType &&
+                position.width === atom.width &&
+                position.attrsJson === atom.attrsJson))
+            return;
+        mountedMeasurements.current.set(atom.key, {
+            nodeType: atom.nodeType,
+            size: { width: atom.width, height: measured.height },
+        });
+        if (latest.pendingLayout)
+            return;
+        setMeasurementState((previous) => {
+            const values = previous.generation === owner ? previous.values : {};
+            const existing = values[String(atom.docPos)];
+            if (existing?.width === atom.width && existing.height === measured.height)
+                return previous;
+            return {
+                generation: owner,
+                revision: previous.generation === owner ? previous.revision + 1 : 1,
+                values: {
+                    ...values,
+                    [String(atom.docPos)]: { width: atom.width, height: measured.height },
+                },
+            };
+        });
+    }, []);
+    const children = renderedPositions.map((atom) => {
+        const Component = definitions.get(atom.nodeType)?.component;
+        if (!Component)
+            return null;
+        return ((0, jsx_runtime_1.jsx)(react_native_1.View, { collapsable: false, pointerEvents: !interactive || pendingLayout ? 'none' : 'box-none', accessibilityElementsHidden: pendingLayout, importantForAccessibility: pendingLayout ? 'no-hide-descendants' : 'auto', style: {
+                position: 'absolute',
+                left: atom.x,
+                top: atom.y,
+                width: atom.width,
+                opacity: pendingLayout ? 0 : 1,
+            }, onLayout: (event) => measure(generation, atom, Component, event), children: (0, jsx_runtime_1.jsx)(AtomHost_1.AtomHost, { component: Component, width: atom.width, estimatedHeight: atom.height, visible: (0, AtomHost_1.atomIsVisible)(atom.y, atom.height, viewport), onMeasure: (event) => measure(generation, atom, Component, event), atomProps: {
+                    attrs: atom.attrs,
+                    nodeType: atom.nodeType,
+                    selected: false,
+                    readOnly,
+                    interactive: interactive && !pendingLayout,
+                    isViewer: true,
+                    updateAttrs: (partial) => updateAttrs(layout.generation, atom, partial),
+                } }) }, atom.key));
+    });
+    return { enabled, themeJson: configuredThemeJson, onAtomLayout, onContainerLayout, children };
+}

package/expo-module.config.json

@@ -0,0 +1,13 @@
+{
+  "platforms": ["ios", "android"],
+  "ios": {
+    "modules": ["NativeEditorModule"],
+    "podspecPath": "./ReactNativeProseEditor.podspec"
+  },
+  "android": {
+    "name": "react-native-rich-text-editor$android-expo",
+    "path": "android/expo",
+    "gradlePath": "android/expo/build.gradle",
+    "modules": ["com.apollohg.editor.NativeEditorModule"]
+  }
+}