@handlewithcare/react-prosemirror 2.0.0

package/dist/cjs/components/OutputSpec.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "OutputSpec", {
+    enumerable: true,
+    get: function() {
+        return ForwardedOutputSpec;
+    }
+});
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _props = require("../props.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 ForwardedOutputSpec = /*#__PURE__*/ (0, _react.memo)(/*#__PURE__*/ (0, _react.forwardRef)(function OutputSpec(param, ref) {
+    let { outputSpec, children, ...propOverrides } = param;
+    if (typeof outputSpec === "string") {
+        return /*#__PURE__*/ _react.default.createElement(_react.default.Fragment, null, outputSpec);
+    }
+    if (!Array.isArray(outputSpec)) {
+        throw new Error("@nytimes/react-prosemirror only supports strings and arrays in toDOM");
+    }
+    const tagSpec = outputSpec[0];
+    const tagName = tagSpec.replace(" ", ":");
+    const attrs = outputSpec[1];
+    let props = {
+        ref,
+        ...propOverrides
+    };
+    let start = 1;
+    if (attrs && typeof attrs === "object" && attrs.nodeType == null && !Array.isArray(attrs)) {
+        start = 2;
+        props = (0, _props.mergeReactProps)((0, _props.htmlAttrsToReactProps)(attrs), props);
+    }
+    const content = [];
+    for(let i = start; i < outputSpec.length; i++){
+        const child = outputSpec[i];
+        if (child === 0) {
+            if (i < outputSpec.length - 1 || i > start) {
+                throw new RangeError("Content hole must be the only child of its parent node");
+            }
+            return /*#__PURE__*/ (0, _react.createElement)(tagName, props, children);
+        }
+        content.push(/*#__PURE__*/ _react.default.createElement(ForwardedOutputSpec, {
+            outputSpec: child
+        }, children));
+    }
+    return /*#__PURE__*/ (0, _react.createElement)(tagName, props, ...content);
+}));

