@tiptap/react 2.5.9 → 2.6.1

package/dist/index.cjs

@@ -11,127 +11,6 @@ function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'defau
 var React__default = /*#__PURE__*/_interopDefaultCompat(React);
 var ReactDOM__default = /*#__PURE__*/_interopDefaultCompat(ReactDOM);
 
-const mergeRefs = (...refs) => {
-    return (node) => {
-        refs.forEach(ref => {
-            if (typeof ref === 'function') {
-                ref(node);
-            }
-            else if (ref) {
-                ref.current = node;
-            }
-        });
-    };
-};
-const Portals = ({ renderers }) => {
-    return (React__default.default.createElement(React__default.default.Fragment, null, Object.entries(renderers).map(([key, renderer]) => {
-        return ReactDOM__default.default.createPortal(renderer.reactElement, renderer.element, key);
-    })));
-};
-class PureEditorContent extends React__default.default.Component {
-    constructor(props) {
-        super(props);
-        this.editorContentRef = React__default.default.createRef();
-        this.initialized = false;
-        this.state = {
-            renderers: {},
-        };
-    }
-    componentDidMount() {
-        this.init();
-    }
-    componentDidUpdate() {
-        this.init();
-    }
-    init() {
-        const { editor } = this.props;
-        if (editor && !editor.isDestroyed && editor.options.element) {
-            if (editor.contentComponent) {
-                return;
-            }
-            const element = this.editorContentRef.current;
-            element.append(...editor.options.element.childNodes);
-            editor.setOptions({
-                element,
-            });
-            editor.contentComponent = this;
-            editor.createNodeViews();
-            this.initialized = true;
-        }
-    }
-    maybeFlushSync(fn) {
-        // Avoid calling flushSync until the editor is initialized.
-        // Initialization happens during the componentDidMount or componentDidUpdate
-        // lifecycle methods, and React doesn't allow calling flushSync from inside
-        // a lifecycle method.
-        if (this.initialized) {
-            ReactDOM.flushSync(fn);
-        }
-        else {
-            fn();
-        }
-    }
-    setRenderer(id, renderer) {
-        this.maybeFlushSync(() => {
-            this.setState(({ renderers }) => ({
-                renderers: {
-                    ...renderers,
-                    [id]: renderer,
-                },
-            }));
-        });
-    }
-    removeRenderer(id) {
-        this.maybeFlushSync(() => {
-            this.setState(({ renderers }) => {
-                const nextRenderers = { ...renderers };
-                delete nextRenderers[id];
-                return { renderers: nextRenderers };
-            });
-        });
-    }
-    componentWillUnmount() {
-        const { editor } = this.props;
-        if (!editor) {
-            return;
-        }
-        this.initialized = false;
-        if (!editor.isDestroyed) {
-            editor.view.setProps({
-                nodeViews: {},
-            });
-        }
-        editor.contentComponent = null;
-        if (!editor.options.element.firstChild) {
-            return;
-        }
-        const newElement = document.createElement('div');
-        newElement.append(...editor.options.element.childNodes);
-        editor.setOptions({
-            element: newElement,
-        });
-    }
-    render() {
-        const { editor, innerRef, ...rest } = this.props;
-        return (React__default.default.createElement(React__default.default.Fragment, null,
-            React__default.default.createElement("div", { ref: mergeRefs(innerRef, this.editorContentRef), ...rest }),
-            React__default.default.createElement(Portals, { renderers: this.state.renderers })));
-    }
-}
-// EditorContent should be re-created whenever the Editor instance changes
-const EditorContentWithKey = React.forwardRef((props, ref) => {
-    const key = React__default.default.useMemo(() => {
-        return Math.floor(Math.random() * 0xFFFFFFFF).toString();
-    }, [props.editor]);
-    // Can't use JSX here because it conflicts with the type definition of Vue's JSX, so use createElement
-    return React__default.default.createElement(PureEditorContent, {
-        key,
-        innerRef: ref,
-        ...props,
-    });
-});
-const EditorContent = React__default.default.memo(EditorContentWithKey);
-
 var shim = {exports: {}};
 
 var useSyncExternalStoreShim_production_min = {};
