@tiptap/core 2.4.0 → 2.5.0-beta.1

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;
@@ -1894,7 +1936,7 @@
       return commands$1.joinForward(state, dispatch);
   };
 
-  const joinItemBackward = () => ({ tr, state, dispatch, }) => {
+  const joinItemBackward = () => ({ state, dispatch, tr, }) => {
       try {
           const point = transform.joinPoint(state.doc, state.selection.$from.pos, -1);
           if (point === null || point === undefined) {
@@ -1906,7 +1948,7 @@
           }
           return true;
       }
-      catch {
+      catch (e) {
           return false;
       }
   };
@@ -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);
       }
@@ -3877,6 +3932,7 @@ img.ProseMirror-separator {
               enableInputRules: true,
               enablePasteRules: true,
               enableCoreExtensions: true,
+              enableContentCheck: false,
               onBeforeCreate: () => null,
               onCreate: () => null,
               onUpdate: () => null,
@@ -3885,6 +3941,7 @@ img.ProseMirror-separator {
               onFocus: () => null,
               onBlur: () => null,
               onDestroy: () => null,
+              onContentError: ({ error }) => { throw error; },
           };
           this.isCapturingTransaction = false;
           this.capturedTransaction = null;
@@ -3894,6 +3951,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 +4111,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,
@@ -4314,7 +4393,8 @@ img.ProseMirror-separator {
                   tr.replaceWith(matchStart, end, newNode);
               }
               else if (match[0]) {
-                  tr.insert(start - 1, config.type.create(attributes)).delete(tr.mapping.map(start), tr.mapping.map(end));
+                  const insertionStart = config.type.isInline ? start : start - 1;
+                  tr.insert(insertionStart, config.type.create(attributes)).delete(tr.mapping.map(start), tr.mapping.map(end));
               }
               tr.scrollIntoView();
           },