@handlewithcare/react-prosemirror 2.4.12 → 2.5.1

package/dist/esm/hooks/useEditor.js

@@ -1,178 +1,12 @@
-import { Schema } from "prosemirror-model";
-import { EditorState } from "prosemirror-state";
-import { DecorationSet, EditorView } from "prosemirror-view";
 import { useCallback, useMemo, useRef, useState } from "react";
 import { flushSync } from "react-dom";
+import { ReactEditorView } from "../ReactEditorView.js";
+import { StaticEditorView } from "../StaticEditorView.js";
+import { EMPTY_STATE } from "../constants.js";
 import { beforeInputPlugin } from "../plugins/beforeInputPlugin.js";
-import { SelectionDOMObserver } from "../selection/SelectionDOMObserver.js";
-import { setSsrStubs } from "../ssr.js";
-import { NodeViewDesc } from "../viewdesc.js";
 import { useClientLayoutEffect } from "./useClientLayoutEffect.js";
 import { useComponentEventListeners } from "./useComponentEventListeners.js";
 import { useForceUpdate } from "./useForceUpdate.js";
-function buildNodeViews(view) {
-    const result = Object.create(null);
-    function add(obj) {
-        for(const prop in obj)if (!Object.prototype.hasOwnProperty.call(result, prop)) // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        result[prop] = obj[prop];
-    }
-    view.someProp("nodeViews", add);
-    view.someProp("markViews", add);
-    return result;
-}
-function changedNodeViews(a, b) {
-    let nA = 0, nB = 0;
-    for(const prop in a){
-        if (a[prop] != b[prop]) return true;
-        nA++;
-    }
-    for(const _ in b)nB++;
-    return nA != nB;
-}
-function changedProps(a, b) {
-    for (const prop of Object.keys(a)){
-        if (a[prop] !== b[prop]) return true;
-    }
-    return false;
-}
-function getEditable(view) {
-    return !view.someProp("editable", (value)=>value(view.state) === false);
-}
-// @ts-expect-error We're making use of knowledge of internal methods here
-export class ReactEditorView extends EditorView {
-    shouldUpdatePluginViews = false;
-    oldProps;
-    _props;
-    ready;
-    constructor(place, props){
-        // Call the superclass constructor with an empty
-        // document and limited props. We'll set everything
-        // else ourselves.
-        const cleanup = setSsrStubs();
-        super(place, {
-            state: EditorState.create({
-                schema: props.state.schema
-            })
-        });
-        cleanup();
-        this.ready = props.ready;
-        this.shouldUpdatePluginViews = true;
-        this._props = props;
-        this.oldProps = {
-            state: props.state
-        };
-        this.state = props.state;
-        // @ts-expect-error We're making use of knowledge of internal attributes here
-        this.domObserver.stop();
-        // @ts-expect-error We're making use of knowledge of internal attributes here
-        this.domObserver = new SelectionDOMObserver(this);
-        // @ts-expect-error We're making use of knowledge of internal attributes here
-        this.domObserver.start();
-        this.editable = getEditable(this);
-        // Destroy the DOM created by the default
-        // ProseMirror ViewDesc implementation; we
-        // have a NodeViewDesc from React instead.
-        // @ts-expect-error We're making use of knowledge of internal attributes here
-        this.docView.dom.replaceChildren();
-        // @ts-expect-error We're making use of knowledge of internal attributes here
-        this.nodeViews = buildNodeViews(this);
-        // @ts-expect-error We're making use of knowledge of internal attributes here
-        this.docView = props.docView;
-    }
-    /**
-   * Whether the EditorView's updateStateInner method thinks that the
-   * docView needs to be blown away and redrawn.
-   *
-   * @privateremarks
-   *
-   * When ProseMirror View detects that the EditorState has been reconfigured
-   * to provide new custom node views, it calls an internal function that
-   * we can't override in order to recreate the entire editor DOM.
-   *
-   * This property mimics that check, so that we can replace the EditorView
-   * with another of our own, preventing ProseMirror View from taking over
-   * DOM management responsibility.
-   */ get needsRedraw() {
-        if (this.oldProps.state.plugins === this._props.state.plugins && this._props.plugins === this.oldProps.plugins) {
-            return false;
-        }
-        const newNodeViews = buildNodeViews(this);
-        // @ts-expect-error Internal property
-        return changedNodeViews(this.nodeViews, newNodeViews);
-    }
-    /**
-   * Like setProps, but without executing any side effects.
-   * Safe to use in a component render method.
-   */ pureSetProps(props) {
-        // this.oldProps = this.props;
-        this._props = {
-            ...this._props,
-            ...props
-        };
-        this.state = this._props.state;
-        this.editable = getEditable(this);
-    }
-    /**
-   * Triggers any side effects that have been queued by previous
-   * calls to pureSetProps.
-   */ runPendingEffects() {
-        if (changedProps(this.props, this.oldProps)) {
-            const newProps = this.props;
-            this._props = this.oldProps;
-            this.state = this._props.state;
-            this.update(newProps);
-        }
-    }
-    update(props) {
-        super.update(props);
-        // Ensure that side effects aren't re-triggered until
-        // pureSetProps is called again
-        this.oldProps = props;
-    }
-    updatePluginViews(prevState) {
-        if (this.shouldUpdatePluginViews) {
-            // @ts-expect-error We're making use of knowledge of internal methods here
-            super.updatePluginViews(prevState);
-        }
-    }
-    // We want to trigger the default EditorView cleanup, but without
-    // the actual view.dom cleanup (which React will have already handled).
-    // So we give the EditorView a dummy DOM element and ask it to clean up
-    destroy() {
-        // If needsRedraw returns true, then we will destroy and recreate
-        // the EditorView, but will likely leave the ProseMirrorDoc node as-is.
-        // In this case, this.dom will still be connected when destroy runs, and
-        // it will be reused for the next EditorView, so we need to manually reset
-        // it.
-        if (this.dom.isConnected) {
-            // We need to manually execute this code from super.destroy(),
-            // because when super.destroy() runs, it will have been given a dummy
-            // dom node
-            // @ts-expect-error Internal property - input
-            for(const type in this.input.eventHandlers){
-                // @ts-expect-error Internal property - input
-                this.dom.removeEventListener(type, this.input.eventHandlers[type]);
-            }
-        }
-        // @ts-expect-error we're intentionally overwriting this property
-        // to prevent side effects
-        this.dom = document.createElement("div");
-        super.destroy();
-    }
-}
-const EMPTY_SCHEMA = new Schema({
-    nodes: {
-        doc: {
-            content: "text*"
-        },
-        text: {
-            inline: true
-        }
-    }
-});
-const EMPTY_STATE = EditorState.create({
-    schema: EMPTY_SCHEMA
-});
 let didWarnValueDefaultValue = false;
 /**
  * Creates, mounts, and manages a ProseMirror `EditorView`.
@@ -185,7 +19,7 @@ let didWarnValueDefaultValue = false;
  */ export function useEditor(mount, options) {
     if (process.env.NODE_ENV !== "production") {
         if (options.defaultState !== undefined && options.state !== undefined && !didWarnValueDefaultValue) {
-            console.error("A component contains a ProseMirror editor with both value and defaultValue props. " + "ProseMirror editors must be either controlled or uncontrolled " + "(specify either the state prop, or the defaultState prop, but not both). " + "Decide between using a controlled or uncontrolled ProseMirror editor " + "and remove one of these props. More info: " + "https://reactjs.org/link/controlled-components");
+            console.error("A component contains a ProseMirror editor with both state and defaultState props. " + "ProseMirror editors must be either controlled or uncontrolled " + "(specify either the state prop, or the defaultState prop, but not both). " + "Decide between using a controlled or uncontrolled ProseMirror editor " + "and remove one of these props. More info: " + "https://reactjs.org/link/controlled-components");
             didWarnValueDefaultValue = true;
         }
     }
@@ -232,30 +66,18 @@ let didWarnValueDefaultValue = false;
         options.dispatchTransaction,
         options.state
     ]);
