@tiptap/core 2.5.0-beta.0 → 2.5.0-beta.2

package/dist/index.umd.js

@@ -1768,15 +1768,49 @@
               return schema.nodeFromJSON(content);
           }
           catch (error) {
+              if (options.errorOnInvalidContent) {
+                  throw new Error('[tiptap error]: Invalid JSON content', { cause: error });
+              }
               console.warn('[tiptap warn]: Invalid content.', 'Passed value:', content, 'Error:', error);
               return createNodeFromContent('', schema, options);
           }
       }
       if (isTextContent) {
-          const parser = model.DOMParser.fromSchema(schema);
-          return options.slice
+          let schemaToUse = schema;
+          let hasInvalidContent = false;
+          // Only ever check for invalid content if we're supposed to throw an error
+          if (options.errorOnInvalidContent) {
+              schemaToUse = new model.Schema({
+                  topNode: schema.spec.topNode,
+                  marks: schema.spec.marks,
+                  // Prosemirror's schemas are executed such that: the last to execute, matches last
+                  // This means that we can add a catch-all node at the end of the schema to catch any content that we don't know how to handle
+                  nodes: schema.spec.nodes.append({
+                      __tiptap__private__unknown__catch__all__node: {
+                          content: 'inline*',
+                          group: 'block',
+                          parseDOM: [
+                              {
+                                  tag: '*',
+                                  getAttrs: () => {
+                                      // 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;
+                                      return null;
+                                  },
+                              },
+                          ],
+                      },
+                  }),
+              });
+          }
+          const parser = model.DOMParser.fromSchema(schemaToUse);
+          const response = options.slice
               ? 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');
+          }
+          return response;
       }
       return createNodeFromContent('', schema, options);
   }
@@ -1805,6 +1839,7 @@
       return nodeOrFragment.toString().startsWith('<');
   };
   const insertContentAt = (position, value, options) => ({ tr, dispatch, editor }) => {
+      var _a;
       if (dispatch) {
           options = {
               parseOptions: {},
@@ -1813,12 +1848,19 @@
               applyPasteRules: false,
               ...options,
           };
-          const content = createNodeFromContent(value, editor.schema, {
-              parseOptions: {
-                  preserveWhitespace: 'full',
-                  ...options.parseOptions,
-              },
-          });
+          let content;
+          try {
+              content = createNodeFromContent(value, editor.schema, {
+                  parseOptions: {
+                      preserveWhitespace: 'full',
+                      ...options.parseOptions,
+                  },
+                  errorOnInvalidContent: (_a = options.errorOnInvalidContent) !== null && _a !== void 0 ? _a : editor.options.enableContentCheck,
+              });
+          }
+          catch (e) {
+              return false;
+          }
           // don’t dispatch an empty fragment because this can lead to strange errors
           if (content.toString() === '<>') {
               return true;
@@ -2182,13 +2224,26 @@
    * @param parseOptions Options for the parser
    * @returns The created Prosemirror document node
    */
-  function createDocument(content, schema, parseOptions = {}) {
-      return createNodeFromContent(content, schema, { slice: false, parseOptions });
+  function createDocument(content, schema, parseOptions = {}, options = {}) {
+      return createNodeFromContent(content, schema, {
+          slice: false,
+          parseOptions,
+          errorOnInvalidContent: options.errorOnInvalidContent,
+      });
   }
 
-  const setContent = (content, emitUpdate = false, parseOptions = {}) => ({ tr, editor, dispatch }) => {
+  const setContent = (content, emitUpdate = false, parseOptions = {}, options = {}) => ({ tr, editor, dispatch }) => {
+      var _a;
       const { doc } = tr;
-      const document = createDocument(content, editor.schema, parseOptions);
+      let document;
+      try {
+          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);
       }
@@ -3295,30 +3350,40 @@
           markType = getMarkType(typeOrName, state.schema);
       }
       if (dispatch) {
-          tr.selection.ranges.forEach(range => {
+          let lastPos;
+          let lastNode;
+          let trimmedFrom;
+          let trimmedTo;
+          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) {
-                      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,
-                              }));
-                          }
-                      });
+                      trimmedFrom = Math.max(pos, from);
+                      trimmedTo = Math.min(pos + node.nodeSize, to);
+                      lastPos = pos;
+                      lastNode = node;
                   }
               });
           });
+          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;
   };
@@ -3877,6 +3942,7 @@ img.ProseMirror-separator {
               enableInputRules: true,
               enablePasteRules: true,
               enableCoreExtensions: true,
+              enableContentCheck: false,
               onBeforeCreate: () => null,
               onCreate: () => null,
               onUpdate: () => null,
@@ -3885,6 +3951,7 @@ img.ProseMirror-separator {
               onFocus: () => null,
               onBlur: () => null,
               onDestroy: () => null,
+              onContentError: ({ error }) => { throw error; },
           };
           this.isCapturingTransaction = false;
           this.capturedTransaction = null;
@@ -3894,6 +3961,7 @@ img.ProseMirror-separator {
           this.createSchema();
           this.on('beforeCreate', this.options.onBeforeCreate);
           this.emit('beforeCreate', { editor: this });
+          this.on('contentError', this.options.onContentError);
           this.createView();
           this.injectCSS();
           this.on('create', this.options.onCreate);
@@ -4053,7 +4121,28 @@ img.ProseMirror-separator {
        * Creates a ProseMirror view.
        */
       createView() {
-          const doc = createDocument(this.options.content, this.schema, this.options.parseOptions);
+          let doc;
+          try {
+              doc = createDocument(this.options.content, this.schema, this.options.parseOptions, { errorOnInvalidContent: this.options.enableContentCheck });
+          }
+          catch (e) {
+              if (!(e instanceof Error) || !['[tiptap error]: Invalid JSON content', '[tiptap error]: Invalid HTML content'].includes(e.message)) {
+                  // Not the content error we were expecting
+                  throw e;
+              }
+              this.emit('contentError', {
+                  editor: this,
+                  error: e,
+                  disableCollaboration: () => {
+                      // To avoid syncing back invalid content, reinitialize the extensions without the collaboration extension
+                      this.options.extensions = this.options.extensions.filter(extension => extension.name !== 'collaboration');
+                      // Restart the initialization process by recreating the extension manager with the new set of extensions
+                      this.createExtensionManager();
+                  },
+              });
+              // Content is invalid, but attempt to create it anyway, stripping out the invalid parts
+              doc = createDocument(this.options.content, this.schema, this.options.parseOptions, { errorOnInvalidContent: false });
+          }
           const selection = resolveFocusPosition(doc, this.options.autofocus);
           this.view = new view.EditorView(this.options.element, {
               ...this.options.editorProps,