@handlewithcare/react-prosemirror 2.4.12 → 2.5.1

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

@@ -1,53 +1,45 @@
-// 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 */ import React, { cloneElement, createElement, forwardRef, memo, useImperativeHandle, useMemo, useRef } from "react";
+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";
-const getPos = {
-    current () {
-        return -1;
-    }
-};
 export const DocNodeView = /*#__PURE__*/ memo(/*#__PURE__*/ forwardRef(function DocNodeView(param, ref) {
-    let { className, node, innerDeco, outerDeco, as, viewDesc, ...elementProps } = param;
+    let { as, node, getPos, decorations, innerDecorations, setMount, ...elementProps } = param;
     const innerRef = useRef(null);
-    useImperativeHandle(ref, ()=>{
-        return innerRef.current;
-    }, []);
-    const { childDescriptors, nodeViewDescRef } = useNodeViewDescriptor(node, ()=>getPos.current(), innerRef, innerRef, innerDeco, outerDeco, viewDesc);
-    const childContextValue = useMemo(()=>({
-            parentRef: nodeViewDescRef,
-            siblingsRef: childDescriptors
+    useImperativeHandle(ref, ()=>innerRef.current);
+    useImperativeHandle(setMount, ()=>innerRef.current);
+    const nodeProps = useMemo(()=>({
+            node,
+            getPos,
+            decorations,
+            innerDecorations
         }), [
-        childDescriptors,
-        nodeViewDescRef
+        node,
+        getPos,
+        decorations,
+        innerDecorations
     ]);
-    const props = {
-        ...elementProps,
-        ref: innerRef,
-        className,
-        suppressContentEditableWarning: true
-    };
-    const element = as ? /*#__PURE__*/ cloneElement(as, props, /*#__PURE__*/ React.createElement(ChildDescriptorsContext.Provider, {
-        value: childContextValue
-    }, /*#__PURE__*/ React.createElement(ChildNodeViews, {
-        getPos: getPos,
-        node: node,
-        innerDecorations: innerDeco
-    }))) : /*#__PURE__*/ createElement("div", props, /*#__PURE__*/ React.createElement(ChildDescriptorsContext.Provider, {
+    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: 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(wrapInDeco, element);
-    return wrapped;
+        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

@@ -32,7 +32,7 @@ export const MarkView = /*#__PURE__*/ memo(/*#__PURE__*/ forwardRef(function Mar
         if (!domRef.current) return;
         const firstChildDesc = childDescriptors.current[0];
         if (!viewDescRef.current) {
-            viewDescRef.current = new MarkViewDesc(parentRef.current, childDescriptors.current, ()=>getPos.current(), mark, domRef.current, firstChildDesc?.dom.parentElement ?? domRef.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
             });
@@ -42,7 +42,6 @@ export const MarkView = /*#__PURE__*/ memo(/*#__PURE__*/ forwardRef(function Mar
             viewDescRef.current.children = childDescriptors.current;
             viewDescRef.current.spec.contentDOM = 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);

package/dist/esm/components/NativeWidgetView.js

@@ -24,7 +24,7 @@ export function NativeWidgetView(param) {
         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;
+        let dom = typeof toDOM === "function" ? toDOM(view, getPos) : toDOM;
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         if (!widget.type.spec.raw) {
             if (dom.nodeType != 1) {
@@ -41,11 +41,10 @@ export function NativeWidgetView(param) {
     useClientLayoutEffect(()=>{
         if (!rootDomRef.current) return;
         if (!viewDescRef.current) {
-            viewDescRef.current = new WidgetViewDesc(parentRef.current, ()=>getPos.current(), widget, rootDomRef.current);
+            viewDescRef.current = new WidgetViewDesc(parentRef.current, getPos, 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)) {

package/dist/esm/components/NodeView.js

@@ -1,25 +1,35 @@
-import React, { memo, useContext } from "react";
-import { EditorContext } from "../contexts/EditorContext.js";
+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(param) {
-    let { outerDeco, getPos, node, innerDeco, ...props } = param;
-    const { view } = useContext(EditorContext);
-    const customNodeView = view?.someProp("nodeViews", (nodeViews)=>nodeViews?.[node.type.name]);
-    if (customNodeView) {
-        return /*#__PURE__*/ React.createElement(CustomNodeView, {
-            customNodeView: customNodeView,
-            node: node,
-            innerDeco: innerDeco,
-            outerDeco: outerDeco,
-            getPos: getPos
-        });
-    }
-    return /*#__PURE__*/ React.createElement(ReactNodeView, {
-        node: node,
-        innerDeco: innerDeco,
-        outerDeco: outerDeco,
-        getPos: getPos,
-        ...props
-    });
+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/ProseMirror.js

@@ -1,4 +1,3 @@
-import { DecorationSet } from "prosemirror-view";
 import React, { useMemo, useState } from "react";
 import { EditorContext } from "../contexts/EditorContext.js";
 import { EditorStateContext } from "../contexts/EditorStateContext.js";
@@ -8,7 +7,9 @@ import { viewDecorations } from "../decorations/viewDecorations.js";
 import { useEditor } from "../hooks/useEditor.js";
 import { LayoutGroup } from "./LayoutGroup.js";
 import { DocNodeViewContext } from "./ProseMirrorDoc.js";
-const EMPTY_OUTER_DECOS = [];
+function getPos() {
+    return -1;
+}
 function ProseMirrorInner(param) {
     let { className, children, nodeViews, customNodeViews, ...props } = param;
     const [mount, setMount] = useState(null);
@@ -16,26 +17,33 @@ function ProseMirrorInner(param) {
         ...props,
         nodeViews: customNodeViews
     });
-    const innerDecos = editor.view ? viewDecorations(editor.view, editor.cursorWrapper) : DecorationSet.empty;
-    const outerDecos = editor.view ? computeDocDeco(editor.view) : EMPTY_OUTER_DECOS;
-    const nodeViewContextValue = useMemo(()=>({
-            nodeViews: nodeViews ?? {}
-        }), [
+    const nodeViewConstructors = editor.view.nodeViews;
+    const nodeViewContextValue = useMemo(()=>{
+        return {
+            components: {
+                ...nodeViews
+            },
+            constructors: nodeViewConstructors
+        };
+    }, [
+        nodeViewConstructors,
         nodeViews
     ]);
+    const node = state.doc;
+    const decorations = computeDocDeco(editor.view);
+    const innerDecorations = viewDecorations(editor.view, editor.cursorWrapper);
     const docNodeViewContextValue = useMemo(()=>({
-            className: className,
-            setMount: setMount,
-            node: editor.view?.state.doc,
-            innerDeco: innerDecos,
-            outerDeco: outerDecos,
-            viewDesc: editor.docViewDescRef.current
+            className,
+            setMount,
+            node,
+            getPos,
+            decorations,
+            innerDecorations
         }), [
         className,
-        editor.docViewDescRef,
-        editor.view?.state.doc,
-        innerDecos,
-        outerDecos
+        node,
+        decorations,
+        innerDecorations
     ]);
     return /*#__PURE__*/ React.createElement(EditorContext.Provider, {
         value: editor

package/dist/esm/components/ProseMirrorDoc.js

@@ -1,34 +1,13 @@
-import React, { createContext, forwardRef, useContext, useImperativeHandle, useMemo, useRef } from "react";
-import { ChildDescriptorsContext } from "../contexts/ChildDescriptorsContext.js";
+import React, { createContext, forwardRef, useContext } from "react";
 import { DocNodeView } from "./DocNodeView.js";
 export const DocNodeViewContext = /*#__PURE__*/ createContext(null);
-function ProseMirrorDoc(param, ref) {
+export const ProseMirrorDoc = /*#__PURE__*/ forwardRef(function ProseMirrorDoc(param, ref) {
     let { as, ...props } = param;
-    const childDescriptors = useRef([]);
-    const innerRef = useRef(null);
-    const { setMount, ...docProps } = useContext(DocNodeViewContext);
-    const viewDescRef = useRef(undefined);
-    useImperativeHandle(ref, ()=>{
-        return innerRef.current;
-    }, []);
-    const childContextValue = useMemo(()=>({
-            parentRef: viewDescRef,
-            siblingsRef: childDescriptors
-        }), [
-        childDescriptors,
-        viewDescRef
-    ]);
-    return /*#__PURE__*/ React.createElement(ChildDescriptorsContext.Provider, {
-        value: childContextValue
-    }, /*#__PURE__*/ React.createElement(DocNodeView, {
-        ref: (el)=>{
-            innerRef.current = el;
-            setMount(el);
-        },
+    const docProps = useContext(DocNodeViewContext);
+    return /*#__PURE__*/ React.createElement(DocNodeView, {
+        ref: ref,
         ...props,
         ...docProps,
         as: as
-    }));
-}
-const ForwardedProseMirrorDoc = /*#__PURE__*/ forwardRef(ProseMirrorDoc);
-export { ForwardedProseMirrorDoc as ProseMirrorDoc };
+    });
+});

package/dist/esm/components/ReactNodeView.js

@@ -1,81 +1,118 @@
-import React, { cloneElement, memo, useContext, useMemo, useRef } from "react";
+import React, { cloneElement, memo, useCallback, useMemo, useRef, useState } from "react";
 import { ChildDescriptorsContext } from "../contexts/ChildDescriptorsContext.js";
 import { IgnoreMutationContext } from "../contexts/IgnoreMutationContext.js";
-import { NodeViewContext } from "../contexts/NodeViewContext.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";
-import { OutputSpec } from "./OutputSpec.js";
 export const ReactNodeView = /*#__PURE__*/ memo(function ReactNodeView(param) {
-    let { outerDeco, getPos, node, innerDeco, ...props } = param;
-    const domRef = useRef(null);
-    const nodeDomRef = useRef(null);
-    const contentDomRef = useRef(null);
-    const getPosFunc = useRef(()=>getPos.current()).current;
-    const { nodeViews } = useContext(NodeViewContext);
-    let element = null;
-    const Component = nodeViews[node.type.name];
-    const outputSpec = useMemo(()=>node.type.spec.toDOM?.(node), [
-        node
-    ]);
-    const { hasContentDOM, childDescriptors, setStopEvent, setSelectNode, setIgnoreMutation, nodeViewDescRef } = useNodeViewDescriptor(node, ()=>getPos.current(), domRef, nodeDomRef, innerDeco, outerDeco, undefined, contentDomRef);
-    const finalProps = {
-        ...props,
-        ...!hasContentDOM && nodeDomRef.current?.tagName !== "BR" && {
-            contentEditable: false
-        }
-    };
+    let { component: Component, outerDeco, getPos, node, innerDeco } = param;
+    const [controlSelected, setControlSelected] = 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;
+        setControlSelected(true);
+        return ()=>{
+            selectNodeRef.current = null;
+            deselectNodeRef.current = null;
+            setControlSelected(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: getPosFunc,
+            getPos: getPos,
             decorations: outerDeco,
             innerDecorations: innerDeco
         }), [
-        getPosFunc,
+        getPos,
         innerDeco,
         node,
         outerDeco
     ]);
-    if (Component) {
-        element = /*#__PURE__*/ React.createElement(Component, {
-            ...finalProps,
-            ref: nodeDomRef,
-            nodeProps: nodeProps
-        }, /*#__PURE__*/ React.createElement(ChildNodeViews, {
-            getPos: getPos,
-            node: node,
-            innerDecorations: innerDeco
-        }));
-    } else {
-        if (outputSpec) {
-            element = /*#__PURE__*/ React.createElement(OutputSpec, {
-                ...finalProps,
-                ref: nodeDomRef,
-                outputSpec: outputSpec
-            }, /*#__PURE__*/ React.createElement(ChildNodeViews, {
-                getPos: getPos,
-                node: node,
-                innerDecorations: innerDeco
-            }));
-        }
-    }
-    if (!element) {
-        throw new Error(`Node spec for ${node.type.name} is missing toDOM`);
-    }
-    const decoratedElement = /*#__PURE__*/ cloneElement(outerDeco.reduce(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 = useMemo(()=>({
-            parentRef: nodeViewDescRef,
-            siblingsRef: childDescriptors
-        }), [
-        childDescriptors,
-        nodeViewDescRef
-    ]);
+    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();
+                }
+                setSelected(true);
+            },
+            deselectNode () {
+                const deselectNode = deselectNodeRef.current;
+                if (deselectNode) {
+                    deselectNode();
+                }
+                setSelected(false);
+            },
+            stopEvent (event) {
+                const stopEvent = stopEventRef.current;
+                if (stopEvent) {
+                    return stopEvent(event);
+                }
+                return false;
+            },
+            ignoreMutation (mutation) {
+                const ignoreMutation = ignoreMutationRef.current;
+                if (ignoreMutation) {
+                    return ignoreMutation(mutation);
+                }
+                return false;
+            }
+        };
+    }, nodeProps);
+    const children = !node.isLeaf ? /*#__PURE__*/ React.createElement(ChildNodeViews, {
+        getPos: getPos,
+        node: node,
+        innerDecorations: innerDeco
+    }) : null;
+    const innerProps = {
+        nodeProps,
+        ...!contentDOM && !nodeProps.node.isText && nodeDOM?.nodeName !== "BR" ? {
+            contentEditable: false,
+            suppressContentEditableWarning: true
+        } : null,
+        ...controlSelected && selected ? {
+            className: "ProseMirror-selectednode"
+        } : null,
+        ref: innerRef
+    };
+    const innerElement = /*#__PURE__*/ React.createElement(Component, innerProps, children);
+    const props = {
+        ...controlSelected && selected || node.type.spec.draggable ? {
+            draggable: true
+        } : null,
+        ref
+    };
+    const decoratedElement = /*#__PURE__*/ cloneElement(outerDeco.reduce(wrapInDeco, innerElement), props);
     return /*#__PURE__*/ React.createElement(SelectNodeContext.Provider, {
         value: setSelectNode
     }, /*#__PURE__*/ React.createElement(StopEventContext.Provider, {

package/dist/esm/components/SeparatorHackView.js

@@ -32,11 +32,10 @@ export function SeparatorHackView(param) {
         }
         if (!ref.current) return;
         if (!viewDescRef.current) {
-            viewDescRef.current = new TrailingHackViewDesc(parentRef.current, [], ()=>getPos.current(), ref.current, null);
+            viewDescRef.current = new TrailingHackViewDesc(parentRef.current, [], getPos, ref.current, null);
         } else {
             viewDescRef.current.parent = parentRef.current;
             viewDescRef.current.dom = ref.current;
-            viewDescRef.current.getPos = ()=>getPos.current();
         }
         if (!siblingsRef.current.includes(viewDescRef.current)) {
             siblingsRef.current.push(viewDescRef.current);

package/dist/esm/components/TextNodeView.js

@@ -37,8 +37,8 @@ export class TextNodeView extends Component {
         // when a composition was started that produces a new text node.
         // Otherwise we just rely on re-rendering the renderRef
         if (!dom) {
-            if (!view?.composing) return;
-            this.viewDescRef = new CompositionViewDesc(parentRef.current, ()=>getPos.current(), // These are just placeholders/dummies. We can't
+            if (!view.composing) return;
+            this.viewDescRef = new CompositionViewDesc(parentRef.current, getPos, // These are just placeholders/dummies. We can't
             // actually find the correct DOM nodes from here,
             // so we let our parent do it.
             // Passing a valid element here just so that the
@@ -51,12 +51,11 @@ export class TextNodeView extends Component {
             textNode = textNode.firstChild;
         }
         if (!this.viewDescRef || this.viewDescRef instanceof CompositionViewDesc) {
-            this.viewDescRef = new TextViewDesc(undefined, [], ()=>getPos.current(), node, decorations, DecorationSet.empty, dom, textNode);
+            this.viewDescRef = new TextViewDesc(undefined, [], getPos, node, decorations, DecorationSet.empty, dom, textNode);
         } else {
             this.viewDescRef.parent = parentRef.current;
             this.viewDescRef.children = [];
             this.viewDescRef.node = node;
-            this.viewDescRef.getPos = ()=>getPos.current();
             this.viewDescRef.outerDeco = decorations;
             this.viewDescRef.innerDeco = DecorationSet.empty;
             this.viewDescRef.dom = dom;
@@ -92,7 +91,7 @@ export class TextNodeView extends Component {
         // an active composition and the selection is in this node,
         // we freeze the DOM of this element so that it doesn't
         // interrupt the composition
-        if (view?.composing && view.state.selection.from >= getPos.current() && view.state.selection.from <= getPos.current() + node.nodeSize) {
+        if (view.composing && view.state.selection.from >= getPos() && view.state.selection.from <= getPos() + node.nodeSize) {
             return this.renderRef;
         }
         this.renderRef = decorations.reduce(wrapInDeco, node.text);

package/dist/esm/components/TrailingHackView.js

@@ -22,11 +22,10 @@ export function TrailingHackView(param) {
     useClientLayoutEffect(()=>{
         if (!ref.current) return;
         if (!viewDescRef.current) {
-            viewDescRef.current = new TrailingHackViewDesc(parentRef.current, [], ()=>getPos.current(), ref.current, null);
+            viewDescRef.current = new TrailingHackViewDesc(parentRef.current, [], getPos, ref.current, null);
         } else {
             viewDescRef.current.parent = parentRef.current;
             viewDescRef.current.dom = ref.current;
-            viewDescRef.current.getPos = ()=>getPos.current();
         }
         if (!siblingsRef.current.includes(viewDescRef.current)) {
             siblingsRef.current.push(viewDescRef.current);

package/dist/esm/components/WidgetView.js

@@ -6,7 +6,6 @@ export function WidgetView(param) {
     let { widget, getPos } = param;
     const { siblingsRef, parentRef } = useContext(ChildDescriptorsContext);
     const viewDescRef = useRef(null);
-    const getPosFunc = useRef(()=>getPos.current()).current;
     const domRef = useRef(null);
     useClientLayoutEffect(()=>{
         const siblings = siblingsRef.current;
@@ -23,11 +22,10 @@ export function WidgetView(param) {
     useClientLayoutEffect(()=>{
         if (!domRef.current) return;
         if (!viewDescRef.current) {
-            viewDescRef.current = new WidgetViewDesc(parentRef.current, ()=>getPos.current(), widget, domRef.current);
+            viewDescRef.current = new WidgetViewDesc(parentRef.current, getPos, widget, domRef.current);
         } else {
             viewDescRef.current.parent = parentRef.current;
             viewDescRef.current.widget = widget;
-            viewDescRef.current.getPos = ()=>getPos.current();
             viewDescRef.current.dom = domRef.current;
         }
         if (!siblingsRef.current.includes(viewDescRef.current)) {
@@ -39,7 +37,7 @@ export function WidgetView(param) {
     return Component && /*#__PURE__*/ React.createElement(Component, {
         ref: domRef,
         widget: widget,
-        getPos: getPosFunc,
+        getPos: getPos,
         contentEditable: false
     });
 }

package/dist/esm/constants.js

@@ -0,0 +1,15 @@
+import { Schema } from "prosemirror-model";
+import { EditorState } from "prosemirror-state";
+export const EMPTY_SCHEMA = new Schema({
+    nodes: {
+        doc: {
+            content: "text*"
+        },
+        text: {
+            inline: true
+        }
+    }
+});
+export const EMPTY_STATE = EditorState.create({
+    schema: EMPTY_SCHEMA
+});