@handlewithcare/react-prosemirror 2.0.0

package/dist/cjs/components/DocNodeView.js

@@ -0,0 +1,104 @@
+// TODO: I must be missing something, but I do not know why
+// this linting rule is only broken in this file
+/* eslint-disable react/prop-types */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "DocNodeView", {
+    enumerable: true,
+    get: function() {
+        return DocNodeView;
+    }
+});
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _ChildDescriptorsContext = require("../contexts/ChildDescriptorsContext.js");
+const _useNodeViewDescriptor = require("../hooks/useNodeViewDescriptor.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 getPos = {
+    current () {
+        return -1;
+    }
+};
+const DocNodeView = /*#__PURE__*/ (0, _react.memo)(/*#__PURE__*/ (0, _react.forwardRef)(function DocNodeView(param, ref) {
+    let { className, node, innerDeco, outerDeco, as, viewDesc, ...elementProps } = param;
+    const innerRef = (0, _react.useRef)(null);
+    (0, _react.useImperativeHandle)(ref, ()=>{
+        return innerRef.current;
+    }, []);
+    const { childDescriptors, nodeViewDescRef } = (0, _useNodeViewDescriptor.useNodeViewDescriptor)(node, ()=>getPos.current(), innerRef, innerRef, innerDeco, outerDeco, viewDesc);
+    const childContextValue = (0, _react.useMemo)(()=>({
+            parentRef: nodeViewDescRef,
+            siblingsRef: childDescriptors
+        }), [
+        childDescriptors,
+        nodeViewDescRef
+    ]);
+    const props = {
+        ...elementProps,
+        ref: innerRef,
+        className,
+        suppressContentEditableWarning: true
+    };
+    const element = as ? /*#__PURE__*/ (0, _react.cloneElement)(as, props, /*#__PURE__*/ _react.default.createElement(_ChildDescriptorsContext.ChildDescriptorsContext.Provider, {
+        value: childContextValue
+    }, /*#__PURE__*/ _react.default.createElement(_ChildNodeViews.ChildNodeViews, {
+        getPos: getPos,
+        node: node,
+        innerDecorations: innerDeco
+    }))) : /*#__PURE__*/ (0, _react.createElement)("div", props, /*#__PURE__*/ _react.default.createElement(_ChildDescriptorsContext.ChildDescriptorsContext.Provider, {
+        value: childContextValue
+    }, /*#__PURE__*/ _react.default.createElement(_ChildNodeViews.ChildNodeViews, {
+        getPos: getPos,
+        node: node,
+        innerDecorations: innerDeco
+    })));
+    if (!node) return element;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const nodeDecorations = outerDeco.filter((deco)=>!deco.inline);
+    if (!nodeDecorations.length) {
+        return element;
+    }
+    const wrapped = nodeDecorations.reduce(_ChildNodeViews.wrapInDeco, element);
+    return wrapped;
+}));

package/dist/cjs/components/LayoutGroup.js

