@handlewithcare/react-prosemirror 3.1.0-tiptap.35 → 3.1.0-tiptap.36

package/dist/esm/components/CustomNodeView.js

@@ -0,0 +1,81 @@
+import { DOMSerializer } from "prosemirror-model";
+import React, { cloneElement, memo, useMemo, useRef } from "react";
+import { createPortal } from "react-dom";
+import { ChildDescriptorsContext } from "../contexts/ChildDescriptorsContext.js";
+import { useNodeViewDescriptor } from "../hooks/useNodeViewDescriptor.js";
+import { ChildNodeViews, wrapInDeco } from "./ChildNodeViews.js";
+export const CustomNodeView = /*#__PURE__*/ memo(function CustomNodeView(param) {
+    let { constructor, node, getPos, innerDeco, outerDeco } = param;
+    const ref = useRef(null);
+    const innerRef = useRef(null);
+    const nodeProps = useMemo(()=>({
+            node,
+            getPos,
+            decorations: outerDeco,
+            innerDecorations: innerDeco
+        }), [
+        node,
+        getPos,
+        outerDeco,
+        innerDeco
+    ]);
+    const createNodeView = function() {
+        for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+            args[_key] = arguments[_key];
+        }
+        const nodeView = constructor(...args);
+        if (!nodeView || !nodeView.dom) {
+            const spec = node.type.spec.toDOM?.(node);
+            if (!spec) {
+                throw new Error(`Node spec for ${node.type.name} is missing toDOM`);
+            }
+            return DOMSerializer.renderSpec(document, spec, null);
+        }
+        return nodeView;
+    };
+    const { childContextValue, contentDOM } = useNodeViewDescriptor(ref, function() {
+        for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+            args[_key] = arguments[_key];
+        }
+        const nodeView = createNodeView(...args);
+        const contentDOM = nodeView.contentDOM;
+        const nodeDOM = nodeView.dom;
+        const wrapperDOM = innerRef.current ?? ref.current;
+        wrapperDOM.appendChild(nodeDOM);
+        if (!contentDOM && nodeDOM instanceof HTMLElement && nodeDOM.tagName !== "BR") {
+            if (!nodeDOM.hasAttribute("contenteditable")) {
+                nodeDOM.contentEditable = "false";
+            }
+            if (node.type.spec.draggable) {
+                nodeDOM.draggable = true;
+            }
+        }
+        return {
+            ...nodeView,
+            destroy () {
+                if (nodeView.destroy) {
+                    nodeView.destroy();
+                }
+                wrapperDOM.removeChild(nodeDOM);
+            },
+            selectNode: nodeView.selectNode?.bind(nodeView),
+            deselectNode: nodeView.deselectNode?.bind(nodeView),
+            stopEvent: nodeView.stopEvent?.bind(nodeView),
+            ignoreMutation: nodeView.ignoreMutation?.bind(nodeView)
+        };
+    }, nodeProps);
+    const Component = node.isInline ? "span" : "div";
+    const props = {
+        ref: innerRef
+    };
+    const children = !node.isLeaf && contentDOM ? /*#__PURE__*/ createPortal(/*#__PURE__*/ React.createElement(ChildDescriptorsContext.Provider, {
+        value: childContextValue
+    }, /*#__PURE__*/ React.createElement(ChildNodeViews, {
+        getPos: getPos,
+        node: node,
+        innerDecorations: innerDeco
+    })), contentDOM) : null;
+    return /*#__PURE__*/ cloneElement(outerDeco.reduce(wrapInDeco, /*#__PURE__*/ React.createElement(Component, props, children)), {
+        ref
+    });
+});

package/dist/esm/components/DefaultNodeView.js

@@ -0,0 +1,16 @@
+import React, { forwardRef, useMemo } from "react";
+import { OutputSpec } from "./OutputSpec.js";
+export const DefaultNodeView = /*#__PURE__*/ forwardRef(function DefaultNodeView(param, ref) {
+    let { nodeProps: { node }, children, ...props } = param;
+    const spec = useMemo(()=>node.type.spec.toDOM?.(node), [
+        node
+    ]);
+    if (!spec) {
+        throw new Error(`Node spec for ${node.type.name} is missing toDOM`);
+    }
+    return /*#__PURE__*/ React.createElement(OutputSpec, {
+        ...props,
+        outputSpec: spec,
+        ref: ref
+    }, children);
+});

