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

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

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "CustomMarkView", {
+    enumerable: true,
+    get: function() {
+        return CustomMarkView;
+    }
+});
+const _prosemirrormodel = require("prosemirror-model");
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _reactdom = require("react-dom");
+const _ChildDescriptionsContext = require("../../contexts/ChildDescriptionsContext.js");
+const _useMarkViewDescription = require("../../hooks/useMarkViewDescription.js");
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const CustomMarkView = /*#__PURE__*/ (0, _react.memo)(function CustomMarkView(param) {
+    let { constructor, mark, inline, getPos, children } = param;
+    const ref = (0, _react.useRef)(null);
+    const innerRef = (0, _react.useRef)(null);
+    const markProps = (0, _react.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 _prosemirrormodel.DOMSerializer.renderSpec(document, spec, null);
+        }
+        return markView;
+    };
+    const { childContextValue, contentDOM } = (0, _useMarkViewDescription.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.default.createElement(Component, props, contentDOM ? /*#__PURE__*/ (0, _reactdom.createPortal)(/*#__PURE__*/ _react.default.createElement(_ChildDescriptionsContext.ChildDescriptionsContext.Provider, {
+        value: childContextValue
+    }, children), contentDOM) : null);
+});

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

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "MarkView", {
+    enumerable: true,
+    get: function() {
+        return MarkView;
+    }
+});
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _ChildDescriptorsContext = require("../../contexts/ChildDescriptorsContext.js");
+const _useClientLayoutEffect = require("../../hooks/useClientLayoutEffect.js");
+const _viewdesc = require("../../viewdesc.js");
+const _OutputSpec = require("../OutputSpec.js");
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const MarkView = /*#__PURE__*/ (0, _react.memo)(/*#__PURE__*/ (0, _react.forwardRef)(function MarkView(param, ref) {
+    let { mark, getPos, children, inline = false } = param;
+    const { siblingsRef, parentRef } = (0, _react.useContext)(_ChildDescriptorsContext.ChildDescriptorsContext);
+    const viewDescRef = (0, _react.useRef)(undefined);
+    const childDescriptors = (0, _react.useRef)([]);
+    const domRef = (0, _react.useRef)(null);
+    (0, _react.useImperativeHandle)(ref, ()=>{
+        return domRef.current;
+    }, []);
+    const outputSpec = (0, _react.useMemo)(()=>mark.type.spec.toDOM?.(mark, inline), [
+        inline,
+        mark
+    ]);
+    if (!outputSpec) throw new Error(`Mark spec for ${mark.type.name} is missing toDOM`);
+    (0, _useClientLayoutEffect.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
+    ]);
+    (0, _useClientLayoutEffect.useClientLayoutEffect)(()=>{
+        if (!domRef.current) return;
+        const firstChildDesc = childDescriptors.current[0];
+        if (!viewDescRef.current) {
+            viewDescRef.current = new _viewdesc.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(_viewdesc.sortViewDescs);
+        for (const childDesc of childDescriptors.current){
+            childDesc.parent = viewDescRef.current;
+        }
+    });
+    const childContextValue = (0, _react.useMemo)(()=>({
+            parentRef: viewDescRef,
+            siblingsRef: childDescriptors
+        }), [
+        childDescriptors,
+        viewDescRef
+    ]);
+    return /*#__PURE__*/ _react.default.createElement(_OutputSpec.OutputSpec, {
+        ref: domRef,
+        outputSpec: outputSpec,
+        isMark: true
+    }, /*#__PURE__*/ _react.default.createElement(_ChildDescriptorsContext.ChildDescriptorsContext.Provider, {
+        value: childContextValue
+    }, children));
+}));

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

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "CustomNodeView", {
+    enumerable: true,
+    get: function() {
+        return CustomNodeView;
+    }
+});
+const _prosemirrormodel = require("prosemirror-model");
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _reactdom = require("react-dom");
+const _ChildDescriptionsContext = require("../../contexts/ChildDescriptionsContext.js");
+const _useNodeViewDescription = require("../../hooks/useNodeViewDescription.js");
+const _ChildNodeViews = require("../ChildNodeViews.js");
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const CustomNodeView = /*#__PURE__*/ (0, _react.memo)(function CustomNodeView(param) {
+    let { constructor, node, getPos, innerDeco, outerDeco } = param;
+    const ref = (0, _react.useRef)(null);
+    const innerRef = (0, _react.useRef)(null);
+    const nodeProps = (0, _react.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 _prosemirrormodel.DOMSerializer.renderSpec(document, spec, null);
+        }
+        return nodeView;
+    };
+    const { childContextValue, contentDOM } = (0, _useNodeViewDescription.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__*/ (0, _reactdom.createPortal)(/*#__PURE__*/ _react.default.createElement(_ChildDescriptionsContext.ChildDescriptionsContext.Provider, {
+        value: childContextValue
+    }, /*#__PURE__*/ _react.default.createElement(_ChildNodeViews.ChildNodeViews, {
+        getPos: getPos,
+        node: node,
+        innerDecorations: innerDeco
+    })), contentDOM) : null;
+    return /*#__PURE__*/ (0, _react.cloneElement)(outerDeco.reduce(_ChildNodeViews.wrapInDeco, /*#__PURE__*/ _react.default.createElement(Component, props, children)), {
+        ref
+    });
+});

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

