@handlewithcare/react-prosemirror 2.4.12 → 2.5.1

package/dist/cjs/hooks/useEditorEventCallback.js

@@ -9,8 +9,15 @@ Object.defineProperty(exports, "useEditorEventCallback", {
     }
 });
 const _react = require("react");
+const _ReactEditorView = require("../ReactEditorView.js");
 const _EditorContext = require("../contexts/EditorContext.js");
 const _useEditorEffect = require("./useEditorEffect.js");
+function assertIsReactEditorView(view) {
+    if (view instanceof _ReactEditorView.ReactEditorView) {
+        return;
+    }
+    throw new DOMException("ProseMirror document is not mounted", "InvalidStateError");
+}
 function useEditorEventCallback(callback) {
     const ref = (0, _react.useRef)(callback);
     const { view } = (0, _react.useContext)(_EditorContext.EditorContext);
@@ -23,11 +30,7 @@ function useEditorEventCallback(callback) {
         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/cjs/hooks/useIgnoreMutation.js

@@ -16,7 +16,7 @@ function useIgnoreMutation(ignoreMutation) {
     const register = (0, _react.useContext)(_IgnoreMutationContext.IgnoreMutationContext);
     const ignoreMutationMemo = (0, _useEditorEventCallback.useEditorEventCallback)(ignoreMutation);
     (0, _useEditorEffect.useEditorEffect)(()=>{
-        register(ignoreMutationMemo);
+        return register(ignoreMutationMemo);
     }, [
         register,
         ignoreMutationMemo

package/dist/cjs/hooks/useNodeViewDescriptor.js

@@ -9,111 +9,154 @@ Object.defineProperty(exports, "useNodeViewDescriptor", {
     }
 });
 const _react = require("react");
+const _ReactEditorView = require("../ReactEditorView.js");
 const _ChildDescriptorsContext = require("../contexts/ChildDescriptorsContext.js");
 const _EditorContext = require("../contexts/EditorContext.js");
 const _viewdesc = require("../viewdesc.js");
 const _useClientLayoutEffect = require("./useClientLayoutEffect.js");
-function useNodeViewDescriptor(node, getPos, domRef, nodeDomRef, innerDecorations, outerDecorations, viewDesc, contentDOMRef) {
+function findContentDOM(source, children) {
+    return source?.contentDOM ?? children[0]?.dom?.parentElement ?? null;
+}
+function useNodeViewDescriptor(ref, constructor, props) {
     const { view } = (0, _react.useContext)(_EditorContext.EditorContext);
-    const [hasContentDOM, setHasContentDOM] = (0, _react.useState)(true);
-    const nodeViewDescRef = (0, _react.useRef)(viewDesc);
-    const stopEvent = (0, _react.useRef)(()=>false);
-    const setStopEvent = (0, _react.useCallback)((newStopEvent)=>{
-        stopEvent.current = newStopEvent;
-    }, []);
-    const ignoreMutation = (0, _react.useRef)(()=>false);
-    const setIgnoreMutation = (0, _react.useCallback)((newIgnoreMutation)=>{
-        ignoreMutation.current = newIgnoreMutation;
-    }, []);
-    const selectNode = (0, _react.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 = (0, _react.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 } = (0, _react.useContext)(_ChildDescriptorsContext.ChildDescriptorsContext);
+    const [dom, setDOM] = (0, _react.useState)(null);
+    const [nodeDOM, setNodeDOM] = (0, _react.useState)(null);
+    const [contentDOM, setContentDOM] = (0, _react.useState)(null);
+    const viewDescRef = (0, _react.useRef)();
+    const childrenRef = (0, _react.useRef)([]);
+    const create = (0, _react.useCallback)((props)=>{
+        if (!(view instanceof _ReactEditorView.ReactEditorView)) {
+            return;
         }
-    });
-    const setSelectNode = (0, _react.useCallback)((newSelectNode, newDeselectNode)=>{
-        selectNode.current = newSelectNode;
-        deselectNode.current = newDeselectNode;
-    }, []);
-    const { siblingsRef, parentRef } = (0, _react.useContext)(_ChildDescriptorsContext.ChildDescriptorsContext);
-    const childDescriptors = (0, _react.useRef)([]);
-    (0, _useClientLayoutEffect.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 _viewdesc.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 = (0, _react.useCallback)((props)=>{
+        if (!(view instanceof _ReactEditorView.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 = (0, _react.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
     (0, _useClientLayoutEffect.useClientLayoutEffect)(()=>{
-        if (!node || !nodeDomRef.current) return;
-        const firstChildDesc = childDescriptors.current[0];
-        if (!nodeViewDescRef.current) {
-            nodeViewDescRef.current = new _viewdesc.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.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(_viewdesc.sortViewDescs);
-        for (const childDesc of childDescriptors.current){
-            childDesc.parent = nodeViewDescRef.current;
+        siblings.sort(_viewdesc.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 _viewdesc.CompositionViewDesc) {
-                const compositionTopDOM = nodeViewDescRef.current.contentDOM?.firstChild;
+            if (child instanceof _viewdesc.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);
             }
         }
+    });
+    (0, _useClientLayoutEffect.useClientLayoutEffect)(()=>{
         return ()=>{
-            if (nodeViewDescRef.current?.children[0] instanceof _viewdesc.CompositionViewDesc && !view?.composing) {
-                nodeViewDescRef.current?.children[0].dom.parentNode?.removeChild(nodeViewDescRef.current?.children[0].dom);
-            }
+            destroy();
+            viewDescRef.current = undefined;
         };
-    });
+    }, [
+        destroy
+    ]);
+    const childContextValue = (0, _react.useMemo)(()=>({
+            parentRef: viewDescRef,
+            siblingsRef: childrenRef
+        }), [
+        childrenRef,
+        viewDescRef
+    ]);
     return {
-        hasContentDOM,
-        childDescriptors,
-        nodeViewDescRef,
-        setStopEvent,
-        setSelectNode,
-        setIgnoreMutation
+        childContextValue,
+        dom,
+        contentDOM,
+        nodeDOM,
+        ref
     };
 }

package/dist/cjs/hooks/useReactKeys.js

@@ -13,5 +13,5 @@ const _EditorContext = require("../contexts/EditorContext.js");
 const _reactKeys = require("../plugins/reactKeys.js");
 function useReactKeys() {
     const { view } = (0, _react.useContext)(_EditorContext.EditorContext);
-    return view && _reactKeys.reactKeysPluginKey.getState(view.state);
+    return _reactKeys.reactKeysPluginKey.getState(view.state);
 }

package/dist/cjs/hooks/useSelectNode.js

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

package/dist/cjs/hooks/useStopEvent.js

@@ -16,7 +16,7 @@ function useStopEvent(stopEvent) {
     const register = (0, _react.useContext)(_StopEventContext.StopEventContext);
     const stopEventMemo = (0, _useEditorEventCallback.useEditorEventCallback)(stopEvent);
     (0, _useEditorEffect.useEditorEffect)(()=>{
-        register(stopEventMemo);
+        return register(stopEventMemo);
     }, [
         register,
         stopEventMemo

package/dist/cjs/plugins/beforeInputPlugin.js

@@ -96,6 +96,14 @@ 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,
@@ -129,8 +137,12 @@ function beforeInputPlugin(setCursorWrapper) {
                                 break;
                             }
                         case "deleteWordBackward":
+                        case "deleteHardLineBackward":
+                        case "deleteSoftLineBackward":
                         case "deleteContentBackward":
                         case "deleteWordForward":
+                        case "deleteHardLineForward":
+                        case "deleteSoftLineForward":
                         case "deleteContentForward":
                         case "deleteContent":
                             {

package/dist/cjs/testing/editorViewTestHelpers.js

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

package/dist/cjs/viewdesc.js

@@ -18,6 +18,9 @@ _export(exports, {
     NodeViewDesc: function() {
         return NodeViewDesc;
     },
+    ReactNodeViewDesc: function() {
+        return ReactNodeViewDesc;
+    },
     TextViewDesc: function() {
         return TextViewDesc;
     },
@@ -36,7 +39,7 @@ _export(exports, {
 });
 const _prosemirrormodel = require("prosemirror-model");
 const _browser = require("./browser.js");
-const _selectionToDOM = require("./selection/selectionToDOM.js");
+const _dom = require("./dom.js");
 function sortViewDescs(a, b) {
     if (a instanceof TrailingHackViewDesc) return 1;
     if (b instanceof TrailingHackViewDesc) return -1;
@@ -104,7 +107,9 @@ let ViewDesc = class ViewDesc {
         return 0;
     }
     destroy() {
-    // pass
+        this.parent = undefined;
+        if (this.dom.pmViewDesc == this) this.dom.pmViewDesc = undefined;
+        for(let i = 0; i < this.children.length; i++)this.children[i].destroy();
     }
     posBeforeChild(child) {
         for(let i = 0, pos = this.posAtStart;; i++){
@@ -157,7 +162,7 @@ let ViewDesc = class ViewDesc {
         // start or at the end of this view desc.
         let atEnd;
         if (dom == this.dom && this.contentDOM) {
-            atEnd = offset > (0, _selectionToDOM.domIndex)(this.contentDOM);
+            atEnd = offset > (0, _dom.domIndex)(this.contentDOM);
         } else if (this.contentDOM && this.contentDOM != this.dom && this.dom.contains(this.contentDOM)) {
             atEnd = dom.compareDocumentPosition(this.contentDOM) & 2;
         } else if (this.dom.firstChild) {
@@ -258,7 +263,7 @@ let ViewDesc = class ViewDesc {
             if (prev && side && enter && !prev.border && !prev.domAtom) return prev.domFromPos(prev.size, side);
             return {
                 node: this.contentDOM,
-                offset: prev ? (0, _selectionToDOM.domIndex)(prev.dom) + 1 : 0
+                offset: prev ? (0, _dom.domIndex)(prev.dom) + 1 : 0
             };
         } else {
             let next, enter = true;
@@ -269,7 +274,7 @@ let ViewDesc = class ViewDesc {
             if (next && enter && !next.border && !next.domAtom) return next.domFromPos(0, side);
             return {
                 node: this.contentDOM,
-                offset: next ? (0, _selectionToDOM.domIndex)(next.dom) : this.contentDOM.childNodes.length
+                offset: next ? (0, _dom.domIndex)(next.dom) : this.contentDOM.childNodes.length
             };
         }
     }
@@ -295,7 +300,7 @@ let ViewDesc = class ViewDesc {
                 for(let j = i; j > 0; j--){
                     const prev = this.children[j - 1];
                     if (prev.size && prev.dom.parentNode == this.contentDOM && !prev.emptyChildAt(1)) {
-                        fromOffset = (0, _selectionToDOM.domIndex)(prev.dom) + 1;
+                        fromOffset = (0, _dom.domIndex)(prev.dom) + 1;
                         break;
                     }
                     from -= prev.size;
@@ -307,7 +312,7 @@ let ViewDesc = class ViewDesc {
                 for(let j = i + 1; j < this.children.length; j++){
                     const next = this.children[j];
                     if (next.size && next.dom.parentNode == this.contentDOM && !next.emptyChildAt(-1)) {
-                        toOffset = (0, _selectionToDOM.domIndex)(next.dom);
+                        toOffset = (0, _dom.domIndex)(next.dom);
                         break;
                     }
                     to += next.size;
@@ -354,7 +359,6 @@ let ViewDesc = class ViewDesc {
         let anchorDOM = this.domFromPos(anchor, anchor ? -1 : 1);
         let headDOM = head == anchor ? anchorDOM : this.domFromPos(head, head ? -1 : 1);
         const domSel = view.root.getSelection();
-        // @ts-expect-error - Internal method domSelectionRange
         const selRange = view.domSelectionRange();
         let brKludge = false;
         // On Firefox, using Selection.collapse to put the cursor after a
@@ -371,7 +375,7 @@ let ViewDesc = class ViewDesc {
                         if (after = scan.nextSibling) {
                             if (after.nodeName == "BR") anchorDOM = headDOM = {
                                 node: after.parentNode,
-                                offset: (0, _selectionToDOM.domIndex)(after) + 1
+                                offset: (0, _dom.domIndex)(after) + 1
                             };
                             break;
                         }
@@ -391,7 +395,7 @@ let ViewDesc = class ViewDesc {
             const after = selRange.focusNode.childNodes[selRange.focusOffset];
             if (after && after.contentEditable == "false") force = true;
         }
-        if (!(force || brKludge && _browser.browser.safari) && (0, _selectionToDOM.isEquivalentPosition)(anchorDOM.node, anchorDOM.offset, selRange.anchorNode, selRange.anchorOffset) && (0, _selectionToDOM.isEquivalentPosition)(headDOM.node, headDOM.offset, selRange.focusNode, selRange.focusOffset)) return;
+        if (!(force || brKludge && _browser.browser.safari) && (0, _dom.isEquivalentPosition)(anchorDOM.node, anchorDOM.offset, selRange.anchorNode, selRange.anchorOffset) && (0, _dom.isEquivalentPosition)(headDOM.node, headDOM.offset, selRange.focusNode, selRange.focusOffset)) return;
         // Selection.extend can be used to create an 'inverted' selection
         // (one where the focus is before the anchor), but not all
         // browsers support it yet.
@@ -554,15 +558,8 @@ let NodeViewDesc = class NodeViewDesc extends ViewDesc {
     outerDeco;
     innerDeco;
     nodeDOM;
-    stopEvent;
-    selectNode;
-    deselectNode;
-    ignoreMutation;
-    constructor(parent, children, getPos, node, outerDeco, innerDeco, dom, contentDOM, nodeDOM, stopEvent, selectNode, deselectNode, ignoreMutation){
-        super(parent, children, getPos, dom, contentDOM), this.node = node, this.outerDeco = outerDeco, this.innerDeco = innerDeco, this.nodeDOM = nodeDOM, this.stopEvent = stopEvent, this.selectNode = selectNode, this.deselectNode = deselectNode, this.ignoreMutation = ignoreMutation;
-    }
-    updateOuterDeco() {
-    // pass
+    constructor(parent, children, getPos, node, outerDeco, innerDeco, dom, contentDOM, nodeDOM){
+        super(parent, children, getPos, dom, contentDOM), this.node = node, this.outerDeco = outerDeco, this.innerDeco = innerDeco, this.nodeDOM = nodeDOM;
     }
     parseRule() {
         // Experimental kludge to allow opt-in re-parsing of nodes
@@ -606,22 +603,46 @@ let NodeViewDesc = class NodeViewDesc extends ViewDesc {
     get border() {
         return this.node.isLeaf ? 0 : 1;
     }
+    updateChildren(_view, _pos) {
+    // Omitted to avoid reproducing lots of unused code.
+    // Overidden elsewhere in case this is ever vendored.
+    }
     // If this desc must be updated to match the given node decoration,
     // do so and return true.
-    update(_node, _outerDeco, _innerDeco, _view) {
+    update(node, outerDeco, innerDeco, view) {
+        if (this.dirty == NODE_DIRTY || !node.sameMarkup(this.node)) return false;
+        this.updateInner(node, outerDeco, innerDeco, view);
         return true;
     }
+    updateInner(node, outerDeco, innerDeco, view) {
+        this.updateOuterDeco(outerDeco);
+        this.node = node;
+        this.innerDeco = innerDeco;
+        if (this.contentDOM) this.updateChildren(view, this.posAtStart);
+        this.dirty = NOT_DIRTY;
+    }
+    updateOuterDeco(outerDeco) {
+        this.outerDeco = outerDeco;
+    }
+    // Mark this node as being the selected node.
+    selectNode() {
+        if (this.nodeDOM.nodeType == 1) this.nodeDOM.classList.add("ProseMirror-selectednode");
+        if (this.contentDOM || !this.node.type.spec.draggable) this.dom.draggable = true;
+    }
+    // Remove selected node marking from this node.
+    deselectNode() {
+        if (this.nodeDOM.nodeType == 1) {
+            this.nodeDOM.classList.remove("ProseMirror-selectednode");
+            if (this.contentDOM || !this.node.type.spec.draggable) this.dom.removeAttribute("draggable");
+        }
+    }
     get domAtom() {
         return this.node.isAtom;
     }
 };
 let TextViewDesc = class TextViewDesc extends NodeViewDesc {
     constructor(parent, children, getPos, node, outerDeco, innerDeco, dom, nodeDOM){
-        super(parent, children, getPos, node, outerDeco, innerDeco, dom, null, nodeDOM, ()=>false, ()=>{
-        /* Text nodes can't have node selections */ }, ()=>{
-        /* Text nodes can't have node selections */ }, (mutation)=>{
-            return mutation.type != "characterData" && mutation.type != "selection";
-        });
+        super(parent, children, getPos, node, outerDeco, innerDeco, dom, null, nodeDOM);
     }
     parseRule() {
         let skip = this.nodeDOM.parentNode;
@@ -631,6 +652,7 @@ let TextViewDesc = class TextViewDesc extends NodeViewDesc {
         };
     }
     update(_node, _outerDeco, _innerDeco, _view) {
+        this.dirty = NOT_DIRTY;
         return true;
     }
     inParent() {
@@ -672,6 +694,63 @@ let TrailingHackViewDesc = class TrailingHackViewDesc extends ViewDesc {
         return this.dom.nodeName == "IMG";
     }
 };
+// A separate subclass is used for customized node views, so that the
+// extra checks only have to be made for nodes that are actually
+// customized.
+let CustomNodeViewDesc = class CustomNodeViewDesc extends NodeViewDesc {
+    spec;
+    constructor(parent, children, getPos, node, outerDeco, innerDeco, dom, contentDOM, nodeDOM, spec){
+        super(parent, children, getPos, node, outerDeco, innerDeco, dom, contentDOM, nodeDOM), this.spec = spec;
+    }
+    // A custom `update` method gets to decide whether the update goes
+    // through. If it does, and there's a `contentDOM` node, our logic
+    // updates the children.
+    update(node, outerDeco, innerDeco, view) {
+        if (this.dirty == NODE_DIRTY) return false;
+        if (this.spec.update && (this.node.type == node.type || this.spec.multiType)) {
+            const result = this.spec.update(node, outerDeco, innerDeco);
+            if (result) this.updateInner(node, outerDeco, innerDeco, view);
+            return result;
+        } else if (!this.contentDOM && !node.isLeaf) {
+            return false;
+        } else {
+            return super.update(node, outerDeco, innerDeco, view);
+        }
+    }
+    selectNode() {
+        this.spec.selectNode ? this.spec.selectNode() : super.selectNode();
+    }
+    deselectNode() {
+        this.spec.deselectNode ? this.spec.deselectNode() : super.deselectNode();
+    }
+    setSelection(anchor, head, view, force) {
+        this.spec.setSelection ? this.spec.setSelection(anchor, head, view.root) : super.setSelection(anchor, head, view, force);
+    }
+    destroy() {
+        if (this.spec.destroy) this.spec.destroy();
+        super.destroy();
+    }
+    stopEvent(event) {
+        return this.spec.stopEvent ? this.spec.stopEvent(event) : false;
+    }
+    ignoreMutation(mutation) {
+        return this.spec.ignoreMutation ? this.spec.ignoreMutation(mutation) : super.ignoreMutation(mutation);
+    }
+};
+let ReactNodeViewDesc = class ReactNodeViewDesc extends CustomNodeViewDesc {
+    updateChildren(_view, _pos) {
+    // React has already updated the children.
+    }
+    updateOuterDeco(outerDeco) {
+        // React has already updated the decorations.
+        this.outerDeco = outerDeco;
+    }
+    destroy() {
+        // React has already destroyed the children (if needed).
+        this.children = [];
+        super.destroy();
+    }
+};
 function sameOuterDeco(a, b) {
     if (a.length != b.length) return false;
     // @ts-expect-error ...

package/dist/esm/AbstractEditorView.js

@@ -0,0 +1 @@
+export { };