package/dist/esm/components/DocNodeView.js

@@ -0,0 +1,45 @@
+import React, { cloneElement, createElement, forwardRef, memo, useImperativeHandle, useMemo, useRef } from "react";
+import { ChildDescriptorsContext } from "../contexts/ChildDescriptorsContext.js";
+import { useNodeViewDescriptor } from "../hooks/useNodeViewDescriptor.js";
+import { ChildNodeViews, wrapInDeco } from "./ChildNodeViews.js";
+export const DocNodeView = /*#__PURE__*/ memo(/*#__PURE__*/ forwardRef(function DocNodeView(param, ref) {
+    let { as, node, getPos, decorations, innerDecorations, setMount, ...elementProps } = param;
+    const innerRef = useRef(null);
+    useImperativeHandle(ref, ()=>innerRef.current);
+    useImperativeHandle(setMount, ()=>innerRef.current);
+    const nodeProps = useMemo(()=>({
+            node,
+            getPos,
+            decorations,
+            innerDecorations
+        }), [
+        node,
+        getPos,
+        decorations,
+        innerDecorations
+    ]);
+    const { childContextValue } = useNodeViewDescriptor(innerRef, ()=>{
+        const dom = innerRef.current;
+        return {
+            dom,
+            contentDOM: dom,
+            update () {
+                return true;
+            }
+        };
+    }, nodeProps);
+    const children = /*#__PURE__*/ React.createElement(ChildDescriptorsContext.Provider, {
+        value: childContextValue
+    }, /*#__PURE__*/ React.createElement(ChildNodeViews, {
+        getPos: getPos,
+        node: node,
+        innerDecorations: innerDecorations
+    }));
+    const props = {
+        ...elementProps,
+        suppressContentEditableWarning: true,
+        ref: innerRef
+    };
+    const element = as ? /*#__PURE__*/ cloneElement(as, props, children) : /*#__PURE__*/ createElement("div", props, children);
+    return nodeProps.decorations.reduce(wrapInDeco, element);
+}));

package/dist/esm/components/MarkView.js

@@ -0,0 +1,68 @@
+import React, { forwardRef, memo, useContext, useImperativeHandle, useMemo, useRef } from "react";
+import { ChildDescriptorsContext } from "../contexts/ChildDescriptorsContext.js";
+import { useClientLayoutEffect } from "../hooks/useClientLayoutEffect.js";
+import { MarkViewDesc, sortViewDescs } from "../viewdesc.js";
+import { OutputSpec } from "./OutputSpec.js";
+export const MarkView = /*#__PURE__*/ memo(/*#__PURE__*/ forwardRef(function MarkView(param, ref) {
+    let { mark, getPos, children } = param;
+    const { siblingsRef, parentRef } = useContext(ChildDescriptorsContext);
+    const viewDescRef = useRef(undefined);
+    const childDescriptors = useRef([]);
+    const domRef = useRef(null);
+    useImperativeHandle(ref, ()=>{
+        return domRef.current;
+    }, []);
+    const outputSpec = useMemo(()=>mark.type.spec.toDOM?.(mark, true), [
+        mark
+    ]);
+    if (!outputSpec) throw new Error(`Mark spec for ${mark.type.name} is missing toDOM`);
+    useClientLayoutEffect(()=>{
+        const siblings = siblingsRef.current;
+        return ()=>{
+            if (!viewDescRef.current) return;
+            if (siblings.includes(viewDescRef.current)) {
+                const index = siblings.indexOf(viewDescRef.current);
+                siblings.splice(index, 1);
+            }
+        };
+    }, [
+        siblingsRef
+    ]);
+    useClientLayoutEffect(()=>{
+        if (!domRef.current) return;
+        const firstChildDesc = childDescriptors.current[0];
+        if (!viewDescRef.current) {
+            viewDescRef.current = new MarkViewDesc(parentRef.current, childDescriptors.current, getPos, mark, domRef.current, firstChildDesc?.dom.parentElement ?? domRef.current, {
+                dom: domRef.current,
+                contentDOM: firstChildDesc?.dom.parentElement ?? domRef.current
+            });
+        } else {
+            viewDescRef.current.parent = parentRef.current;
+            viewDescRef.current.spec.dom = viewDescRef.current.dom = domRef.current;
+            viewDescRef.current.children = childDescriptors.current;
+            viewDescRef.current.spec.contentDOM = viewDescRef.current.contentDOM = firstChildDesc?.dom.parentElement ?? domRef.current;
+            viewDescRef.current.mark = mark;
+        }
+        if (!siblingsRef.current.includes(viewDescRef.current)) {
+            siblingsRef.current.push(viewDescRef.current);
+        }
+        siblingsRef.current.sort(sortViewDescs);
+        for (const childDesc of childDescriptors.current){
+            childDesc.parent = viewDescRef.current;
+        }
+    });
+    const childContextValue = useMemo(()=>({
+            parentRef: viewDescRef,
+            siblingsRef: childDescriptors
+        }), [
+        childDescriptors,
+        viewDescRef
+    ]);
+    return /*#__PURE__*/ React.createElement(OutputSpec, {
+        ref: domRef,
+        outputSpec: outputSpec,
+        isMark: true
+    }, /*#__PURE__*/ React.createElement(ChildDescriptorsContext.Provider, {
+        value: childContextValue
+    }, children));
+}));

