@tiptap/core 2.5.0-beta.3 → 2.5.0-beta.5

package/dist/index.cjs

@@ -466,6 +466,7 @@ function getSchemaByResolvedExtensions(extensions, editor) {
             selectable: callOrReturn(getExtensionField(extension, 'selectable', context)),
             draggable: callOrReturn(getExtensionField(extension, 'draggable', context)),
             code: callOrReturn(getExtensionField(extension, 'code', context)),
+            whitespace: callOrReturn(getExtensionField(extension, 'whitespace', context)),
             defining: callOrReturn(getExtensionField(extension, 'defining', context)),
             isolating: callOrReturn(getExtensionField(extension, 'isolating', context)),
             attrs: Object.fromEntries(extensionAttributes.map(extensionAttribute => {
@@ -1083,7 +1084,7 @@ class ExtensionManager {
             const addKeyboardShortcuts = getExtensionField(extension, 'addKeyboardShortcuts', context);
             let defaultBindings = {};
             // bind exit handling
-            if (extension.type === 'mark' && extension.config.exitable) {
+            if (extension.type === 'mark' && getExtensionField(extension, 'exitable', context)) {
                 defaultBindings.ArrowRight = () => Mark.handleExit({ editor, mark: extension });
             }
             if (addKeyboardShortcuts) {
@@ -1289,13 +1290,17 @@ class Extension {
     configure(options = {}) {
         // return a new instance so we can use the same extension
         // with different calls of `configure`
-        const extension = this.extend();
+        const extension = this.extend({
+            ...this.config,
+            addOptions() {
+                var _a;
+                return mergeDeep(((_a = this.parent) === null || _a === void 0 ? void 0 : _a.call(this)) || {}, options);
+            },
+        });
+        // Always preserve the current name
+        extension.name = this.name;
+        // Set the parent to be our parent
         extension.parent = this.parent;
-        extension.options = mergeDeep(this.options, options);
-        extension.storage = callOrReturn(getExtensionField(extension, 'addStorage', {
-            name: extension.name,
-            options: extension.options,
-        }));
         return extension;
     }
     extend(extendedConfig = {}) {
@@ -1303,7 +1308,7 @@ class Extension {
         extension.parent = this;
         this.child = extension;
         extension.name = extendedConfig.name ? extendedConfig.name : extension.parent.name;
-        if (extendedConfig.defaultOptions) {
+        if (extendedConfig.defaultOptions && Object.keys(extendedConfig.defaultOptions).length > 0) {
             console.warn(`[tiptap warn]: BREAKING CHANGE: "defaultOptions" is deprecated. Please use "addOptions" instead. Found in extension: "${extension.name}".`);
         }
         extension.options = callOrReturn(getExtensionField(extension, 'addOptions', {
@@ -1777,6 +1782,7 @@ function createNodeFromContent(content, schema, options) {
     if (isTextContent) {
         let schemaToUse = schema;
         let hasInvalidContent = false;
+        let invalidContent = '';
         // Only ever check for invalid content if we're supposed to throw an error
         if (options.errorOnInvalidContent) {
             schemaToUse = new model.Schema({
@@ -1791,9 +1797,11 @@ function createNodeFromContent(content, schema, options) {
                         parseDOM: [
                             {
                                 tag: '*',
-                                getAttrs: () => {
+                                getAttrs: e => {
                                     // If this is ever called, we know that the content has something that we don't know how to handle in the schema
                                     hasInvalidContent = true;
+                                    // Try to stringify the element for a more helpful error message
+                                    invalidContent = typeof e === 'string' ? e : e.outerHTML;
                                     return null;
                                 },
                             },
@@ -1807,7 +1815,7 @@ function createNodeFromContent(content, schema, options) {
             ? parser.parseSlice(elementFromString(content), options.parseOptions).content
             : parser.parse(elementFromString(content), options.parseOptions);
         if (options.errorOnInvalidContent && hasInvalidContent) {
-            throw new Error('[tiptap error]: Invalid HTML content');
+            throw new Error('[tiptap error]: Invalid HTML content', { cause: new Error(`Invalid element found: ${invalidContent}`) });
         }
         return response;
     }
@@ -1860,10 +1868,6 @@ const insertContentAt = (position, value, options) => ({ tr, dispatch, editor })
         catch (e) {
             return false;
         }
-        // don’t dispatch an empty fragment because this can lead to strange errors
-        if (content.toString() === '<>') {
-            return true;
-        }
         let { from, to } = typeof position === 'number' ? { from: position, to: position } : { from: position.from, to: position.to };
         let isOnlyTextContent = true;
         let isOnlyBlockContent = true;
@@ -2233,22 +2237,27 @@ function createDocument(content, schema, parseOptions = {}, options = {}) {
     });
 }
 
-const setContent = (content, emitUpdate = false, parseOptions = {}, options = {}) => ({ tr, editor, dispatch }) => {
-    var _a;
+const setContent = (content, emitUpdate = false, parseOptions = {}, options = {}) => ({ editor, tr, dispatch, commands, }) => {
+    var _a, _b;
     const { doc } = tr;
-    let document;
-    try {
-        document = createDocument(content, editor.schema, parseOptions, {
+    // This is to keep backward compatibility with the previous behavior
+    // TODO remove this in the next major version
+    if (parseOptions.preserveWhitespace !== 'full') {
+        const document = createDocument(content, editor.schema, parseOptions, {
             errorOnInvalidContent: (_a = options.errorOnInvalidContent) !== null && _a !== void 0 ? _a : editor.options.enableContentCheck,
         });
-    }
-    catch (e) {
-        return false;
+        if (dispatch) {
+            tr.replaceWith(0, doc.content.size, document).setMeta('preventUpdate', !emitUpdate);
+        }
+        return true;
     }
     if (dispatch) {
-        tr.replaceWith(0, doc.content.size, document).setMeta('preventUpdate', !emitUpdate);
+        tr.setMeta('preventUpdate', !emitUpdate);
     }
-    return true;
+    return commands.insertContentAt({ from: 0, to: doc.content.size }, content, {
+        parseOptions,
+        errorOnInvalidContent: (_b = options.errorOnInvalidContent) !== null && _b !== void 0 ? _b : editor.options.enableContentCheck,
+    });
 };
 
 function getMarkAttributes(state, typeOrName) {
@@ -3352,40 +3361,30 @@ const updateAttributes = (typeOrName, attributes = {}) => ({ tr, state, dispatch
         markType = getMarkType(typeOrName, state.schema);
     }
     if (dispatch) {
-        let lastPos;
-        let lastNode;
-        let trimmedFrom;
-        let trimmedTo;
-        tr.selection.ranges.forEach((range) => {
+        tr.selection.ranges.forEach(range => {
             const from = range.$from.pos;
             const to = range.$to.pos;
             state.doc.nodesBetween(from, to, (node, pos) => {
                 if (nodeType && nodeType === node.type) {
-                    trimmedFrom = Math.max(pos, from);
-                    trimmedTo = Math.min(pos + node.nodeSize, to);
-                    lastPos = pos;
-                    lastNode = node;
+                    tr.setNodeMarkup(pos, undefined, {
+                        ...node.attrs,
+                        ...attributes,
+                    });
+                }
+                if (markType && node.marks.length) {
+                    node.marks.forEach(mark => {
+                        if (markType === mark.type) {
+                            const trimmedFrom = Math.max(pos, from);
+                            const trimmedTo = Math.min(pos + node.nodeSize, to);
+                            tr.addMark(trimmedFrom, trimmedTo, markType.create({
+                                ...mark.attrs,
+                                ...attributes,
+                            }));
+                        }
+                    });
                 }
             });
         });
-        if (lastNode) {
-            if (lastPos !== undefined) {
-                tr.setNodeMarkup(lastPos, undefined, {
-                    ...lastNode.attrs,
-                    ...attributes,
-                });
-            }
-            if (markType && lastNode.marks.length) {
-                lastNode.marks.forEach((mark) => {
-                    if (markType === mark.type) {
-                        tr.addMark(trimmedFrom, trimmedTo, markType.create({
-                            ...mark.attrs,
-                            ...attributes,
-                        }));
-                    }
-                });
-            }
-        }
     }
     return true;
 };
@@ -3641,7 +3640,7 @@ const Tabindex = Extension.create({
             new state.Plugin({
                 key: new state.PluginKey('tabindex'),
                 props: {
-                    attributes: this.editor.isEditable ? { tabindex: '0' } : {},
+                    attributes: () => (this.editor.isEditable ? { tabindex: '0' } : {}),
                 },
             }),
         ];
@@ -4556,20 +4555,25 @@ class Mark {
     configure(options = {}) {
         // return a new instance so we can use the same extension
         // with different calls of `configure`
-        const extension = this.extend();
-        extension.options = mergeDeep(this.options, options);
-        extension.storage = callOrReturn(getExtensionField(extension, 'addStorage', {
-            name: extension.name,
-            options: extension.options,
-        }));
+        const extension = this.extend({
+            ...this.config,
+            addOptions() {
+                var _a;
+                return mergeDeep(((_a = this.parent) === null || _a === void 0 ? void 0 : _a.call(this)) || {}, options);
+            },
+        });
+        // Always preserve the current name
+        extension.name = this.name;
+        // Set the parent to be our parent
+        extension.parent = this.parent;
         return extension;
     }
     extend(extendedConfig = {}) {
-        const extension = new Mark({ ...this.config, ...extendedConfig });
+        const extension = new Mark(extendedConfig);
         extension.parent = this;
         this.child = extension;
         extension.name = extendedConfig.name ? extendedConfig.name : extension.parent.name;
-        if (extendedConfig.defaultOptions) {
+        if (extendedConfig.defaultOptions && Object.keys(extendedConfig.defaultOptions).length > 0) {
             console.warn(`[tiptap warn]: BREAKING CHANGE: "defaultOptions" is deprecated. Please use "addOptions" instead. Found in extension: "${extension.name}".`);
         }
         extension.options = callOrReturn(getExtensionField(extension, 'addOptions', {
@@ -4643,20 +4647,25 @@ class Node {
     configure(options = {}) {
         // return a new instance so we can use the same extension
         // with different calls of `configure`
-        const extension = this.extend();
-        extension.options = mergeDeep(this.options, options);
-        extension.storage = callOrReturn(getExtensionField(extension, 'addStorage', {
-            name: extension.name,
-            options: extension.options,
-        }));
+        const extension = this.extend({
+            ...this.config,
+            addOptions() {
+                var _a;
+                return mergeDeep(((_a = this.parent) === null || _a === void 0 ? void 0 : _a.call(this)) || {}, options);
+            },
+        });
+        // Always preserve the current name
+        extension.name = this.name;
+        // Set the parent to be our parent
+        extension.parent = this.parent;
         return extension;
     }
     extend(extendedConfig = {}) {
-        const extension = new Node({ ...this.config, ...extendedConfig });
+        const extension = new Node(extendedConfig);
         extension.parent = this;
         this.child = extension;
         extension.name = extendedConfig.name ? extendedConfig.name : extension.parent.name;
-        if (extendedConfig.defaultOptions) {
+        if (extendedConfig.defaultOptions && Object.keys(extendedConfig.defaultOptions).length > 0) {
             console.warn(`[tiptap warn]: BREAKING CHANGE: "defaultOptions" is deprecated. Please use "addOptions" instead. Found in extension: "${extension.name}".`);
         }
         extension.options = callOrReturn(getExtensionField(extension, 'addOptions', {