package/dist/cjs/components/ProseMirror.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "ProseMirror", {
+    enumerable: true,
+    get: function() {
+        return ProseMirror;
+    }
+});
+const _prosemirrorview = require("prosemirror-view");
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _EditorContext = require("../contexts/EditorContext.js");
+const _EditorStateContext = require("../contexts/EditorStateContext.js");
+const _NodeViewContext = require("../contexts/NodeViewContext.js");
+const _computeDocDeco = require("../decorations/computeDocDeco.js");
+const _viewDecorations = require("../decorations/viewDecorations.js");
+const _useEditor = require("../hooks/useEditor.js");
+const _LayoutGroup = require("./LayoutGroup.js");
+const _ProseMirrorDoc = require("./ProseMirrorDoc.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 EMPTY_OUTER_DECOS = [];
+function ProseMirrorInner(param) {
+    let { className, children, nodeViews, customNodeViews, ...props } = param;
+    const [mount, setMount] = (0, _react.useState)(null);
+    const { editor, state } = (0, _useEditor.useEditor)(mount, {
+        ...props,
+        nodeViews: customNodeViews
+    });
+    const innerDecos = editor.view ? (0, _viewDecorations.viewDecorations)(editor.view, editor.cursorWrapper) : _prosemirrorview.DecorationSet.empty;
+    const outerDecos = editor.view ? (0, _computeDocDeco.computeDocDeco)(editor.view) : EMPTY_OUTER_DECOS;
+    const nodeViewContextValue = (0, _react.useMemo)(()=>({
+            nodeViews: nodeViews ?? {}
+        }), [
+        nodeViews
+    ]);
+    const docNodeViewContextValue = (0, _react.useMemo)(()=>({
+            className: className,
+            setMount: setMount,
+            node: editor.view?.state.doc,
+            innerDeco: innerDecos,
+            outerDeco: outerDecos,
+            viewDesc: editor.docViewDescRef.current
+        }), [
+        className,
+        editor.docViewDescRef,
+        editor.view?.state.doc,
+        innerDecos,
+        outerDecos
+    ]);
+    return /*#__PURE__*/ _react.default.createElement(_EditorContext.EditorContext.Provider, {
+        value: editor
+    }, /*#__PURE__*/ _react.default.createElement(_EditorStateContext.EditorStateContext.Provider, {
+        value: state
+    }, /*#__PURE__*/ _react.default.createElement(_NodeViewContext.NodeViewContext.Provider, {
+        value: nodeViewContextValue
+    }, /*#__PURE__*/ _react.default.createElement(_ProseMirrorDoc.DocNodeViewContext.Provider, {
+        value: docNodeViewContextValue
+    }, children))));
+}
+function ProseMirror(props) {
+    return /*#__PURE__*/ _react.default.createElement(_LayoutGroup.LayoutGroup, null, /*#__PURE__*/ _react.default.createElement(ProseMirrorInner, props));
+}

package/dist/cjs/components/ProseMirrorDoc.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    DocNodeViewContext: function() {
+        return DocNodeViewContext;
+    },
+    ProseMirrorDoc: function() {
+        return ForwardedProseMirrorDoc;
+    }
+});
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _ChildDescriptorsContext = require("../contexts/ChildDescriptorsContext.js");
+const _DocNodeView = require("./DocNodeView.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 DocNodeViewContext = /*#__PURE__*/ (0, _react.createContext)(null);
+function ProseMirrorDoc(param, ref) {
+    let { as, ...props } = param;
+    const childDescriptors = (0, _react.useRef)([]);
+    const innerRef = (0, _react.useRef)(null);
+    const { setMount, ...docProps } = (0, _react.useContext)(DocNodeViewContext);
+    const viewDescRef = (0, _react.useRef)(undefined);
+    (0, _react.useImperativeHandle)(ref, ()=>{
+        return innerRef.current;
+    }, []);
+    const childContextValue = (0, _react.useMemo)(()=>({
+            parentRef: viewDescRef,
+            siblingsRef: childDescriptors
+        }), [
+        childDescriptors,
+        viewDescRef
+    ]);
+    return /*#__PURE__*/ _react.default.createElement(_ChildDescriptorsContext.ChildDescriptorsContext.Provider, {
+        value: childContextValue
+    }, /*#__PURE__*/ _react.default.createElement(_DocNodeView.DocNodeView, {
+        ref: (el)=>{
+            innerRef.current = el;
+            setMount(el);
+        },
+        ...props,
+        ...docProps,
+        as: as
+    }));
+}
+const ForwardedProseMirrorDoc = /*#__PURE__*/ (0, _react.forwardRef)(ProseMirrorDoc);

package/dist/cjs/components/SeparatorHackView.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "SeparatorHackView", {
+    enumerable: true,
+    get: function() {
+        return SeparatorHackView;
+    }
+});
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _browser = require("../browser.js");
+const _ChildDescriptorsContext = require("../contexts/ChildDescriptorsContext.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 SeparatorHackView(param) {
+    let { getPos } = param;
+    const { siblingsRef, parentRef } = (0, _react.useContext)(_ChildDescriptorsContext.ChildDescriptorsContext);
+    const viewDescRef = (0, _react.useRef)(null);
+    const ref = (0, _react.useRef)(null);
+    const [shouldRender, setShouldRender] = (0, _react.useState)(false);
+    (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
+    ]);
+    // There's no risk of an infinite loop here, because
+    // we call setShouldRender conditionally
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    (0, _react.useLayoutEffect)(()=>{
+        const lastSibling = siblingsRef.current[siblingsRef.current.length - 1];
+        if ((_browser.browser.safari || _browser.browser.chrome) && lastSibling?.dom?.contentEditable == "false") {
+            setShouldRender(true);
+            return;
+        }
+        if (!ref.current) return;
+        if (!viewDescRef.current) {
+            viewDescRef.current = new _viewdesc.TrailingHackViewDesc(parentRef.current, [], ()=>getPos.current(), 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);
+        }
+        siblingsRef.current.sort(_viewdesc.sortViewDescs);
+    });
+    return shouldRender ? /*#__PURE__*/ _react.default.createElement("img", {
+        ref: ref,
+        className: "ProseMirror-separator"
+    }) : null;
+}