package/dist/esm/components/NodeView.js

@@ -0,0 +1,35 @@
+import React, { memo, useContext, useMemo } from "react";
+import { NodeViewContext } from "../contexts/NodeViewContext.js";
+import { CustomNodeView } from "./CustomNodeView.js";
+import { DefaultNodeView } from "./DefaultNodeView.js";
+import { ReactNodeView } from "./ReactNodeView.js";
+export const NodeView = /*#__PURE__*/ memo(function NodeView(props) {
+    const { components, constructors } = useContext(NodeViewContext);
+    const component = components[props.node.type.name] ?? DefaultNodeView;
+    const constructor = constructors[props.node.type.name];
+    // Construct a wrapper component so that the node view remounts when either
+    // its component or constructor changes. A React node view would remount if
+    // its underlying component changed without this wrapper, but a custom node
+    // view otherwise uses the same React components for all custom node views.
+    const Component = useMemo(()=>{
+        if (constructor) {
+            return function NodeView(props) {
+                return /*#__PURE__*/ React.createElement(CustomNodeView, {
+                    constructor: constructor,
+                    ...props
+                });
+            };
+        } else {
+            return function NodeView(props) {
+                return /*#__PURE__*/ React.createElement(ReactNodeView, {
+                    component: component,
+                    ...props
+                });
+            };
+        }
+    }, [
+        constructor,
+        component
+    ]);
+    return /*#__PURE__*/ React.createElement(Component, props);
+});

package/dist/esm/components/NodeViewComponentProps.js

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

package/dist/esm/components/ReactNodeView.js