@@ -0,0 +1,111 @@
+/* Copyright (c) The New York Times Company */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "LayoutGroup", {
+    enumerable: true,
+    get: function() {
+        return LayoutGroup;
+    }
+});
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _LayoutGroupContext = require("../contexts/LayoutGroupContext.js");
+const _useForceUpdate = require("../hooks/useForceUpdate.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;
+}
+function LayoutGroup(param) {
+    let { children } = param;
+    const createQueue = (0, _react.useRef)(new Set()).current;
+    const destroyQueue = (0, _react.useRef)(new Set()).current;
+    const isMounted = (0, _react.useRef)(false);
+    const forceUpdate = (0, _useForceUpdate.useForceUpdate)();
+    const isUpdatePending = (0, _react.useRef)(true);
+    const ensureFlush = (0, _react.useCallback)(()=>{
+        if (!isUpdatePending.current) {
+            forceUpdate();
+            isUpdatePending.current = true;
+        }
+    }, [
+        forceUpdate
+    ]);
+    const register = (0, _react.useCallback)((effect)=>{
+        let destroy;
+        const create = ()=>{
+            destroy = effect();
+        };
+        createQueue.add(create);
+        ensureFlush();
+        return ()=>{
+            createQueue.delete(create);
+            if (destroy) {
+                if (isMounted.current) {
+                    destroyQueue.add(destroy);
+                    ensureFlush();
+                } else {
+                    destroy();
+                }
+            }
+        };
+    }, [
+        createQueue,
+        destroyQueue,
+        ensureFlush
+    ]);
+    (0, _react.useLayoutEffect)(()=>{
+        isUpdatePending.current = false;
+        createQueue.forEach((create)=>create());
+        createQueue.clear();
+        return ()=>{
+            destroyQueue.forEach((destroy)=>destroy());
+            destroyQueue.clear();
+        };
+    });
+    (0, _react.useLayoutEffect)(()=>{
+        isMounted.current = true;
+        return ()=>{
+            isMounted.current = false;
+        };
+    }, []);
+    return /*#__PURE__*/ _react.default.createElement(_LayoutGroupContext.LayoutGroupContext.Provider, {
+        value: register
+    }, children);
+}

package/dist/cjs/components/MarkView.js

@@ -0,0 +1,115 @@
+"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 _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 } = 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, true), [
+        mark
+    ]);
+    if (!outputSpec) throw new Error(`Mark spec for ${mark.type.name} is missing toDOM`);
+    (0, _react.useLayoutEffect)(()=>{
+        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, _react.useLayoutEffect)(()=>{
+        if (!domRef.current) return;
+        const firstChildDesc = childDescriptors.current[0];
+        if (!viewDescRef.current) {
+            viewDescRef.current = new _viewdesc.MarkViewDesc(parentRef.current, childDescriptors.current, ()=>getPos.current(), mark, domRef.current, firstChildDesc?.dom.parentElement ?? domRef.current);
+        } else {
+            viewDescRef.current.parent = parentRef.current;
+            viewDescRef.current.dom = domRef.current;
+            viewDescRef.current.children = childDescriptors.current;
+            viewDescRef.current.contentDOM = firstChildDesc?.dom.parentElement ?? domRef.current;
+            viewDescRef.current.mark = mark;
+            viewDescRef.current.getPos = ()=>getPos.current();
+        }
+        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
+    }, /*#__PURE__*/ _react.default.createElement(_ChildDescriptorsContext.ChildDescriptorsContext.Provider, {
+        value: childContextValue
+    }, children));
+}));

