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

package/dist/index.cjs

@@ -1774,15 +1774,49 @@ function createNodeFromContent(content, schema, options) {
             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);
 }
@@ -1811,6 +1845,7 @@ const isFragment = (nodeOrFragment) => {
     return nodeOrFragment.toString().startsWith('<');
 };
 const insertContentAt = (position, value, options) => ({ tr, dispatch, editor }) => {
+    var _a;
     if (dispatch) {
         options = {
             parseOptions: {},
@@ -1819,12 +1854,19 @@ const insertContentAt = (position, value, options) => ({ tr, dispatch, editor })
             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;
@@ -2188,13 +2230,26 @@ const selectTextblockStart = () => ({ state, dispatch }) => {
  * @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);
     }
@@ -3301,30 +3356,40 @@ const updateAttributes = (typeOrName, attributes = {}) => ({ tr, state, dispatch
         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;
 };
@@ -3883,6 +3948,7 @@ class Editor extends EventEmitter {
             enableInputRules: true,
             enablePasteRules: true,
             enableCoreExtensions: true,
+            enableContentCheck: false,
             onBeforeCreate: () => null,
             onCreate: () => null,
             onUpdate: () => null,
@@ -3891,6 +3957,7 @@ class Editor extends EventEmitter {
             onFocus: () => null,
             onBlur: () => null,
             onDestroy: () => null,
+            onContentError: ({ error }) => { throw error; },
         };
         this.isCapturingTransaction = false;
         this.capturedTransaction = null;
@@ -3900,6 +3967,7 @@ class Editor extends EventEmitter {
         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);
@@ -4059,7 +4127,28 @@ class Editor extends EventEmitter {
      * 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,