@@ -0,0 +1,123 @@
+import React, { cloneElement, memo, useCallback, useMemo, useRef, useState } from "react";
+import { ChildDescriptorsContext } from "../contexts/ChildDescriptorsContext.js";
+import { IgnoreMutationContext } from "../contexts/IgnoreMutationContext.js";
+import { SelectNodeContext } from "../contexts/SelectNodeContext.js";
+import { StopEventContext } from "../contexts/StopEventContext.js";
+import { useNodeViewDescriptor } from "../hooks/useNodeViewDescriptor.js";
+import { ChildNodeViews, wrapInDeco } from "./ChildNodeViews.js";
+export const ReactNodeView = /*#__PURE__*/ memo(function ReactNodeView(param) {
+    let { component: Component, outerDeco, getPos, node, innerDeco } = param;
+    const [hasCustomSelectNode, setHasCustomSelectNode] = useState(false);
+    const [selected, setSelected] = useState(false);
+    const ref = useRef(null);
+    const innerRef = useRef(null);
+    const selectNodeRef = useRef(null);
+    const deselectNodeRef = useRef(null);
+    const stopEventRef = useRef(null);
+    const ignoreMutationRef = useRef(null);
+    const setSelectNode = useCallback((selectHandler, deselectHandler)=>{
+        selectNodeRef.current = selectHandler;
+        deselectNodeRef.current = deselectHandler;
+        setHasCustomSelectNode(true);
+        return ()=>{
+            selectNodeRef.current = null;
+            deselectNodeRef.current = null;
+            setHasCustomSelectNode(false);
+        };
+    }, []);
+    const setStopEvent = useCallback((handler)=>{
+        stopEventRef.current = handler;
+        return ()=>{
+            stopEventRef.current = null;
+        };
+    }, []);
+    const setIgnoreMutation = useCallback((handler)=>{
+        ignoreMutationRef.current = handler;
+        return ()=>{
+            ignoreMutationRef.current = null;
+            return ()=>{
+                ignoreMutationRef.current = null;
+            };
+        };
+    }, []);
+    const nodeProps = useMemo(()=>({
+            node: node,
+            getPos: getPos,
+            decorations: outerDeco,
+            innerDecorations: innerDeco
+        }), [
+        getPos,
+        innerDeco,
+        node,
+        outerDeco
+    ]);
+    const { childContextValue, contentDOM, nodeDOM } = useNodeViewDescriptor(ref, ()=>{
+        setSelected(false);
+        return {
+            dom: innerRef.current ?? ref.current,
+            update () {
+                return true;
+            },
+            multiType: true,
+            selectNode () {
+                const selectNode = selectNodeRef.current;
+                if (selectNode) {
+                    selectNode.call(this);
+                }
+                setSelected(true);
+            },
+            deselectNode () {
+                const deselectNode = deselectNodeRef.current;
+                if (deselectNode) {
+                    deselectNode.call(this);
+                }
+                setSelected(false);
+            },
+            stopEvent (event) {
+                const stopEvent = stopEventRef.current;
+                if (stopEvent) {
+                    return stopEvent.call(this, event);
+                }
+                return false;
+            },
+            ignoreMutation (mutation) {
+                const ignoreMutation = ignoreMutationRef.current;
+                if (ignoreMutation) {
+                    return ignoreMutation.call(this, mutation);
+                }
+                return false;
+            }
+        };
+    }, nodeProps);
+    const props = {
+        nodeProps,
+        ...!contentDOM && !nodeProps.node.isText && nodeDOM?.nodeName !== "BR" ? {
+            contentEditable: false,
+            suppressContentEditableWarning: true
+        } : null,
+        ...!hasCustomSelectNode && selected ? {
+            className: "ProseMirror-selectednode"
+        } : null,
+        ...!hasCustomSelectNode && selected || node.type.spec.draggable ? {
+            draggable: true
+        } : null,
+        ref: innerRef
+    };
+    const children = !node.isLeaf ? /*#__PURE__*/ React.createElement(ChildNodeViews, {
+        getPos: getPos,
+        node: node,
+        innerDecorations: innerDeco
+    }) : null;
+    const element = /*#__PURE__*/ cloneElement(outerDeco.reduce(wrapInDeco, /*#__PURE__*/ React.createElement(Component, props, children)), {
+        ref
+    });
+    return /*#__PURE__*/ React.createElement(SelectNodeContext.Provider, {
+        value: setSelectNode
+    }, /*#__PURE__*/ React.createElement(StopEventContext.Provider, {
+        value: setStopEvent
+    }, /*#__PURE__*/ React.createElement(IgnoreMutationContext.Provider, {
+        value: setIgnoreMutation
+    }, /*#__PURE__*/ React.createElement(ChildDescriptorsContext.Provider, {
+        value: childContextValue
+    }, element))));
+});

package/dist/esm/components/marks/CustomMarkView.js

@@ -0,0 +1,59 @@
+import { DOMSerializer } from "prosemirror-model";
+import React, { memo, useMemo, useRef } from "react";
+import { createPortal } from "react-dom";
+import { ChildDescriptionsContext } from "../../contexts/ChildDescriptionsContext.js";
+import { useMarkViewDescription } from "../../hooks/useMarkViewDescription.js";
+export const CustomMarkView = /*#__PURE__*/ memo(function CustomMarkView(param) {
+    let { constructor, mark, inline, getPos, children } = param;
+    const ref = useRef(null);
+    const innerRef = useRef(null);
+    const markProps = useMemo(()=>({
+            mark,
+            inline,
+            getPos,
+            contentDOMRef: {
+                current: null
+            }
+        }), [
+        mark,
+        inline,
+        getPos
+    ]);
+    const createMarkView = function() {
+        for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+            args[_key] = arguments[_key];
+        }
+        const markView = constructor(...args);
+        if (!markView || !markView.dom) {
+            const spec = mark.type.spec.toDOM?.(mark, inline);
+            if (!spec) {
+                throw new Error(`Mark spec for ${mark.type.name} is missing toDOM`);
+            }
+            return DOMSerializer.renderSpec(document, spec, null);
+        }
+        return markView;
+    };
+    const { childContextValue, contentDOM } = useMarkViewDescription(ref, function() {
+        for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+            args[_key] = arguments[_key];
+        }
+        const markView = createMarkView(...args);
+        const dom = markView.dom;
+        const wrapperDOM = innerRef.current ?? ref.current;
+        return {
+            ...markView,
+            destroy () {
+                markView.destroy?.();
+                wrapperDOM.removeChild(dom);
+            },
+            ignoreMutation: markView.ignoreMutation
+        };
+    }, (markView)=>markView?.contentDOM ?? null, markProps);
+    const Component = inline ? "span" : "div";
+    const props = {
+        ref: innerRef
+    };
+    return /*#__PURE__*/ React.createElement(Component, props, contentDOM ? /*#__PURE__*/ createPortal(/*#__PURE__*/ React.createElement(ChildDescriptionsContext.Provider, {
+        value: childContextValue
+    }, children), contentDOM) : null);
+});