-    const cleanup = setSsrStubs();
-    const tempDom = document.createElement("div");
-    cleanup();
-    const docViewDescRef = useRef(new NodeViewDesc(undefined, [], ()=>-1, state.doc, [], DecorationSet.empty, tempDom, null, tempDom, ()=>false, ()=>{
-    /* The doc node can't have a node selection*/ }, ()=>{
-    /* The doc node can't have a node selection*/ }, ()=>false));
     const directEditorProps = {
         ...options,
         state,
         plugins,
-        dispatchTransaction,
-        docView: docViewDescRef.current,
-        ready: true
+        dispatchTransaction
     };
-    const [view, setView] = useState(// During the initial render, we create something of a dummy
-    // EditorView. This allows us to ensure that the first render actually
-    // renders the document, which is necessary for SSR.
-    ()=>new ReactEditorView(null, {
-            ...directEditorProps,
-            ready: false
-        }));
+    const [view, setView] = useState(()=>{
+        return new StaticEditorView(directEditorProps);
+    });
     useClientLayoutEffect(()=>{
         return ()=>{
-            view?.destroy();
+            view.destroy();
         };
     }, [
         view
@@ -265,44 +87,33 @@ let didWarnValueDefaultValue = false;
     // so this is not a concern.
     // eslint-disable-next-line react-hooks/exhaustive-deps
     useClientLayoutEffect(()=>{
-        if (!mount) {
-            setView(null);
-            return;
-        }
-        if (!view || view.dom !== mount) {
-            const newView = new ReactEditorView({
-                mount
-            }, directEditorProps);
-            setView(newView);
-            newView.dom.addEventListener("compositionend", forceUpdate);
-            return;
-        }
-        // TODO: We should be able to put this in previous branch,
-        // but we need to convince EditorView's constructor not to
-        // clear out the DOM when passed a mount that already has
-        // content in it, otherwise React blows up when it tries
-        // to clean up.
-        if (view.needsRedraw) {
-            setView(null);
-            return;
+        if (mount !== view.dom) {
+            if (mount) {
+                const view = new ReactEditorView({
+                    mount
+                }, directEditorProps);
+                view.dom.addEventListener("compositionend", forceUpdate);
+                setView(view);
+            } else {
+                const view = new StaticEditorView(directEditorProps);
+                setView(view);
+            }
+        } else if (view instanceof ReactEditorView) {
+            view.commitPendingEffects();
         }
-        // @ts-expect-error Internal property - domObserver
-        view?.domObserver.selectionToDOM();
-        view?.runPendingEffects();
     });
-    view?.pureSetProps(directEditorProps);
+    view.update(directEditorProps);
     const editor = useMemo(()=>({
-            view: view,
-            registerEventListener,
-            unregisterEventListener,
+            view,
             cursorWrapper,
-            docViewDescRef,
-            flushSyncRef
+            flushSyncRef,
+            registerEventListener,
+            unregisterEventListener
         }), [
-        view,
+        cursorWrapper,
         registerEventListener,
         unregisterEventListener,
-        cursorWrapper
+        view
     ]);
     return {
         editor,

package/dist/esm/hooks/useEditorEffect.js

@@ -1,4 +1,5 @@
 /* Copyright (c) The New York Times Company */ import { useContext } from "react";
+import { ReactEditorView } from "../ReactEditorView.js";
 import { EditorContext } from "../contexts/EditorContext.js";
 import { useLayoutGroupEffect } from "./useLayoutGroupEffect.js";
 /**
@@ -24,8 +25,7 @@ import { useLayoutGroupEffect } from "./useLayoutGroupEffect.js";
     // every time it changes, because it will most likely
     // be defined inline and run on every re-render.
     useLayoutGroupEffect(()=>{
-        // @ts-expect-error We're making use of knowledge of internal attributes here
-        if (view?.docView && view.ready) {
+        if (view instanceof ReactEditorView) {
             flushSyncRef.current = false;
             const result = effect(view);
             flushSyncRef.current = true;

package/dist/esm/hooks/useEditorEventCallback.js

@@ -1,6 +1,13 @@
 /* Copyright (c) The New York Times Company */ import { useCallback, useContext, useRef } from "react";
+import { ReactEditorView } from "../ReactEditorView.js";
 import { EditorContext } from "../contexts/EditorContext.js";
 import { useEditorEffect } from "./useEditorEffect.js";
+function assertIsReactEditorView(view) {
+    if (view instanceof ReactEditorView) {
+        return;
+    }
+    throw new DOMException("ProseMirror document is not mounted", "InvalidStateError");
+}
 /**
  * Returns a stable function reference to be used as an
  * event handler callback.
@@ -25,11 +32,7 @@ import { useEditorEffect } from "./useEditorEffect.js";
         for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
             args[_key] = arguments[_key];
         }
-        // It's not actually possible for an event handler to run
-        // while view is null, since view is only ever set to
-        // null in a layout effect that then immediately triggers
-        // a re-render which sets view to a new EditorView
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        assertIsReactEditorView(view);
         return ref.current(view, ...args);
     }, [
         view

package/dist/esm/hooks/useIgnoreMutation.js

@@ -6,7 +6,7 @@ export function useIgnoreMutation(ignoreMutation) {
     const register = useContext(IgnoreMutationContext);
     const ignoreMutationMemo = useEditorEventCallback(ignoreMutation);
     useEditorEffect(()=>{
-        register(ignoreMutationMemo);
+        return register(ignoreMutationMemo);
     }, [
         register,
         ignoreMutationMemo

package/dist/esm/hooks/useNodeViewDescriptor.js

@@ -1,109 +1,152 @@
-import { useCallback, useContext, useRef, useState } from "react";
+import { useCallback, useContext, useMemo, useRef, useState } from "react";
+import { ReactEditorView } from "../ReactEditorView.js";
 import { ChildDescriptorsContext } from "../contexts/ChildDescriptorsContext.js";
 import { EditorContext } from "../contexts/EditorContext.js";
-import { CompositionViewDesc, NodeViewDesc, sortViewDescs } from "../viewdesc.js";
+import { CompositionViewDesc, ReactNodeViewDesc, sortViewDescs } from "../viewdesc.js";
 import { useClientLayoutEffect } from "./useClientLayoutEffect.js";
-export function useNodeViewDescriptor(node, getPos, domRef, nodeDomRef, innerDecorations, outerDecorations, viewDesc, contentDOMRef) {
+function findContentDOM(source, children) {
+    return source?.contentDOM ?? children[0]?.dom?.parentElement ?? null;
+}
+export function useNodeViewDescriptor(ref, constructor, props) {
     const { view } = useContext(EditorContext);
-    const [hasContentDOM, setHasContentDOM] = useState(true);
-    const nodeViewDescRef = useRef(viewDesc);
-    const stopEvent = useRef(()=>false);
-    const setStopEvent = useCallback((newStopEvent)=>{
-        stopEvent.current = newStopEvent;
-    }, []);
-    const ignoreMutation = useRef(()=>false);
-    const setIgnoreMutation = useCallback((newIgnoreMutation)=>{
-        ignoreMutation.current = newIgnoreMutation;
-    }, []);
-    const selectNode = useRef(()=>{
-        if (!nodeDomRef.current || !node) return;
-        if (nodeDomRef.current.nodeType == 1) nodeDomRef.current.classList.add("ProseMirror-selectednode");
-        if (contentDOMRef?.current || !node.type.spec.draggable) (domRef?.current ?? nodeDomRef.current).draggable = true;
-    });
-    const deselectNode = useRef(()=>{
-        if (!nodeDomRef.current || !node) return;
-        if (nodeDomRef.current.nodeType == 1) {
-            nodeDomRef.current.classList.remove("ProseMirror-selectednode");
-            if (contentDOMRef?.current || !node.type.spec.draggable) (domRef?.current ?? nodeDomRef.current).removeAttribute("draggable");
+    const { parentRef, siblingsRef } = useContext(ChildDescriptorsContext);
+    const [dom, setDOM] = useState(null);
+    const [nodeDOM, setNodeDOM] = useState(null);
+    const [contentDOM, setContentDOM] = useState(null);
+    const viewDescRef = useRef();
+    const childrenRef = useRef([]);
+    const create = useCallback((props)=>{
+        if (!(view instanceof ReactEditorView)) {
+            return;
         }
-    });
-    const setSelectNode = useCallback((newSelectNode, newDeselectNode)=>{
-        selectNode.current = newSelectNode;
-        deselectNode.current = newDeselectNode;
-    }, []);
-    const { siblingsRef, parentRef } = useContext(ChildDescriptorsContext);
-    const childDescriptors = useRef([]);
-    useClientLayoutEffect(()=>{
+        const dom = ref.current;
+        if (!dom) {
+            return;
+        }
+        const { node, getPos, decorations, innerDecorations } = props;
+        const nodeView = constructor(node, view, getPos, decorations, innerDecorations);
+        if (!nodeView) {
+            return;
+        }
+        const parent = parentRef.current;
+        const children = childrenRef.current;
+        const contentDOM = findContentDOM(nodeView, children);
+        const nodeDOM = nodeView.dom;
+        const viewDesc = new ReactNodeViewDesc(parent, children, getPos, node, decorations, innerDecorations, dom, contentDOM, nodeDOM, nodeView);
+        setDOM(dom);
+        setContentDOM(contentDOM);
+        setNodeDOM(nodeDOM);
+        return viewDesc;
+    }, [
+        ref,
+        parentRef,
+        constructor,
+        view
+    ]);
+    const update = useCallback((props)=>{
+        if (!(view instanceof ReactEditorView)) {
+            return false;
+        }
+        const viewDesc = viewDescRef.current;
+        if (!viewDesc) {
+            return false;
+        }
+        const dom = ref.current;
+        if (!dom || dom !== viewDesc.dom) {
+            return false;
+        }
+        const contentDOM = findContentDOM(viewDesc, viewDesc.children);
+        if (contentDOM !== viewDesc.contentDOM) {
+            return false;
+        }
+        if (!dom.contains(viewDesc.nodeDOM)) {
+            return false;
+        }
+        const { node, decorations, innerDecorations } = props;
+        return viewDesc.matchesNode(node, decorations, innerDecorations) || viewDesc.update(node, decorations, innerDecorations, view);
+    }, [
+        ref,
+        view
+    ]);
+    const destroy = useCallback(()=>{
+        const viewDesc = viewDescRef.current;
+        if (!viewDesc) {
+            return;
+        }
+        viewDesc.destroy();
         const siblings = siblingsRef.current;
-        return ()=>{
-            if (!nodeViewDescRef.current) return;
-            if (siblings.includes(nodeViewDescRef.current)) {
-                const index = siblings.indexOf(nodeViewDescRef.current);
-                siblings.splice(index, 1);
-            }
-        };
+        if (siblings.includes(viewDesc)) {
+            const index = siblings.indexOf(viewDesc);
+            siblings.splice(index, 1);
+        }
+        setDOM(null);
+        setContentDOM(null);
+        setNodeDOM(null);
     }, [
         siblingsRef
     ]);
-    // eslint-disable-next-line react-hooks/exhaustive-deps
     useClientLayoutEffect(()=>{
-        if (!node || !nodeDomRef.current) return;
-        const firstChildDesc = childDescriptors.current[0];
-        if (!nodeViewDescRef.current) {
-            nodeViewDescRef.current = new NodeViewDesc(parentRef.current, childDescriptors.current, getPos, node, outerDecorations, innerDecorations, domRef?.current ?? nodeDomRef.current, firstChildDesc?.dom.parentElement ?? null, nodeDomRef.current, (event)=>!!stopEvent.current(event), ()=>selectNode.current(), ()=>deselectNode.current(), (mutation)=>ignoreMutation.current(mutation));
-        } else {
-            nodeViewDescRef.current.parent = parentRef.current;
-            nodeViewDescRef.current.children = childDescriptors.current;
-            nodeViewDescRef.current.node = node;
-            nodeViewDescRef.current.getPos = getPos;
-            nodeViewDescRef.current.outerDeco = outerDecorations;
-            nodeViewDescRef.current.innerDeco = innerDecorations;
-            nodeViewDescRef.current.dom = domRef?.current ?? nodeDomRef.current;
-            nodeViewDescRef.current.dom.pmViewDesc = nodeViewDescRef.current;
-            nodeViewDescRef.current.contentDOM = // If there's already a contentDOM, we can just
-            // keep it; it won't have changed. This is especially
-            // important during compositions, where the
-            // firstChildDesc might not have a correct dom node set yet.
-            contentDOMRef?.current ?? nodeViewDescRef.current.contentDOM ?? firstChildDesc?.dom.parentElement ?? null;
-            nodeViewDescRef.current.nodeDOM = nodeDomRef.current;
+        if (!update(props)) {
+            destroy();
+            viewDescRef.current = create(props);
+        }
+        const viewDesc = viewDescRef.current;
+        if (!viewDesc) {
+            return;
         }
-        setHasContentDOM(nodeViewDescRef.current.contentDOM !== null);
-        if (!siblingsRef.current.includes(nodeViewDescRef.current)) {
-            siblingsRef.current.push(nodeViewDescRef.current);
+        if (view.dom === viewDesc.dom && view instanceof ReactEditorView) {
+            view.docView = viewDesc;
+        }
+        const parent = parentRef.current;
+        const siblings = siblingsRef.current;
+        const children = childrenRef.current;
+        viewDesc.parent = parent;
+        if (!siblings.includes(viewDesc)) {
+            siblings.push(viewDesc);
         }
-        siblingsRef.current.sort(sortViewDescs);
-        for (const childDesc of childDescriptors.current){
-            childDesc.parent = nodeViewDescRef.current;
+        siblings.sort(sortViewDescs);
+        for (const child of children){
+            child.parent = viewDesc;
             // Because TextNodeViews can't locate the DOM nodes
             // for compositions, we need to override them here
-            if (childDesc instanceof CompositionViewDesc) {
-                const compositionTopDOM = nodeViewDescRef.current.contentDOM?.firstChild;
+            if (child instanceof CompositionViewDesc) {
+                const compositionTopDOM = viewDesc?.contentDOM?.firstChild;
                 if (!compositionTopDOM) throw new Error(`Started a composition but couldn't find the text node it belongs to.`);
                 let textDOM = compositionTopDOM;
                 while(textDOM.firstChild){
                     textDOM = textDOM.firstChild;
                 }
                 if (!textDOM || !(textDOM instanceof Text)) throw new Error(`Started a composition but couldn't find the text node it belongs to.`);
-                childDesc.dom = compositionTopDOM;
-                childDesc.textDOM = textDOM;
-                childDesc.text = textDOM.data;
-                childDesc.textDOM.pmViewDesc = childDesc;
-                // @ts-expect-error Internal property -- input
-                view?.input.compositionNodes.push(childDesc);
+                child.dom = compositionTopDOM;
+                child.textDOM = textDOM;
+                child.text = textDOM.data;
+                child.textDOM.pmViewDesc = child;
+                // It should not be possible to be in a composition because one could
+                // not start between the renders that switch the view type.
+                view.input.compositionNodes.push(child);
             }
         }
+    });
+    useClientLayoutEffect(()=>{
         return ()=>{
-            if (nodeViewDescRef.current?.children[0] instanceof CompositionViewDesc && !view?.composing) {
-                nodeViewDescRef.current?.children[0].dom.parentNode?.removeChild(nodeViewDescRef.current?.children[0].dom);
-            }
+            destroy();
+            viewDescRef.current = undefined;
         };
-    });
+    }, [
+        destroy
+    ]);
+    const childContextValue = useMemo(()=>({
+            parentRef: viewDescRef,
+            siblingsRef: childrenRef
+        }), [
+        childrenRef,
+        viewDescRef
+    ]);
     return {
-        hasContentDOM,
-        childDescriptors,
-        nodeViewDescRef,
-        setStopEvent,
-        setSelectNode,
-        setIgnoreMutation
+        childContextValue,
+        dom,
+        contentDOM,
+        nodeDOM,
+        ref
     };
 }

package/dist/esm/hooks/useReactKeys.js

@@ -3,5 +3,5 @@ import { EditorContext } from "../contexts/EditorContext.js";
 import { reactKeysPluginKey } from "../plugins/reactKeys.js";
 export function useReactKeys() {
     const { view } = useContext(EditorContext);
-    return view && reactKeysPluginKey.getState(view.state);
+    return reactKeysPluginKey.getState(view.state);
 }

package/dist/esm/hooks/useSelectNode.js

@@ -2,17 +2,19 @@ import { useContext } from "react";
 import { SelectNodeContext } from "../contexts/SelectNodeContext.js";
 import { useEditorEffect } from "./useEditorEffect.js";
 import { useEditorEventCallback } from "./useEditorEventCallback.js";
-export function useSelectNode(selectNode, deselectNode) {
+function noop() {
+// empty
+}
+export function useSelectNode(selectNode) {
+    let deselectNode = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : noop;
     const register = useContext(SelectNodeContext);
     const selectNodeMemo = useEditorEventCallback(selectNode);
-    const deselectNodeMemo = useEditorEventCallback(deselectNode ?? (()=>{
-    // empty
-    }));
+    const deselectNodeMemo = useEditorEventCallback(deselectNode);
     return useEditorEffect(()=>{
-        register(selectNodeMemo, deselectNodeMemo);
+        return register(selectNodeMemo, deselectNodeMemo);
     }, [
-        deselectNodeMemo,
         register,
-        selectNodeMemo
+        selectNodeMemo,
+        deselectNodeMemo
     ]);
 }

package/dist/esm/hooks/useStopEvent.js

@@ -6,7 +6,7 @@ export function useStopEvent(stopEvent) {
     const register = useContext(StopEventContext);
     const stopEventMemo = useEditorEventCallback(stopEvent);
     useEditorEffect(()=>{
-        register(stopEventMemo);
+        return register(stopEventMemo);
     }, [
         register,
         stopEventMemo

package/dist/esm/plugins/beforeInputPlugin.js

@@ -86,6 +86,14 @@ export function beforeInputPlugin(setCursorWrapper) {
                         case "insertParagraph":
                         case "insertLineBreak":
                             {
+                                // ProseMirror-view has a hack that runs the Enter event handlers
+                                // on iOS, to avoid a bug in Safari with calling event.preventDefault() on
+                                // Enter events.
+                                //
+                                // We want to prevent that hack, because we run the Enter event handlers
+                                // here, where there is no such bug. So we set this flag, which prosemirror-view
+                                // uses to check whether it should run the deferred event handlers.
+                                view.input.lastIOSEnter = 0;
                                 // Fire a synthetic keydown event to trigger ProseMirror's keymap
                                 const keyEvent = new KeyboardEvent("keydown", {
                                     bubbles: true,
@@ -119,8 +127,12 @@ export function beforeInputPlugin(setCursorWrapper) {
                                 break;
                             }
                         case "deleteWordBackward":
+                        case "deleteHardLineBackward":
+                        case "deleteSoftLineBackward":
                         case "deleteContentBackward":
                         case "deleteWordForward":
+                        case "deleteHardLineForward":
+                        case "deleteSoftLineForward":
                         case "deleteContentForward":
                         case "deleteContent":
                             {

package/dist/esm/testing/editorViewTestHelpers.js

@@ -62,8 +62,6 @@ export function tempEditor(param) {
         }, /*#__PURE__*/ React.createElement(Test, null), /*#__PURE__*/ React.createElement(ProseMirrorDoc, null)));
         return view;
     }
-    // We need two renders for the hasContentDOM state to settle
-    rerenderEditor();
     return {
         view: view,
         rerender: rerenderEditor,