@@ -191,7 +191,7 @@ const ReactNodeView = /*#__PURE__*/ (0, _react.memo)(function ReactNodeView(para
         ...!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/cjs/contexts/ChildDescriptorsContext.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "ChildDescriptorsContext", {
+    enumerable: true,
+    get: function() {
+        return ChildDescriptorsContext;
+    }
+});
+const _react = require("react");
+const ChildDescriptorsContext = (0, _react.createContext)({
+    parentRef: {
+        current: undefined
+    },
+    siblingsRef: {
+        current: []
+    }
+});

package/dist/cjs/hooks/useNodeViewDescriptor.js

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useNodeViewDescriptor", {
+    enumerable: true,
+    get: function() {
+        return 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");
+const _useEffectEvent = require("./useEffectEvent.js");
+function findContentDOM(view, source, children) {
+    // When a composition is happening, we want to essentially freeze everything,
+    // so we maintain the current contentDOM.
+    return view.composing ? source?.contentDOM ?? null : children[0]?.dom?.parentElement ?? null;
+}
+function useNodeViewDescriptor(ref, constructor, props) {
+    const { view } = (0, _react.useContext)(_EditorContext.EditorContext);
+    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, _useEffectEvent.useEffectEvent)(()=>{
+        if (!(view instanceof _ReactEditorView.ReactEditorView)) {
+            return;
+        }
+        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(view, 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;
+    });
+    const update = (0, _useEffectEvent.useEffectEvent)(()=>{
+        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(view, 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);
+    });
+    const destroy = (0, _useEffectEvent.useEffectEvent)(()=>{
+        const viewDesc = viewDescRef.current;
+        if (!viewDesc) {
+            return;
+        }
+        viewDesc.destroy();
+        const siblings = siblingsRef.current;
+        if (siblings.includes(viewDesc)) {
+            const index = siblings.indexOf(viewDesc);
+            siblings.splice(index, 1);
+        }
+        setDOM(null);
+        setContentDOM(null);
+        setNodeDOM(null);
+    });
+    (0, _useClientLayoutEffect.useClientLayoutEffect)(()=>{
+        viewDescRef.current = create();
+        return ()=>{
+            destroy();
+        };
+    }, [
+        create,
+        destroy
+    ]);
+    (0, _useClientLayoutEffect.useClientLayoutEffect)(()=>{
+        if (!update()) {
+            destroy();
+            viewDescRef.current = create();
+        }
+        const viewDesc = viewDescRef.current;
+        if (!viewDesc) {
+            return;
+        }
+        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);
+        }
+        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 (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.`);
+                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);
+            }
+        }
+    });
+    const childContextValue = (0, _react.useMemo)(()=>({
+            parentRef: viewDescRef,
+            siblingsRef: childrenRef
+        }), [
+        childrenRef,
+        viewDescRef
+    ]);
+    return {
+        childContextValue,
+        dom,
+        contentDOM,
+        nodeDOM,
+        ref
+    };
+}

package/dist/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/dist/cjs/tiptap/TiptapNodeView.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "ReactProseMirrorNodeView", {
+    enumerable: true,
+    get: function() {
+        return ReactProseMirrorNodeView;
+    }
+});
+const _core = require("@tiptap/core");
+let ReactProseMirrorNodeView = class ReactProseMirrorNodeView extends _core.NodeView {
+    _dom;
+    _contentDOM;
+    constructor(component, props, dom, contentDOM, options){
+        super(component, props, options);
+        this._dom = dom;
+        this._contentDOM = contentDOM;
+    }
+    get dom() {
+        return this._dom;
+    }
+    get contentDOM() {
+        return this._contentDOM;
+    }
+};

package/dist/cjs/tiptap/tiptapNodeView.js

@@ -17,6 +17,7 @@ const _useIgnoreMutation = require("../hooks/useIgnoreMutation.js");
 const _useIsNodeSelected = require("../hooks/useIsNodeSelected.js");
 const _useStopEvent = require("../hooks/useStopEvent.js");
 const _props = require("../props.js");
+const _refs = require("../refs.js");
 const _ReactProseMirrorNodeView = require("./ReactProseMirrorNodeView.js");
 const _useTiptapEditorEventCallback = require("./hooks/useTiptapEditorEventCallback.js");
 function _interop_require_default(obj) {
@@ -75,6 +76,7 @@ function tiptapNodeView(param) {
         const extensionManager = editor?.extensionManager ?? null;
         const extensions = extensionManager?.extensions ?? null;
         const selected = (0, _useIsNodeSelected.useIsNodeSelected)();
+        const isDraggingRef = (0, _react1.useRef)(false);
         const htmlAttributes = (0, _react1.useMemo)(()=>{
             if (!extensions) return {};
             const attributes = (0, _core.getAttributesFromExtensions)(extensions);
@@ -105,7 +107,10 @@ function tiptapNodeView(param) {
                 node,
                 view: editor.view
             }, this.dom, this.contentDOM);
-            return nodeView.stopEvent(event) ?? false;
+            nodeView.isDragging = isDraggingRef.current;
+            const result = nodeView.stopEvent(event) ?? false;
+            isDraggingRef.current = nodeView.isDragging;
+            return result;
         });
         (0, _useIgnoreMutation.useIgnoreMutation)(function(_, mutation) {
             if (ignoreMutation) {
@@ -184,12 +189,10 @@ function tiptapNodeView(param) {
             contentDOMRef,
             node.type.name
         ]);
+        const innerRef = (0, _react1.useRef)(null);
+        const finalRef = (0, _refs.useMergedDOMRefs)(ref, innerRef);
         const onDragStart = (0, _useTiptapEditorEventCallback.useTiptapEditorEventCallback)((editor, event)=>{
-            // TODO: We should probably just merge this with our own
-            // ref, I'm being lazy since we are providing this
-            // ref in the first place (in ReactNodeView), so we know
-            // it's an object
-            const dom = typeof ref === "object" ? ref?.current : null;
+            const dom = innerRef.current;
             if (!dom) return;
             const viewDesc = dom.pmViewDesc;
             if (!viewDesc) return;
@@ -216,7 +219,7 @@ function tiptapNodeView(param) {
         return /*#__PURE__*/ _react1.default.createElement(_react.ReactNodeViewContext.Provider, {
             value: nodeViewContext
         }, /*#__PURE__*/ _react1.default.createElement(OuterTag, {
-            ref: ref,
+            ref: finalRef,
             ...props,
             ...htmlProps,
             className: finalClassName