package/dist/esm/components/marks/OldMarkView.js

@@ -0,0 +1,69 @@
+import React, { forwardRef, memo, useContext, useImperativeHandle, useMemo, useRef } from "react";
+import { ChildDescriptorsContext } from "../../contexts/ChildDescriptorsContext.js";
+import { useClientLayoutEffect } from "../../hooks/useClientLayoutEffect.js";
+import { MarkViewDesc, sortViewDescs } from "../../viewdesc.js";
+import { OutputSpec } from "../OutputSpec.js";
+export const MarkView = /*#__PURE__*/ memo(/*#__PURE__*/ forwardRef(function MarkView(param, ref) {
+    let { mark, getPos, children, inline = false } = param;
+    const { siblingsRef, parentRef } = useContext(ChildDescriptorsContext);
+    const viewDescRef = useRef(undefined);
+    const childDescriptors = useRef([]);
+    const domRef = useRef(null);
+    useImperativeHandle(ref, ()=>{
+        return domRef.current;
+    }, []);
+    const outputSpec = useMemo(()=>mark.type.spec.toDOM?.(mark, inline), [
+        inline,
+        mark
+    ]);
+    if (!outputSpec) throw new Error(`Mark spec for ${mark.type.name} is missing toDOM`);
+    useClientLayoutEffect(()=>{
+        const siblings = siblingsRef.current;
+        return ()=>{
+            if (!viewDescRef.current) return;
+            if (siblings.includes(viewDescRef.current)) {
+                const index = siblings.indexOf(viewDescRef.current);
+                siblings.splice(index, 1);
+            }
+        };
+    }, [
+        siblingsRef
+    ]);
+    useClientLayoutEffect(()=>{
+        if (!domRef.current) return;
+        const firstChildDesc = childDescriptors.current[0];
+        if (!viewDescRef.current) {
+            viewDescRef.current = new MarkViewDesc(parentRef.current, childDescriptors.current, getPos, mark, domRef.current, firstChildDesc?.dom.parentElement ?? domRef.current, {
+                dom: domRef.current,
+                contentDOM: firstChildDesc?.dom.parentElement ?? domRef.current
+            });
+        } else {
+            viewDescRef.current.parent = parentRef.current;
+            viewDescRef.current.spec.dom = viewDescRef.current.dom = domRef.current;
+            viewDescRef.current.children = childDescriptors.current;
+            viewDescRef.current.spec.contentDOM = viewDescRef.current.contentDOM = firstChildDesc?.dom.parentElement ?? domRef.current;
+            viewDescRef.current.mark = mark;
+        }
+        if (!siblingsRef.current.includes(viewDescRef.current)) {
+            siblingsRef.current.push(viewDescRef.current);
+        }
+        siblingsRef.current.sort(sortViewDescs);
+        for (const childDesc of childDescriptors.current){
+            childDesc.parent = viewDescRef.current;
+        }
+    });
+    const childContextValue = useMemo(()=>({
+            parentRef: viewDescRef,
+            siblingsRef: childDescriptors
+        }), [
+        childDescriptors,
+        viewDescRef
+    ]);
+    return /*#__PURE__*/ React.createElement(OutputSpec, {
+        ref: domRef,
+        outputSpec: outputSpec,
+        isMark: true
+    }, /*#__PURE__*/ React.createElement(ChildDescriptorsContext.Provider, {
+        value: childContextValue
+    }, children));
+}));

package/dist/esm/components/nodes/CustomNodeView.js