package/dist/cjs/components/NativeWidgetView.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "NativeWidgetView", {
+    enumerable: true,
+    get: function() {
+        return NativeWidgetView;
+    }
+});
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _ChildDescriptorsContext = require("../contexts/ChildDescriptorsContext.js");
+const _useEditorEffect = require("../hooks/useEditorEffect.js");
+const _viewdesc = require("../viewdesc.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;
+}
+function NativeWidgetView(param) {
+    let { widget, getPos } = param;
+    const { siblingsRef, parentRef } = (0, _react.useContext)(_ChildDescriptorsContext.ChildDescriptorsContext);
+    const viewDescRef = (0, _react.useRef)(null);
+    const rootDomRef = (0, _react.useRef)(null);
+    (0, _react.useLayoutEffect)(()=>{
+        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, _useEditorEffect.useEditorEffect)((view)=>{
+        if (!rootDomRef.current) return;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const toDOM = widget.type.toDOM;
+        let dom = typeof toDOM === "function" ? toDOM(view, ()=>getPos.current()) : toDOM;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        if (!widget.type.spec.raw) {
+            if (dom.nodeType != 1) {
+                const wrap = document.createElement("span");
+                wrap.appendChild(dom);
+                dom = wrap;
+            }
+            dom.contentEditable = "false";
+            dom.classList.add("ProseMirror-widget");
+        }
+        if (rootDomRef.current.firstElementChild === dom) return;
+        rootDomRef.current.replaceChildren(dom);
+    });
+    (0, _react.useLayoutEffect)(()=>{
+        if (!rootDomRef.current) return;
+        if (!viewDescRef.current) {
+            viewDescRef.current = new _viewdesc.WidgetViewDesc(parentRef.current, ()=>getPos.current(), widget, rootDomRef.current);
+        } else {
+            viewDescRef.current.parent = parentRef.current;
+            viewDescRef.current.widget = widget;
+            viewDescRef.current.getPos = ()=>getPos.current();
+            viewDescRef.current.dom = rootDomRef.current;
+        }
+        if (!siblingsRef.current.includes(viewDescRef.current)) {
+            siblingsRef.current.push(viewDescRef.current);
+        }
+        siblingsRef.current.sort(_viewdesc.sortViewDescs);
+    });
+    return /*#__PURE__*/ _react.default.createElement("span", {
+        ref: rootDomRef
+    });
+}

package/dist/cjs/components/NodeView.js

@@ -0,0 +1,196 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "NodeView", {
+    enumerable: true,
+    get: function() {
+        return NodeView;
+    }
+});
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _ChildDescriptorsContext = require("../contexts/ChildDescriptorsContext.js");
+const _EditorContext = require("../contexts/EditorContext.js");
+const _NodeViewContext = require("../contexts/NodeViewContext.js");
+const _SelectNodeContext = require("../contexts/SelectNodeContext.js");
+const _StopEventContext = require("../contexts/StopEventContext.js");
+const _useNodeViewDescriptor = require("../hooks/useNodeViewDescriptor.js");
+const _ChildNodeViews = require("./ChildNodeViews.js");
+const _CustomNodeView = require("./CustomNodeView.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 NodeView = /*#__PURE__*/ (0, _react.memo)(function NodeView(param) {
+    let { outerDeco, getPos, node, innerDeco, ...props } = param;
+    const domRef = (0, _react.useRef)(null);
+    const nodeDomRef = (0, _react.useRef)(null);
+    const contentDomRef = (0, _react.useRef)(null);
+    const getPosFunc = (0, _react.useRef)(()=>getPos.current()).current;
+    // this is ill-conceived; should revisit
+    const initialNode = (0, _react.useRef)(node);
+    const initialOuterDeco = (0, _react.useRef)(outerDeco);
+    const initialInnerDeco = (0, _react.useRef)(innerDeco);
+    const customNodeViewRootRef = (0, _react.useRef)(null);
+    const customNodeViewRef = (0, _react.useRef)(null);
+    // const state = useEditorState();
+    const { nodeViews } = (0, _react.useContext)(_NodeViewContext.NodeViewContext);
+    const { view } = (0, _react.useContext)(_EditorContext.EditorContext);
+    let element = null;
+    const Component = nodeViews[node.type.name];
+    const outputSpec = (0, _react.useMemo)(()=>node.type.spec.toDOM?.(node), [
+        node
+    ]);
+    // TODO: Would be great to pull all of the custom node view stuff into
+    // a hook
+    const customNodeView = view?.someProp("nodeViews", (nodeViews)=>nodeViews?.[node.type.name]);
+    (0, _react.useLayoutEffect)(()=>{
+        if (!customNodeViewRef.current || !customNodeViewRootRef.current) return;
+        const { dom } = customNodeViewRef.current;
+        nodeDomRef.current = customNodeViewRootRef.current;
+        customNodeViewRootRef.current.appendChild(dom);
+        return ()=>{
+            customNodeViewRef.current?.destroy?.();
+        };
+    }, []);
+    (0, _react.useLayoutEffect)(()=>{
+        if (!customNodeView || !customNodeViewRef.current) return;
+        const { destroy, update } = customNodeViewRef.current;
+        const updated = update?.call(customNodeViewRef.current, node, outerDeco, innerDeco) ?? true;
+        if (updated) return;
+        destroy?.call(customNodeViewRef.current);
+        if (!customNodeViewRootRef.current) return;
+        initialNode.current = node;
+        initialOuterDeco.current = outerDeco;
+        initialInnerDeco.current = innerDeco;
+        customNodeViewRef.current = customNodeView(initialNode.current, // customNodeView will only be set if view is set, and we can only reach
+        // this line if customNodeView is set
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        view, ()=>getPos.current(), initialOuterDeco.current, initialInnerDeco.current);
+        const { dom } = customNodeViewRef.current;
+        nodeDomRef.current = customNodeViewRootRef.current;
+        customNodeViewRootRef.current.appendChild(dom);
+    }, [
+        customNodeView,
+        view,
+        innerDeco,
+        node,
+        outerDeco,
+        getPos
+    ]);
+    const { hasContentDOM, childDescriptors, setStopEvent, setSelectNode, nodeViewDescRef } = (0, _useNodeViewDescriptor.useNodeViewDescriptor)(node, ()=>getPos.current(), domRef, nodeDomRef, innerDeco, outerDeco, undefined, contentDomRef);
+    const finalProps = {
+        ...props,
+        ...!hasContentDOM && {
+            contentEditable: false
+        }
+    };
+    const nodeProps = (0, _react.useMemo)(()=>({
+            node: node,
+            getPos: getPosFunc,
+            decorations: outerDeco,
+            innerDecorations: innerDeco
+        }), [
+        getPosFunc,
+        innerDeco,
+        node,
+        outerDeco
+    ]);
+    if (Component) {
+        element = /*#__PURE__*/ _react.default.createElement(Component, {
+            ...finalProps,
+            ref: nodeDomRef,
+            nodeProps: nodeProps
+        }, /*#__PURE__*/ _react.default.createElement(_ChildNodeViews.ChildNodeViews, {
+            getPos: getPos,
+            node: node,
+            innerDecorations: innerDeco
+        }));
+    } else if (customNodeView) {
+        element = /*#__PURE__*/ _react.default.createElement(_CustomNodeView.CustomNodeView, {
+            contentDomRef: contentDomRef,
+            customNodeView: customNodeView,
+            customNodeViewRef: customNodeViewRef,
+            customNodeViewRootRef: customNodeViewRootRef,
+            initialInnerDeco: initialInnerDeco,
+            initialNode: initialNode,
+            initialOuterDeco: initialOuterDeco,
+            node: node,
+            getPos: getPos,
+            innerDeco: innerDeco
+        });
+    } else {
+        if (outputSpec) {
+            element = /*#__PURE__*/ _react.default.createElement(_OutputSpec.OutputSpec, {
+                ...finalProps,
+                ref: nodeDomRef,
+                outputSpec: outputSpec
+            }, /*#__PURE__*/ _react.default.createElement(_ChildNodeViews.ChildNodeViews, {
+                getPos: getPos,
+                node: node,
+                innerDecorations: innerDeco
+            }));
+        }
+    }
+    if (!element) {
+        throw new Error(`Node spec for ${node.type.name} is missing toDOM`);
+    }
+    const decoratedElement = /*#__PURE__*/ (0, _react.cloneElement)(outerDeco.reduce(_ChildNodeViews.wrapInDeco, element), // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    outerDeco.some((d)=>d.type.attrs.nodeName) ? {
+        ref: domRef
+    } : // we've already passed the domRef to the NodeView component
+    // as a prop
+    undefined);
+    const childContextValue = (0, _react.useMemo)(()=>({
+            parentRef: nodeViewDescRef,
+            siblingsRef: childDescriptors
+        }), [
+        childDescriptors,
+        nodeViewDescRef
+    ]);
+    return /*#__PURE__*/ _react.default.createElement(_SelectNodeContext.SelectNodeContext.Provider, {
+        value: setSelectNode
+    }, /*#__PURE__*/ _react.default.createElement(_StopEventContext.StopEventContext.Provider, {
+        value: setStopEvent
+    }, /*#__PURE__*/ _react.default.createElement(_ChildDescriptorsContext.ChildDescriptorsContext.Provider, {
+        value: childContextValue
+    }, decoratedElement)));
+});

package/dist/cjs/components/NodeViewComponentProps.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});