@stesura/react-prosemirror 3.2.11-stesura.1

package/dist/cjs/tiptap/TiptapEditorContent.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "TiptapEditorContent", {
+    enumerable: true,
+    get: function() {
+        return TiptapEditorContent;
+    }
+});
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _reactdom = require("react-dom");
+const _ProseMirrorDoc = require("../components/ProseMirrorDoc.js");
+const _useEditorEffect = require("../hooks/useEditorEffect.js");
+const _TiptapEditorContext = require("./contexts/TiptapEditorContext.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;
+}
+/**
+ * This component renders all of the editor's registered "React renderers".
+ */ const Portals = (param)=>{
+    let { contentComponent } = param;
+    const renderers = (0, _react.useSyncExternalStore)(contentComponent.subscribe, contentComponent.getSnapshot, contentComponent.getServerSnapshot);
+    return /*#__PURE__*/ _react.default.createElement(_react.default.Fragment, null, Object.values(renderers));
+};
+function getInstance() {
+    const subscribers = new Set();
+    let renderers = {};
+    return {
+        /**
+     * Subscribe to the editor instance's changes.
+     */ subscribe (callback) {
+            subscribers.add(callback);
+            return ()=>{
+                subscribers.delete(callback);
+            };
+        },
+        getSnapshot () {
+            return renderers;
+        },
+        getServerSnapshot () {
+            return renderers;
+        },
+        /**
+     * Adds a new React Renderer to the editor.
+     */ setRenderer (id, renderer) {
+            renderers = {
+                ...renderers,
+                [id]: /*#__PURE__*/ (0, _reactdom.createPortal)(renderer.reactElement, renderer.element, id)
+            };
+            subscribers.forEach((subscriber)=>subscriber());
+        },
+        /**
+     * Removes a React Renderer from the editor.
+     */ removeRenderer (id) {
+            const nextRenderers = {
+                ...renderers
+            };
+            delete nextRenderers[id];
+            renderers = nextRenderers;
+            subscribers.forEach((subscriber)=>subscriber());
+        }
+    };
+}
+function TiptapEditorContent(param) {
+    let { editor: editorProp, ...props } = param;
+    const editor = editorProp;
+    const { onEditorInitialize, onEditorDeinitialize } = (0, _react.useContext)(_TiptapEditorContext.TiptapEditorContext);
+    (0, _useEditorEffect.useEditorEffect)((view)=>{
+        if (editor.view === view) {
+            return;
+        }
+        // @ts-expect-error private property
+        editor.editorView = view;
+        editor.contentComponent = getInstance();
+        // @ts-expect-error private method
+        editor.injectCSS();
+        const dom = view.dom;
+        dom.editor = editor;
+        setTimeout(()=>{
+            if (editor.isDestroyed) {
+                return;
+            }
+            editor.commands.focus(editor.options.autofocus);
+            editor.emit("create", {
+                editor
+            });
+            editor.isInitialized = true;
+            onEditorInitialize();
+        });
+        return ()=>{
+            editor.isInitialized = false;
+            editor.contentComponent = null;
+            editor.destroy();
+            onEditorDeinitialize();
+        };
+    }, [
+        editor,
+        onEditorDeinitialize,
+        onEditorInitialize
+    ]);
+    return /*#__PURE__*/ _react.default.createElement(_react.default.Fragment, null, /*#__PURE__*/ _react.default.createElement(_ProseMirrorDoc.ProseMirrorDoc, props), editor?.contentComponent && /*#__PURE__*/ _react.default.createElement(Portals, {
+        contentComponent: editor.contentComponent
+    }));
+}