@@ -410,12 +289,161 @@ if (process.env.NODE_ENV === 'production') {
 
 var shimExports = shim.exports;
 
-class Editor extends core.Editor {
-    constructor() {
-        super(...arguments);
-        this.contentComponent = null;
+const mergeRefs = (...refs) => {
+    return (node) => {
+        refs.forEach(ref => {
+            if (typeof ref === 'function') {
+                ref(node);
+            }
+            else if (ref) {
+                ref.current = node;
+            }
+        });
+    };
+};
+/**
+ * This component renders all of the editor's node views.
+ */
+const Portals = ({ contentComponent, }) => {
+    // For performance reasons, we render the node view portals on state changes only
+    const renderers = shimExports.useSyncExternalStore(contentComponent.subscribe, contentComponent.getSnapshot, contentComponent.getServerSnapshot);
+    // This allows us to directly render the portals without any additional wrapper
+    return (React__default.default.createElement(React__default.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 NodeView Renderer to the editor.
+         */
+        setRenderer(id, renderer) {
+            renderers = {
+                ...renderers,
+                [id]: ReactDOM__default.default.createPortal(renderer.reactElement, renderer.element, id),
+            };
+            subscribers.forEach(subscriber => subscriber());
+        },
+        /**
+         * Removes a NodeView Renderer from the editor.
+         */
+        removeRenderer(id) {
+            const nextRenderers = { ...renderers };
+            delete nextRenderers[id];
+            renderers = nextRenderers;
+            subscribers.forEach(subscriber => subscriber());
+        },
+    };
+}
+class PureEditorContent extends React__default.default.Component {
+    constructor(props) {
+        super(props);
+        this.editorContentRef = React__default.default.createRef();
+        this.initialized = false;
+        this.state = {
+            hasContentComponentInitialized: Boolean(props.editor.contentComponent),
+        };
+    }
+    componentDidMount() {
+        this.init();
+    }
+    componentDidUpdate() {
+        this.init();
+    }
+    init() {
+        const editor = this.props.editor;
+        if (editor && !editor.isDestroyed && editor.options.element) {
+            if (editor.contentComponent) {
+                return;
+            }
+            const element = this.editorContentRef.current;
+            element.append(...editor.options.element.childNodes);
+            editor.setOptions({
+                element,
+            });
+            editor.contentComponent = getInstance();
+            // Has the content component been initialized?
+            if (!this.state.hasContentComponentInitialized) {
+                // Subscribe to the content component
+                this.unsubscribeToContentComponent = editor.contentComponent.subscribe(() => {
+                    this.setState(prevState => {
+                        if (!prevState.hasContentComponentInitialized) {
+                            return {
+                                hasContentComponentInitialized: true,
+                            };
+                        }
+                        return prevState;
+                    });
+                    // Unsubscribe to previous content component
+                    if (this.unsubscribeToContentComponent) {
+                        this.unsubscribeToContentComponent();
+                    }
+                });
+            }
+            editor.createNodeViews();
+            this.initialized = true;
+        }
+    }
+    componentWillUnmount() {
+        const editor = this.props.editor;
+        if (!editor) {
+            return;
+        }
+        this.initialized = false;
+        if (!editor.isDestroyed) {
+            editor.view.setProps({
+                nodeViews: {},
+            });
+        }
+        if (this.unsubscribeToContentComponent) {
+            this.unsubscribeToContentComponent();
+        }
+        editor.contentComponent = null;
+        if (!editor.options.element.firstChild) {
+            return;
+        }
+        const newElement = document.createElement('div');
+        newElement.append(...editor.options.element.childNodes);
+        editor.setOptions({
+            element: newElement,
+        });
+    }
+    render() {
+        const { editor, innerRef, ...rest } = this.props;
+        return (React__default.default.createElement(React__default.default.Fragment, null,
+            React__default.default.createElement("div", { ref: mergeRefs(innerRef, this.editorContentRef), ...rest }),
+            (editor === null || editor === void 0 ? void 0 : editor.contentComponent) && React__default.default.createElement(Portals, { contentComponent: editor.contentComponent })));
     }
 }
+// EditorContent should be re-created whenever the Editor instance changes
+const EditorContentWithKey = React.forwardRef((props, ref) => {
+    const key = React__default.default.useMemo(() => {
+        return Math.floor(Math.random() * 0xffffffff).toString();
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [props.editor]);
+    // Can't use JSX here because it conflicts with the type definition of Vue's JSX, so use createElement
+    return React__default.default.createElement(PureEditorContent, {
+        key,
+        innerRef: ref,
+        ...props,
+    });
+});
+const EditorContent = React__default.default.memo(EditorContentWithKey);
 
 var withSelector = {exports: {}};
 
@@ -775,17 +803,20 @@ class EditorInstanceManager {
      * Create a new editor instance. And attach event listeners.
      */
     createEditor() {
-        const editor = new Editor(this.options.current);
-        // Always call the most recent version of the callback function by default
-        editor.on('beforeCreate', (...args) => { var _a, _b; return (_b = (_a = this.options.current).onBeforeCreate) === null || _b === void 0 ? void 0 : _b.call(_a, ...args); });
-        editor.on('blur', (...args) => { var _a, _b; return (_b = (_a = this.options.current).onBlur) === null || _b === void 0 ? void 0 : _b.call(_a, ...args); });
-        editor.on('create', (...args) => { var _a, _b; return (_b = (_a = this.options.current).onCreate) === null || _b === void 0 ? void 0 : _b.call(_a, ...args); });
-        editor.on('destroy', (...args) => { var _a, _b; return (_b = (_a = this.options.current).onDestroy) === null || _b === void 0 ? void 0 : _b.call(_a, ...args); });
-        editor.on('focus', (...args) => { var _a, _b; return (_b = (_a = this.options.current).onFocus) === null || _b === void 0 ? void 0 : _b.call(_a, ...args); });
-        editor.on('selectionUpdate', (...args) => { var _a, _b; return (_b = (_a = this.options.current).onSelectionUpdate) === null || _b === void 0 ? void 0 : _b.call(_a, ...args); });
-        editor.on('transaction', (...args) => { var _a, _b; return (_b = (_a = this.options.current).onTransaction) === null || _b === void 0 ? void 0 : _b.call(_a, ...args); });
-        editor.on('update', (...args) => { var _a, _b; return (_b = (_a = this.options.current).onUpdate) === null || _b === void 0 ? void 0 : _b.call(_a, ...args); });
-        editor.on('contentError', (...args) => { var _a, _b; return (_b = (_a = this.options.current).onContentError) === null || _b === void 0 ? void 0 : _b.call(_a, ...args); });
+        const optionsToApply = {
+            ...this.options.current,
+            // Always call the most recent version of the callback function by default
+            onBeforeCreate: (...args) => { var _a, _b; return (_b = (_a = this.options.current).onBeforeCreate) === null || _b === void 0 ? void 0 : _b.call(_a, ...args); },
+            onBlur: (...args) => { var _a, _b; return (_b = (_a = this.options.current).onBlur) === null || _b === void 0 ? void 0 : _b.call(_a, ...args); },
+            onCreate: (...args) => { var _a, _b; return (_b = (_a = this.options.current).onCreate) === null || _b === void 0 ? void 0 : _b.call(_a, ...args); },
+            onDestroy: (...args) => { var _a, _b; return (_b = (_a = this.options.current).onDestroy) === null || _b === void 0 ? void 0 : _b.call(_a, ...args); },
+            onFocus: (...args) => { var _a, _b; return (_b = (_a = this.options.current).onFocus) === null || _b === void 0 ? void 0 : _b.call(_a, ...args); },
+            onSelectionUpdate: (...args) => { var _a, _b; return (_b = (_a = this.options.current).onSelectionUpdate) === null || _b === void 0 ? void 0 : _b.call(_a, ...args); },
+            onTransaction: (...args) => { var _a, _b; return (_b = (_a = this.options.current).onTransaction) === null || _b === void 0 ? void 0 : _b.call(_a, ...args); },
+            onUpdate: (...args) => { var _a, _b; return (_b = (_a = this.options.current).onUpdate) === null || _b === void 0 ? void 0 : _b.call(_a, ...args); },
+            onContentError: (...args) => { var _a, _b; return (_b = (_a = this.options.current).onContentError) === null || _b === void 0 ? void 0 : _b.call(_a, ...args); },
+        };
+        const editor = new core.Editor(optionsToApply);
         // no need to keep track of the event listeners, they will be removed when the editor is destroyed
         return editor;
     }
@@ -1019,7 +1050,9 @@ const useReactNodeView = () => React.useContext(ReactNodeViewContext);
 const NodeViewContent = props => {
     const Tag = props.as || 'div';
     const { nodeViewContentRef } = useReactNodeView();
-    return (React__default.default.createElement(Tag, { ...props, ref: nodeViewContentRef, "data-node-view-content": "", style: {
+    return (
+    // @ts-ignore
+    React__default.default.createElement(Tag, { ...props, ref: nodeViewContentRef, "data-node-view-content": "", style: {
             whiteSpace: 'pre-wrap',
             ...props.style,
         } }));
@@ -1028,7 +1061,9 @@ const NodeViewContent = props => {
 const NodeViewWrapper = React__default.default.forwardRef((props, ref) => {
     const { onDragStart } = useReactNodeView();
     const Tag = props.as || 'div';
-    return (React__default.default.createElement(Tag, { ...props, ref: ref, "data-node-view-wrapper": "", onDragStart: onDragStart, style: {
+    return (
+    // @ts-ignore
+    React__default.default.createElement(Tag, { ...props, ref: ref, "data-node-view-wrapper": "", onDragStart: onDragStart, style: {
             whiteSpace: 'normal',
             ...props.style,
         } }));
@@ -1082,19 +1117,29 @@ class ReactRenderer {
                 this.element.setAttribute(key, attrs[key]);
             });
         }
-        this.render();
+        if (this.editor.isInitialized) {
+            // On first render, we need to flush the render synchronously
+            // Renders afterwards can be async, but this fixes a cursor positioning issue
+            ReactDOM.flushSync(() => {
+                this.render();
+            });
+        }
+        else {
+            this.render();
+        }
     }
     render() {
-        var _a, _b;
+        var _a;
         const Component = this.component;
         const props = this.props;
+        const editor = this.editor;
         if (isClassComponent(Component) || isForwardRefComponent(Component)) {
             props.ref = (ref) => {
                 this.ref = ref;
             };
         }
-        this.reactElement = React__default.default.createElement(Component, { ...props });
-        (_b = (_a = this.editor) === null || _a === void 0 ? void 0 : _a.contentComponent) === null || _b === void 0 ? void 0 : _b.setRenderer(this.id, this);
+        this.reactElement = React__default.default.createElement(Component, props);
+        (_a = editor === null || editor === void 0 ? void 0 : editor.contentComponent) === null || _a === void 0 ? void 0 : _a.setRenderer(this.id, this);
     }
     updateProps(props = {}) {
         this.props = {
@@ -1104,8 +1149,9 @@ class ReactRenderer {
         this.render();
     }
     destroy() {
-        var _a, _b;
-        (_b = (_a = this.editor) === null || _a === void 0 ? void 0 : _a.contentComponent) === null || _b === void 0 ? void 0 : _b.removeRenderer(this.id);
+        var _a;
+        const editor = this.editor;
+        (_a = editor === null || editor === void 0 ? void 0 : editor.contentComponent) === null || _a === void 0 ? void 0 : _a.removeRenderer(this.id);
     }
 }
 
@@ -1127,18 +1173,19 @@ class ReactNodeView extends core.NodeView {
             };
             this.component.displayName = capitalizeFirstChar(this.extension.name);
         }
-        const ReactNodeViewProvider = componentProps => {
-            const Component = this.component;
-            const onDragStart = this.onDragStart.bind(this);
-            const nodeViewContentRef = element => {
-                if (element && this.contentDOMElement && element.firstChild !== this.contentDOMElement) {
-                    element.appendChild(this.contentDOMElement);
-                }
-            };
-            return (React__default.default.createElement(React__default.default.Fragment, null,
-                React__default.default.createElement(ReactNodeViewContext.Provider, { value: { onDragStart, nodeViewContentRef } },
-                    React__default.default.createElement(Component, { ...componentProps }))));
+        const onDragStart = this.onDragStart.bind(this);
+        const nodeViewContentRef = element => {
+            if (element && this.contentDOMElement && element.firstChild !== this.contentDOMElement) {
+                element.appendChild(this.contentDOMElement);
+            }
         };
+        const context = { onDragStart, nodeViewContentRef };
+        const Component = this.component;
+        // For performance reasons, we memoize the provider component
+        // And all of the things it requires are declared outside of the component, so it doesn't need to re-render
+        const ReactNodeViewProvider = React__default.default.memo(componentProps => {
+            return (React__default.default.createElement(ReactNodeViewContext.Provider, { value: context }, React__default.default.createElement(Component, componentProps)));
+        });
         ReactNodeViewProvider.displayName = 'ReactNodeView';
         if (this.node.isLeaf) {
             this.contentDOMElement = null;
@@ -1257,8 +1304,11 @@ function ReactNodeViewRenderer(component, options) {
     };
 }
 
+Object.defineProperty(exports, "Editor", {
+  enumerable: true,
+  get: function () { return core.Editor; }
+});
 exports.BubbleMenu = BubbleMenu;
-exports.Editor = Editor;
 exports.EditorConsumer = EditorConsumer;
 exports.EditorContent = EditorContent;
 exports.EditorContext = EditorContext;