@@ -0,0 +1,84 @@
+import { DOMSerializer } from "prosemirror-model";
+import React, { cloneElement, memo, useMemo, useRef } from "react";
+import { createPortal } from "react-dom";
+import { ChildDescriptionsContext } from "../../contexts/ChildDescriptionsContext.js";
+import { useNodeViewDescription } from "../../hooks/useNodeViewDescription.js";
+import { ChildNodeViews, wrapInDeco } from "../ChildNodeViews.js";
+export const CustomNodeView = /*#__PURE__*/ memo(function CustomNodeView(param) {
+    let { constructor, node, getPos, innerDeco, outerDeco } = param;
+    const ref = useRef(null);
+    const innerRef = useRef(null);
+    const nodeProps = useMemo(()=>({
+            node,
+            getPos,
+            decorations: outerDeco,
+            innerDecorations: innerDeco,
+            contentDOMRef: {
+                current: null
+            }
+        }), [
+        node,
+        getPos,
+        outerDeco,
+        innerDeco
+    ]);
+    const createNodeView = function() {
+        for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+            args[_key] = arguments[_key];
+        }
+        const nodeView = constructor(...args);
+        if (!nodeView || !nodeView.dom) {
+            const spec = node.type.spec.toDOM?.(node);
+            if (!spec) {
+                throw new Error(`Node spec for ${node.type.name} is missing toDOM`);
+            }
+            return DOMSerializer.renderSpec(document, spec, null);
+        }
+        return nodeView;
+    };
+    const { childContextValue, contentDOM } = useNodeViewDescription(ref, function() {
+        for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+            args[_key] = arguments[_key];
+        }
+        const nodeView = createNodeView(...args);
+        const contentDOM = nodeView.contentDOM;
+        const nodeDOM = nodeView.dom;
+        const wrapperDOM = innerRef.current ?? ref.current;
+        wrapperDOM.appendChild(nodeDOM);
+        if (!contentDOM && nodeDOM instanceof HTMLElement && nodeDOM.tagName !== "BR") {
+            if (!nodeDOM.hasAttribute("contenteditable")) {
+                nodeDOM.contentEditable = "false";
+            }
+            if (node.type.spec.draggable) {
+                nodeDOM.draggable = true;
+            }
+        }
+        return {
+            ...nodeView,
+            destroy () {
+                if (nodeView.destroy) {
+                    nodeView.destroy();
+                }
+                wrapperDOM.removeChild(nodeDOM);
+            },
+            selectNode: nodeView.selectNode?.bind(nodeView),
+            deselectNode: nodeView.deselectNode?.bind(nodeView),
+            stopEvent: nodeView.stopEvent?.bind(nodeView),
+            ignoreMutation: nodeView.ignoreMutation?.bind(nodeView)
+        };
+    }, (source)=>source?.contentDOM ?? null, nodeProps);
+    const Component = node.isInline ? "span" : "div";
+    const props = {
+        ref: innerRef
+    };
+    const children = !node.isLeaf && contentDOM ? /*#__PURE__*/ createPortal(/*#__PURE__*/ React.createElement(ChildDescriptionsContext.Provider, {
+        value: childContextValue
+    }, /*#__PURE__*/ React.createElement(ChildNodeViews, {
+        getPos: getPos,
+        node: node,
+        innerDecorations: innerDeco
+    })), contentDOM) : null;
+    return /*#__PURE__*/ cloneElement(outerDeco.reduce(wrapInDeco, /*#__PURE__*/ React.createElement(Component, props, children)), {
+        ref
+    });
+});

package/dist/esm/components/nodes/ReactNodeView.js

@@ -140,7 +140,7 @@ export const ReactNodeView = /*#__PURE__*/ memo(function ReactNodeView(param) {
         ...!hasCustomSelectNode && selected ? {
             className: "ProseMirror-selectednode"
         } : null,
-        ...!hasCustomSelectNode && selected || node.type.spec.draggable ? {
+        ...!hasCustomSelectNode && selected || !contentDOMRef.current && !nodeProps.node.isText && domRef.current?.nodeName !== "BR" && node.type.spec.draggable ? {
             draggable: true
         } : null,
         ref: setNodeDOM

package/dist/esm/contexts/ChildDescriptorsContext.js

@@ -0,0 +1,9 @@
+import { createContext } from "react";
+export const ChildDescriptorsContext = createContext({
+    parentRef: {
+        current: undefined
+    },
+    siblingsRef: {
+        current: []
+    }
+});