@stesura/react-prosemirror 3.2.11-stesura.1

package/dist/cjs/components/ChildNodeViews.js

@@ -0,0 +1,418 @@
+"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, {
+    ChildNodeViews: function() {
+        return ChildNodeViews;
+    },
+    wrapInDeco: function() {
+        return wrapInDeco;
+    }
+});
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _ChildDescriptionsContext = require("../contexts/ChildDescriptionsContext.js");
+const _EditorContext = require("../contexts/EditorContext.js");
+const _iterDeco = require("../decorations/iterDeco.js");
+const _reactKeys = require("../plugins/reactKeys.js");
+const _props = require("../props.js");
+const _viewdesc = require("../viewdesc.js");
+const _NativeWidgetView = require("./NativeWidgetView.js");
+const _SeparatorHackView = require("./SeparatorHackView.js");
+const _TextNodeView = require("./TextNodeView.js");
+const _TrailingHackView = require("./TrailingHackView.js");
+const _WidgetView = require("./WidgetView.js");
+const _MarkView = require("./marks/MarkView.js");
+const _NodeView = require("./nodes/NodeView.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 wrapInDeco(reactNode, deco) {
+    const { nodeName, ...attrs } = deco.type.attrs;
+    const props = (0, _props.htmlAttrsToReactProps)(attrs);
+    // We auto-wrap text nodes in spans so that we can apply attributes
+    // and styles, but we want to avoid double-wrapping the same
+    // text node
+    if (nodeName || typeof reactNode === "string") {
+        return /*#__PURE__*/ (0, _react.createElement)(nodeName ?? "span", props, reactNode);
+    }
+    return /*#__PURE__*/ (0, _react.cloneElement)(reactNode, (0, _props.mergeReactProps)(reactNode.props, props));
+}
+function areChildrenEqual(a, b) {
+    return a.type === b.type && a.marks.every((mark)=>mark.isInSet(b.marks)) && b.marks.every((mark)=>mark.isInSet(a.marks)) && a.key === b.key && (a.type !== "node" || b.type !== "node" || a.node.eq(b.node) && (0, _viewdesc.sameOuterDeco)(a.outerDeco, b.outerDeco) && a.innerDeco.eq(b.innerDeco)) && a.widget === b.widget;
+}
+const ChildView = /*#__PURE__*/ (0, _react.memo)(function ChildView(param) {
+    let { child, getInnerPos } = param;
+    const { view } = (0, _react.useContext)(_EditorContext.EditorContext);
+    const childRef = (0, _react.useRef)(child);
+    childRef.current = child;
+    const getPos = (0, _react.useCallback)(()=>{
+        return getInnerPos() + childRef.current.offset;
+    }, [
+        getInnerPos
+    ]);
+    return child.type === "widget" ? /*#__PURE__*/ _react.default.createElement(_WidgetView.WidgetView, {
+        key: child.key,
+        widget: child.widget,
+        getPos: getPos
+    }) : child.type === "native-widget" ? /*#__PURE__*/ _react.default.createElement(_NativeWidgetView.NativeWidgetView, {
+        key: child.key,
+        widget: child.widget,
+        getPos: getPos
+    }) : child.type === "hack" ? /*#__PURE__*/ _react.default.createElement(child.component, {
+        key: child.key,
+        getPos: getPos
+    }) : child.node.isText ? /*#__PURE__*/ _react.default.createElement(_ChildDescriptionsContext.ChildDescriptionsContext.Consumer, {
+        key: child.key
+    }, (param)=>{
+        let { siblingsRef, parentRef } = param;
+        return /*#__PURE__*/ _react.default.createElement(_TextNodeView.TextNodeView, {
+            view: view,
+            node: child.node,
+            getPos: getPos,
+            siblingsRef: siblingsRef,
+            parentRef: parentRef,
+            decorations: child.outerDeco
+        });
+    }) : /*#__PURE__*/ _react.default.createElement(_NodeView.RemountableNodeView, {
+        key: child.key,
+        node: child.node,
+        getPos: getPos,
+        outerDeco: child.outerDeco,
+        innerDeco: child.innerDeco
+    });
+});
+const InlinePartition = /*#__PURE__*/ (0, _react.memo)(function InlinePartition(param) {
+    let { childViews, getInnerPos } = param;
+    const firstChild = childViews[0];
+    const firstChildRef = (0, _react.useRef)(firstChild);
+    firstChildRef.current = firstChild;
+    const getPos = (0, _react.useCallback)(()=>{
+        return getInnerPos() + firstChildRef.current.offset;
+    }, [
+        getInnerPos
+    ]);
+    const firstMark = firstChild.marks[0];
+    if (!firstMark) {
+        return /*#__PURE__*/ _react.default.createElement(_react.default.Fragment, null, childViews.map((child)=>{
+            return /*#__PURE__*/ _react.default.createElement(ChildView, {
+                key: child.key,
+                child: child,
+                getInnerPos: getInnerPos
+            });
+        }));
+    }
+    return /*#__PURE__*/ _react.default.createElement(_MarkView.MarkView, {
+        key: firstChild.key,
+        mark: firstMark,
+        getPos: getPos,
+        inline: true
+    }, /*#__PURE__*/ _react.default.createElement(InlineView, {
+        key: firstChild.key,
+        getInnerPos: getInnerPos,
+        childViews: childViews.map((child)=>({
+                ...child,
+                marks: child.marks.slice(1)
+            }))
+    }));
+});
+const InlineView = /*#__PURE__*/ (0, _react.memo)(function InlineView(param) {
+    let { getInnerPos, childViews } = param;
+    // const editorState = useEditorState();
+    const partitioned = childViews.reduce((acc, child)=>{
+        const lastPartition = acc[acc.length - 1];
+        if (!lastPartition) {
+            return [
+                [
+                    child
+                ]
+            ];
+        }
+        const lastChild = lastPartition[lastPartition.length - 1];
+        if (!lastChild) {
+            return [
+                ...acc.slice(0, acc.length),
+                [
+                    child
+                ]
+            ];
+        }
+        if (!child.marks.length && !lastChild.marks.length || child.marks.length && lastChild.marks.length && // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        child.marks[0]?.eq(lastChild.marks[0])) {
+            return [
+                ...acc.slice(0, acc.length - 1),
+                [
+                    ...lastPartition.slice(0, lastPartition.length),
+                    child
+                ]
+            ];
+        }
+        return [
+            ...acc,
+            [
+                child
+            ]
+        ];
+    }, []);
+    return /*#__PURE__*/ _react.default.createElement(_react.default.Fragment, null, partitioned.map((childViews)=>{
+        const firstChild = childViews[0];
+        if (!firstChild) return null;
+        return /*#__PURE__*/ _react.default.createElement(InlinePartition, {
+            key: firstChild.key,
+            childViews: childViews,
+            getInnerPos: getInnerPos
+        });
+    }));
+});
+function createKey(innerPos, offset, index, type, posToKey, widget) {
+    const pos = innerPos + offset;
+    const key = posToKey?.get(pos);
+    if (type === "widget" || type === "native-widget") {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        if (widget.type.spec.key) // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return widget.type.spec.key;
+        if (type === "widget") {
+            // eslint-disable-next-line no-console
+            console.warn(`Widget at position ${pos} doesn't have a key specified. React ProseMirror will generate a key partially based on this widget’s index into its parent’s children. This can cause issues if there are multiple adjacent widgets.`);
+        }
+        return `${key}-${index}`;
+    }
+    if (key) return key;
+    // if (!doc) return pos;
+    const parentPos = innerPos - 1;
+    const parentKey = posToKey?.get(parentPos);
+    if (parentKey) return `${parentKey}-${offset}`;
+    return pos;
+}
+function adjustWidgetMarksForward(lastNodeChild, widgetChild) {
+    if (!widgetChild || // Using internal Decoration property, "type"
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    widgetChild.widget.type.side >= 0) return;
+    if (!lastNodeChild || !lastNodeChild.node.isInline) return;
+    const marksToSpread = lastNodeChild.marks;
+    widgetChild.marks = widgetChild.marks.reduce((acc, mark)=>mark.addToSet(acc), marksToSpread);
+}
+function adjustWidgetMarksBack(widgetChildren, nodeChild) {
+    if (!nodeChild.node.isInline) return;
+    const marksToSpread = nodeChild.marks;
+    for(let i = widgetChildren.length - 1; i >= 0; i--){
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const child = widgetChildren[i];
+        if (// Using internal Decoration property, "type"
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        child.widget.type.side < 0 || // Using internal Decoration property, "type"
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        child.widget.type.spec.marks) {
+            continue;
+        }
+        child.marks = child.marks.reduce((acc, mark)=>mark.addToSet(acc), marksToSpread);
+    }
+}
+const ChildElement = /*#__PURE__*/ (0, _react.memo)(function ChildElement(param) {
+    let { child, getInnerPos } = param;
+    const childRef = (0, _react.useRef)(child);
+    childRef.current = child;
+    const getPos = (0, _react.useCallback)(()=>{
+        return getInnerPos() + childRef.current.offset;
+    }, [
+        getInnerPos
+    ]);
+    if (child.type === "node") {
+        return child.marks.reduce((element, mark)=>/*#__PURE__*/ _react.default.createElement(_MarkView.MarkView, {
+                mark: mark,
+                getPos: getPos,
+                inline: false
+            }, element), /*#__PURE__*/ _react.default.createElement(_NodeView.RemountableNodeView, {
+            key: child.key,
+            outerDeco: child.outerDeco,
+            node: child.node,
+            innerDeco: child.innerDeco,
+            getPos: getPos
+        }));
+    } else {
+        return /*#__PURE__*/ _react.default.createElement(InlineView, {
+            key: child.key,
+            childViews: [
+                child
+            ],
+            getInnerPos: getInnerPos
+        });
+    }
+});
+function createChildElements(children, getInnerPos) {
+    if (!children.length) return [];
+    if (children.every((child)=>child.type !== "node" || child.node.isInline)) {
+        return [
+            /*#__PURE__*/ _react.default.createElement(InlineView, {
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                key: children[0].key,
+                childViews: children,
+                getInnerPos: getInnerPos
+            })
+        ];
+    }
+    return children.map((child)=>{
+        return /*#__PURE__*/ _react.default.createElement(ChildElement, {
+            key: child.key,
+            child: child,
+            getInnerPos: getInnerPos
+        });
+    });
+}
+const ChildNodeViews = /*#__PURE__*/ (0, _react.memo)(function ChildNodeViews(param) {
+    let { getPos, node, innerDecorations } = param;
+    const { view } = (0, _react.useContext)(_EditorContext.EditorContext);
+    const getInnerPos = (0, _react.useCallback)(()=>getPos() + 1, [
+        getPos
+    ]);
+    const childMap = (0, _react.useRef)(new Map()).current;
+    if (!node) return null;
+    const keysSeen = new Map();
+    let widgetChildren = [];
+    let lastNodeChild = null;
+    (0, _iterDeco.iterDeco)(node, innerDecorations, (widget, isNative, offset, index)=>{
+        const posToKey = _reactKeys.reactKeysPluginKey.getState(view.state)?.posToKey;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const widgetMarks = widget.type.spec.marks ?? [];
+        let key;
+        if (isNative) {
+            key = createKey(getInnerPos(), offset, index, "native-widget", posToKey, widget);
+            const child = {
+                type: "native-widget",
+                widget,
+                marks: widgetMarks,
+                offset,
+                index,
+                key
+            };
+            const prevChild = childMap.get(key);
+            if (prevChild && areChildrenEqual(prevChild, child)) {
+                prevChild.offset = offset;
+            } else {
+                childMap.set(key, child);
+            }
+            keysSeen.set(key, keysSeen.size);
+        } else {
+            key = createKey(getInnerPos(), offset, index, "widget", posToKey, widget);
+            const child = {
+                type: "widget",
+                widget: widget,
+                marks: widgetMarks,
+                offset,
+                index,
+                key
+            };
+            const prevChild = childMap.get(key);
+            if (prevChild && areChildrenEqual(prevChild, child)) {
+                prevChild.offset = offset;
+            } else {
+                childMap.set(key, child);
+            }
+            keysSeen.set(key, keysSeen.size);
+        }
+        const child = childMap.get(key);
+        widgetChildren.push(child);
+        adjustWidgetMarksForward(lastNodeChild, childMap.get(key));
+    }, (childNode, outerDeco, innerDeco, offset, index)=>{
+        const posToKey = _reactKeys.reactKeysPluginKey.getState(view.state)?.posToKey;
+        const key = createKey(getInnerPos(), offset, index, "node", posToKey);
+        const child = {
+            type: "node",
+            node: childNode,
+            marks: childNode.marks,
+            innerDeco,
+            outerDeco,
+            offset,
+            index,
+            key
+        };
+        const prevChild = childMap.get(key);
+        if (prevChild && areChildrenEqual(prevChild, child)) {
+            prevChild.offset = offset;
+            lastNodeChild = prevChild;
+        } else {
+            childMap.set(key, child);
+            lastNodeChild = child;
+        }
+        keysSeen.set(key, keysSeen.size);
+        adjustWidgetMarksBack(widgetChildren, lastNodeChild);
+        widgetChildren = [];
+    });
+    for (const key of childMap.keys()){
+        if (!keysSeen.has(key)) {
+            childMap.delete(key);
+        }
+    }
+    const children = Array.from(childMap.values()).sort(// We already ensured that these existed in keysSeen in the previous
+    // step
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    (a, b)=>keysSeen.get(a.key) - keysSeen.get(b.key));
+    if (node.isTextblock) {
+        const lastChild = children[children.length - 1];
+        if (!lastChild || lastChild.type !== "node" || lastChild.node.isInline && !lastChild.node.isText || // RegExp.test actually handles undefined just fine
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        /\n$/.test(lastChild.node.text)) {
+            children.push({
+                type: "hack",
+                component: _SeparatorHackView.SeparatorHackView,
+                marks: [],
+                offset: lastChild?.offset ?? 0,
+                index: (lastChild?.index ?? 0) + 1,
+                key: "trailing-hack-img"
+            }, {
+                type: "hack",
+                component: _TrailingHackView.TrailingHackView,
+                marks: [],
+                offset: lastChild?.offset ?? 0,
+                index: (lastChild?.index ?? 0) + 2,
+                key: "trailing-hack-br"
+            });
+        }
+    }
+    const childElements = createChildElements(children, getInnerPos);
+    return /*#__PURE__*/ _react.default.createElement(_react.default.Fragment, null, childElements);
+});

