@tiptap/core 2.4.0 → 2.5.0-beta.1

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;
@@ -1900,7 +1942,7 @@ const joinForward = () => ({ state, dispatch }) => {
     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) {
@@ -1912,7 +1954,7 @@ const joinItemBackward = () => ({ tr, state, dispatch, }) => {
         }
         return true;
     }
-    catch {
+    catch (e) {
         return false;
     }
 };
@@ -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);
     }
@@ -3883,6 +3938,7 @@ class Editor extends EventEmitter {
             enableInputRules: true,
             enablePasteRules: true,
             enableCoreExtensions: true,
+            enableContentCheck: false,
             onBeforeCreate: () => null,
             onCreate: () => null,
             onUpdate: () => null,
@@ -3891,6 +3947,7 @@ class Editor extends EventEmitter {
             onFocus: () => null,
             onBlur: () => null,
             onDestroy: () => null,
+            onContentError: ({ error }) => { throw error; },
         };
         this.isCapturingTransaction = false;
         this.capturedTransaction = null;
@@ -3900,6 +3957,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 +4117,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,
@@ -4320,7 +4399,8 @@ function nodeInputRule(config) {
                 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();
         },