@tiptap/core 2.5.0-beta.4 → 2.5.0-beta.6

package/dist/index.umd.js

@@ -1778,6 +1778,7 @@
       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({
@@ -1792,9 +1793,11 @@
                           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;
                                   },
                               },
@@ -1808,7 +1811,7 @@
               ? 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;
       }
@@ -1861,10 +1864,6 @@
           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;
@@ -2234,22 +2233,27 @@
       });
   }
 
-  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) {
@@ -3353,40 +3357,30 @@
           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;
   };