package/dist/cjs/tiptap/TiptapEditorView.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "TiptapEditorView", {
+    enumerable: true,
+    get: function() {
+        return TiptapEditorView;
+    }
+});
+const _react = require("@tiptap/react");
+const _classnames = /*#__PURE__*/ _interop_require_default(require("classnames"));
+const _react1 = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _ProseMirror = require("../components/ProseMirror.js");
+const _useForceUpdate = require("../hooks/useForceUpdate.js");
+const _TiptapEditorContext = require("./contexts/TiptapEditorContext.js");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+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 TiptapEditorView(param) {
+    let { editor, nodeViewComponents, markViewComponents, children, static: isStatic = false } = param;
+    const [isEditorInitialized, setIsEditorInitialized] = (0, _react1.useState)(editor.isInitialized);
+    const attributesProp = editor.options.editorProps?.attributes;
+    const [attributes, setAttributes] = (0, _react1.useState)(typeof attributesProp === "function" ? attributesProp(editor.state) : attributesProp);
+    const forceUpdate = (0, _useForceUpdate.useForceUpdate)();
+    const dispatchTransaction = (0, _react1.useCallback)((tr)=>{
+        // @ts-expect-error calling private method
+        editor.dispatchTransaction(tr);
+        if (typeof attributesProp === "function") {
+            setAttributes(attributesProp(editor.state));
+        }
+        // Tiptap's dispatchTransaction doesn't trigger
+        // a re-render, so we need to manually force
+        // one to ensure that React stays in sync.
+        forceUpdate();
+    }, [
+        attributesProp,
+        editor,
+        forceUpdate
+    ]);
+    const editorProps = {
+        ...editor.options.editorProps,
+        attributes: {
+            role: "textbox",
+            ...attributes,
+            class: (0, _classnames.default)(attributes?.class, "tiptap")
+        }
+    };
+    const { nodeViews, markViews } = editor.isDestroyed ? {
+        nodeViews: undefined,
+        markViews: undefined
+    } : editor.view.props;
+    const contextValue = (0, _react1.useMemo)(()=>({
+            editor
+        }), [
+        editor
+    ]);
+    const onEditorInitialize = (0, _react1.useCallback)(()=>{
+        setIsEditorInitialized(true);
+    }, []);
+    const onEditorDeinitialize = (0, _react1.useCallback)(()=>{
+        setIsEditorInitialized(false);
+    }, []);
+    const tiptapEditorContextValue = (0, _react1.useMemo)(()=>({
+            isEditorInitialized,
+            onEditorInitialize,
+            onEditorDeinitialize
+        }), [
+        isEditorInitialized,
+        onEditorDeinitialize,
+        onEditorInitialize
+    ]);
+    return /*#__PURE__*/ _react1.default.createElement(_ProseMirror.ProseMirror, {
+        static: isStatic,
+        ...editorProps,
+        markViewComponents: markViewComponents,
+        markViews: markViews,
+        nodeViewComponents: nodeViewComponents,
+        nodeViews: nodeViews,
+        state: editor.state,
+        dispatchTransaction: dispatchTransaction
+    }, /*#__PURE__*/ _react1.default.createElement(_react.EditorContext.Provider, {
+        value: contextValue
+    }, /*#__PURE__*/ _react1.default.createElement(_TiptapEditorContext.TiptapEditorContext.Provider, {
+        value: tiptapEditorContextValue
+    }, children)));
+}

package/dist/cjs/tiptap/contexts/TiptapEditorContext.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "TiptapEditorContext", {
+    enumerable: true,
+    get: function() {
+        return TiptapEditorContext;
+    }
+});
+const _react = require("react");
+const TiptapEditorContext = (0, _react.createContext)(null);

package/dist/cjs/tiptap/extensions/ReactProseMirror.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "ReactProseMirror", {
+    enumerable: true,
+    get: function() {
+        return ReactProseMirror;
+    }
+});
+const _core = require("@tiptap/core");
+const _reorderSiblings = require("../../commands/reorderSiblings.js");
+const _reactKeys = require("../../plugins/reactKeys.js");
+const ReactProseMirror = _core.Extension.create({
+    name: "@handlewithcare/react-prosemirror/reactKeys",
+    addProseMirrorPlugins () {
+        return [
+            (0, _reactKeys.reactKeys)()
+        ];
+    },
+    addCommands () {
+        return {
+            /**
+       * Command that reorders the adjacent nodes starting
+       * at the provided position.
+       *
+       * @param pos - The `start` position of the parent of the nodes being reordered
+       * @param order - The new order for the nodes, expressed as an array of indices. For
+       *                example, to swap the first two nodes in a set of three, `order`
+       *                would be set to `[1, 0, 2]`. To move the first node to the end,
+       *                and keep the other two in relative order, set `order` to `[1, 2, 0]`.
+       */ reorderSiblings (initialPos, order) {
+                return function reorderSiblingsCommand(param) {
+                    let { tr, state, dispatch } = param;
+                    return (0, _reorderSiblings.reorderSiblingsOnTransaction)(initialPos, order, tr, state, dispatch);
+                };
+            }
+        };
+    }
+});