package/dist/cjs/components/CursorWrapper.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "CursorWrapper", {
+    enumerable: true,
+    get: function() {
+        return CursorWrapper;
+    }
+});
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _ReactEditorView = require("../ReactEditorView.js");
+const _dom = require("../dom.js");
+const _useEditorEffect = require("../hooks/useEditorEffect.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 CursorWrapper = /*#__PURE__*/ (0, _react.forwardRef)(function CursorWrapper(param, ref) {
+    let { widget, getPos, ...props } = param;
+    const innerRef = (0, _react.useRef)(null);
+    (0, _react.useImperativeHandle)(ref, ()=>{
+        return innerRef.current;
+    }, []);
+    (0, _useEditorEffect.useEditorEffect)((view)=>{
+        if (!(view instanceof _ReactEditorView.ReactEditorView) || !innerRef.current) return;
+        view.domObserver.disconnectSelection();
+        const domSel = view.domSelection();
+        if (!domSel.isCollapsed) return;
+        const node = innerRef.current;
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        domSel.collapse(node.parentNode, (0, _dom.domIndex)(node) + 1);
+        view.cursorWrapped = true;
+        view.domObserver.connectSelection();
+        return ()=>{
+            view.cursorWrapped = false;
+        };
+    }, []);
+    return /*#__PURE__*/ _react.default.createElement("img", {
+        ref: innerRef,
+        className: "ProseMirror-separator",
+        // eslint-disable-next-line react/no-unknown-property
+        "mark-placeholder": "true",
+        alt: "",
+        ...props
+    });
+});