package/dist/cjs/components/TextNodeView.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "TextNodeView", {
+    enumerable: true,
+    get: function() {
+        return TextNodeView;
+    }
+});
+const _prosemirrorview = require("prosemirror-view");
+const _react = require("react");
+const _reactdom = require("react-dom");
+const _viewdesc = require("../viewdesc.js");
+const _ChildNodeViews = require("./ChildNodeViews.js");
+function shallowEqual(objA, objB) {
+    if (objA === objB) {
+        return true;
+    }
+    if (!objA || !objB) {
+        return false;
+    }
+    const aKeys = Object.keys(objA);
+    const bKeys = Object.keys(objB);
+    const len = aKeys.length;
+    if (bKeys.length !== len) {
+        return false;
+    }
+    for(let i = 0; i < len; i++){
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const key = aKeys[i];
+        if (objA[key] !== objB[key] || !Object.prototype.hasOwnProperty.call(objB, key)) {
+            return false;
+        }
+    }
+    return true;
+}
+let TextNodeView = class TextNodeView extends _react.Component {
+    viewDescRef = null;
+    renderRef = null;
+    updateEffect() {
+        const { view, decorations, siblingsRef, parentRef, getPos, node } = this.props;
+        // There simply is no other way to ref a text node
+        // eslint-disable-next-line react/no-find-dom-node
+        const dom = (0, _reactdom.findDOMNode)(this);
+        // We only need to explicitly create a CompositionViewDesc
+        // 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 _viewdesc.CompositionViewDesc(parentRef.current, ()=>getPos.current(), // 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
+            // ViewDesc constructor doesn't blow up.
+            document.createElement("div"), document.createTextNode(node.text ?? ""), node.text ?? "");
+            return;
+        }
+        let textNode = dom;
+        while(textNode.firstChild){
+            textNode = textNode.firstChild;
+        }
+        if (!this.viewDescRef || this.viewDescRef instanceof _viewdesc.CompositionViewDesc) {
+            this.viewDescRef = new _viewdesc.TextViewDesc(undefined, [], ()=>getPos.current(), node, decorations, _prosemirrorview.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 = _prosemirrorview.DecorationSet.empty;
+            this.viewDescRef.dom = dom;
+            // @ts-expect-error We have our own ViewDesc implementations
+            this.viewDescRef.dom.pmViewDesc = this.viewDescRef;
+            this.viewDescRef.nodeDOM = textNode;
+        }
+        if (!siblingsRef.current.includes(this.viewDescRef)) {
+            siblingsRef.current.push(this.viewDescRef);
+        }
+        siblingsRef.current.sort(_viewdesc.sortViewDescs);
+    }
+    shouldComponentUpdate(nextProps) {
+        return !shallowEqual(this.props, nextProps);
+    }
+    componentDidMount() {
+        this.updateEffect();
+    }
+    componentDidUpdate() {
+        this.updateEffect();
+    }
+    componentWillUnmount() {
+        const { siblingsRef } = this.props;
+        if (!this.viewDescRef) return;
+        if (siblingsRef.current.includes(this.viewDescRef)) {
+            const index = siblingsRef.current.indexOf(this.viewDescRef);
+            siblingsRef.current.splice(index, 1);
+        }
+    }
+    render() {
+        const { view, getPos, node, decorations } = this.props;
+        // During a composition, it's crucial that we don't try to
+        // update the DOM that the user is working in. If there's
+        // 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) {
+            return this.renderRef;
+        }
+        this.renderRef = decorations.reduce(_ChildNodeViews.wrapInDeco, node.text);
+        return this.renderRef;
+    }
+};

package/dist/cjs/components/TrailingHackView.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "TrailingHackView", {
+    enumerable: true,
+    get: function() {
+        return TrailingHackView;
+    }
+});
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _ChildDescriptorsContext = require("../contexts/ChildDescriptorsContext.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 TrailingHackView(param) {
+    let { getPos } = param;
+    const { siblingsRef, parentRef } = (0, _react.useContext)(_ChildDescriptorsContext.ChildDescriptorsContext);
+    const viewDescRef = (0, _react.useRef)(null);
+    const ref = (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, _react.useLayoutEffect)(()=>{
+        if (!ref.current) return;
+        if (!viewDescRef.current) {
+            viewDescRef.current = new _viewdesc.TrailingHackViewDesc(parentRef.current, [], ()=>getPos.current(), 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);
+        }
+        siblingsRef.current.sort(_viewdesc.sortViewDescs);
+    });
+    return /*#__PURE__*/ _react.default.createElement("br", {
+        ref: ref,
+        className: "ProseMirror-trailingBreak"
+    });
+}

package/dist/cjs/components/WidgetView.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "WidgetView", {
+    enumerable: true,
+    get: function() {
+        return WidgetView;
+    }
+});
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _ChildDescriptorsContext = require("../contexts/ChildDescriptorsContext.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 WidgetView(param) {
+    let { widget, getPos } = param;
+    const { siblingsRef, parentRef } = (0, _react.useContext)(_ChildDescriptorsContext.ChildDescriptorsContext);
+    const viewDescRef = (0, _react.useRef)(null);
+    const getPosFunc = (0, _react.useRef)(()=>getPos.current()).current;
+    const domRef = (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, _react.useLayoutEffect)(()=>{
+        if (!domRef.current) return;
+        if (!viewDescRef.current) {
+            viewDescRef.current = new _viewdesc.WidgetViewDesc(parentRef.current, ()=>getPos.current(), 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)) {
+            siblingsRef.current.push(viewDescRef.current);
+        }
+        siblingsRef.current.sort(_viewdesc.sortViewDescs);
+    });
+    const { Component } = widget.type;
+    return Component && /*#__PURE__*/ _react.default.createElement(Component, {
+        ref: domRef,
+        widget: widget,
+        getPos: getPosFunc,
+        contentEditable: false
+    });
+}

package/dist/cjs/components/WidgetViewComponentProps.js

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