package/dist/cjs/tiptap/extensions/ReactProseMirrorCommands.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "ReactProseMirrorCommands", {
+    enumerable: true,
+    get: function() {
+        return ReactProseMirrorCommands;
+    }
+});
+const _core = require("@tiptap/core");
+const _updateAttributes = require("./commands/updateAttributes.js");
+const ReactProseMirrorCommands = _core.Extension.create({
+    name: "reactProseMirrorCommands",
+    addCommands () {
+        return {
+            ..._core.commands,
+            updateAttributes: _updateAttributes.updateAttributes
+        };
+    }
+});

package/dist/cjs/tiptap/extensions/commands/updateAttributes.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "updateAttributes", {
+    enumerable: true,
+    get: function() {
+        return updateAttributes;
+    }
+});
+const _core = require("@tiptap/core");
+const updateAttributes = function(typeOrName) {
+    let attributes = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+    return (param)=>{
+        let { tr, state, dispatch } = param;
+        let nodeType = null;
+        let markType = null;
+        const schemaType = (0, _core.getSchemaTypeNameByName)(typeof typeOrName === "string" ? typeOrName : typeOrName.name, state.schema);
+        if (!schemaType) {
+            return false;
+        }
+        if (schemaType === "node") {
+            nodeType = (0, _core.getNodeType)(typeOrName, state.schema);
+        }
+        if (schemaType === "mark") {
+            markType = (0, _core.getMarkType)(typeOrName, state.schema);
+        }
+        let canUpdate = false;
+        tr.selection.ranges.forEach((range)=>{
+            const from = range.$from.pos;
+            const to = range.$to.pos;
+            let lastPos;
+            let lastNode;
+            let trimmedFrom;
+            let trimmedTo;
+            if (tr.selection.empty) {
+                state.doc.nodesBetween(from, to, (node, pos)=>{
+                    if (nodeType && nodeType === node.type) {
+                        canUpdate = true;
+                        trimmedFrom = Math.max(pos, from);
+                        trimmedTo = Math.min(pos + node.nodeSize, to);
+                        lastPos = pos;
+                        lastNode = node;
+                    }
+                });
+            } else {
+                state.doc.nodesBetween(from, to, (node, pos)=>{
+                    if (pos < from && nodeType && nodeType === node.type) {
+                        canUpdate = true;
+                        trimmedFrom = Math.max(pos, from);
+                        trimmedTo = Math.min(pos + node.nodeSize, to);
+                        lastPos = pos;
+                        lastNode = node;
+                    }
+                    if (pos >= from && pos <= to) {
+                        if (nodeType && nodeType === node.type) {
+                            canUpdate = true;
+                            if (dispatch) {
+                                Object.entries(attributes).forEach((param)=>{
+                                    let [key, value] = param;
+                                    tr.setNodeAttribute(pos, key, value);
+                                });
+                            }
+                        }
+                        if (markType && node.marks.length) {
+                            node.marks.forEach((mark)=>{
+                                if (markType === mark.type) {
+                                    canUpdate = true;
+                                    if (dispatch) {
+                                        const trimmedFrom2 = Math.max(pos, from);
+                                        const trimmedTo2 = Math.min(pos + node.nodeSize, to);
+                                        tr.addMark(trimmedFrom2, trimmedTo2, markType.create({
+                                            ...mark.attrs,
+                                            ...attributes
+                                        }));
+                                    }
+                                }
+                            });
+                        }
+                    }
+                });
+            }
+            if (lastNode) {
+                if (dispatch) {
+                    Object.entries(attributes).forEach((param)=>{
+                        let [key, value] = param;
+                        if (lastPos !== undefined) tr.setNodeAttribute(lastPos, key, value);
+                    });
+                }
+                if (markType && lastNode.marks.length) {
+                    lastNode.marks.forEach((mark)=>{
+                        if (markType === mark.type && dispatch) {
+                            tr.addMark(trimmedFrom, trimmedTo, markType.create({
+                                ...mark.attrs,
+                                ...attributes
+                            }));
+                        }
+                    });
+                }
+            }
+        });
+        return canUpdate;
+    };
+};