package/dist/cjs/components/EditorStateSelectorsProvider.js

@@ -0,0 +1,90 @@
+"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, {
+    EditorStateSelectorsProvider: function() {
+        return EditorStateSelectorsProvider;
+    },
+    EditorStateSelectorsRegistrar: function() {
+        return EditorStateSelectorsRegistrar;
+    }
+});
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _EditorStateStoreContext = require("../contexts/EditorStateStoreContext.js");
+const _useEditorState = require("../hooks/useEditorState.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 EditorStateSelectorsRegistrar(param) {
+    let { children } = param;
+    const store = (0, _react.useMemo)(()=>(0, _EditorStateStoreContext.createEditorStateStore)(), []);
+    return /*#__PURE__*/ _react.default.createElement(_EditorStateStoreContext.EditorStateStoreContext.Provider, {
+        value: store
+    }, children);
+}
+function EditorStateSelectorsProvider(param) {
+    let { children } = param;
+    const editorState = (0, _useEditorState.useEditorState)();
+    const store = (0, _react.useContext)(_EditorStateStoreContext.EditorStateStoreContext);
+    // This _must_ be set during render so that child components
+    // get the latest values from their selectors during render,
+    // if they happen to render before store.notifyListeners()
+    // is called
+    store.setState(editorState);
+    // This means that we get a double-render whenever the selectors update,
+    // but everything is consistent during both renders.
+    // Only components with new selector values will render on
+    // the second render cycle
+    (0, _react.useLayoutEffect)(()=>{
+        store.notifyListeners();
+    }, [
+        editorState,
+        store
+    ]);
+    return children;
+}