@tiptap/core 2.5.5 → 2.5.7

package/dist/packages/core/src/helpers/isNodeEmpty.d.ts

@@ -1,2 +1,8 @@
 import { Node as ProseMirrorNode } from '@tiptap/pm/model';
-export declare function isNodeEmpty(node: ProseMirrorNode): boolean;
+/**
+ * Returns true if the given node is empty.
+ * When `checkChildren` is true (default), it will also check if all children are empty.
+ */
+export declare function isNodeEmpty(node: ProseMirrorNode, { checkChildren }?: {
+    checkChildren: boolean;
+}): boolean;

package/dist/packages/core/src/types.d.ts

@@ -154,9 +154,7 @@ export type GlobalAttributes = {
     /**
      * The attributes to add to the node or mark types.
      */
-    attributes: {
-        [key: string]: Attribute;
-    };
+    attributes: Record<string, Attribute | undefined>;
 }[];
 export type PickValue<T, K extends keyof T> = T[K];
 export type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tiptap/core",
   "description": "headless rich text editor",
-  "version": "2.5.5",
+  "version": "2.5.7",
   "homepage": "https://tiptap.dev",
   "keywords": [
     "tiptap",
@@ -32,10 +32,10 @@
     "dist"
   ],
   "devDependencies": {
-    "@tiptap/pm": "^2.5.5"
+    "@tiptap/pm": "^2.5.7"
   },
   "peerDependencies": {
-    "@tiptap/pm": "^2.5.5"
+    "@tiptap/pm": "^2.5.7"
   },
   "repository": {
     "type": "git",

package/src/Editor.ts

@@ -39,6 +39,7 @@ import { isFunction } from './utilities/isFunction.js'
 
 export * as extensions from './extensions/index.js'
 
+// @ts-ignore
 export interface TiptapEditorHTMLElement extends HTMLElement {
   editor?: Editor
 }
@@ -340,6 +341,7 @@ export class Editor extends EventEmitter<EditorEvents> {
 
     // Let’s store the editor instance in the DOM element.
     // So we’ll have access to it for tests.
+    // @ts-ignore
     const dom = this.view.dom as TiptapEditorHTMLElement
 
     dom.editor = this
@@ -349,6 +351,10 @@ export class Editor extends EventEmitter<EditorEvents> {
    * Creates all node views.
    */
   public createNodeViews(): void {
+    if (this.view.isDestroyed) {
+      return
+    }
+
     this.view.setProps({
       nodeViews: this.extensionManager.nodeViews,
     })

package/src/commands/insertContentAt.ts

@@ -81,6 +81,13 @@ export const insertContentAt: RawCommands['insertContentAt'] = (position, value,
         errorOnInvalidContent: options.errorOnInvalidContent ?? editor.options.enableContentCheck,
       })
     } catch (e) {
+      editor.emit('contentError', {
+        editor,
+        error: e as Error,
+        disableCollaboration: () => {
+          console.error('[tiptap error]: Unable to disable collaboration at this point in time')
+        },
+      })
       return false
     }
 

package/src/commands/splitBlock.ts

@@ -61,18 +61,30 @@ export const splitBlock: RawCommands['splitBlock'] = ({ keepMarks = true } = {})
     return false
   }
 
-  if (dispatch) {
-    const atEnd = $to.parentOffset === $to.parent.content.size
-
-    if (selection instanceof TextSelection) {
-      tr.deleteSelection()
-    }
-
-    const deflt = $from.depth === 0
-      ? undefined
-      : defaultBlockAt($from.node(-1).contentMatchAt($from.indexAfter(-1)))
-
-    let types = atEnd && deflt
+  const atEnd = $to.parentOffset === $to.parent.content.size
+
+  const deflt = $from.depth === 0
+    ? undefined
+    : defaultBlockAt($from.node(-1).contentMatchAt($from.indexAfter(-1)))
+
+  let types = atEnd && deflt
+    ? [
+      {
+        type: deflt,
+        attrs: newAttributes,
+      },
+    ]
+    : undefined
+
+  let can = canSplit(tr.doc, tr.mapping.map($from.pos), 1, types)
+
+  if (
+    !types
+      && !can
+      && canSplit(tr.doc, tr.mapping.map($from.pos), 1, deflt ? [{ type: deflt }] : undefined)
+  ) {
+    can = true
+    types = deflt
       ? [
         {
           type: deflt,
@@ -80,26 +92,14 @@ export const splitBlock: RawCommands['splitBlock'] = ({ keepMarks = true } = {})
         },
       ]
       : undefined
+  }
 
-    let can = canSplit(tr.doc, tr.mapping.map($from.pos), 1, types)
-
-    if (
-      !types
-        && !can
-        && canSplit(tr.doc, tr.mapping.map($from.pos), 1, deflt ? [{ type: deflt }] : undefined)
-    ) {
-      can = true
-      types = deflt
-        ? [
-          {
-            type: deflt,
-            attrs: newAttributes,
-          },
-        ]
-        : undefined
-    }
-
+  if (dispatch) {
     if (can) {
+      if (selection instanceof TextSelection) {
+        tr.deleteSelection()
+      }
+
       tr.split(tr.mapping.map($from.pos), 1, types)
 
       if (deflt && !atEnd && !$from.parentOffset && $from.parent.type !== deflt) {
@@ -119,5 +119,5 @@ export const splitBlock: RawCommands['splitBlock'] = ({ keepMarks = true } = {})
     tr.scrollIntoView()
   }
 
-  return true
+  return can
 }

package/src/helpers/createNodeFromContent.ts

@@ -58,13 +58,14 @@ export function createNodeFromContent(
   }
 
   if (isTextContent) {
-    let schemaToUse = schema
-    let hasInvalidContent = false
-    let invalidContent = ''
 
-    // Only ever check for invalid content if we're supposed to throw an error
+    // Check for invalid content
     if (options.errorOnInvalidContent) {
-      schemaToUse = new Schema({
+      let hasInvalidContent = false
+      let invalidContent = ''
+
+      // A copy of the current schema with a catch-all node at the end
+      const contentCheckSchema = new Schema({
         topNode: schema.spec.topNode,
         marks: schema.spec.marks,
         // Prosemirror's schemas are executed such that: the last to execute, matches last
@@ -88,19 +89,26 @@ export function createNodeFromContent(
           },
         }),
       })
-    }
 
-    const parser = DOMParser.fromSchema(schemaToUse)
+      if (options.slice) {
+        DOMParser.fromSchema(contentCheckSchema).parseSlice(elementFromString(content), options.parseOptions)
+      } else {
+        DOMParser.fromSchema(contentCheckSchema).parse(elementFromString(content), options.parseOptions)
+      }
 
-    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', { cause: new Error(`Invalid element found: ${invalidContent}`) })
+      }
+    }
+
+    const parser = DOMParser.fromSchema(schema)
 
-    if (options.errorOnInvalidContent && hasInvalidContent) {
-      throw new Error('[tiptap error]: Invalid HTML content', { cause: new Error(`Invalid element found: ${invalidContent}`) })
+    if (options.slice) {
+      return parser.parseSlice(elementFromString(content), options.parseOptions).content
     }
 
-    return response
+    return parser.parse(elementFromString(content), options.parseOptions)
+
   }
 
   return createNodeFromContent('', schema, options)

package/src/helpers/isNodeEmpty.ts

@@ -1,11 +1,41 @@
 import { Node as ProseMirrorNode } from '@tiptap/pm/model'
 
-export function isNodeEmpty(node: ProseMirrorNode): boolean {
-  const defaultContent = node.type.createAndFill()
+/**
+ * Returns true if the given node is empty.
+ * When `checkChildren` is true (default), it will also check if all children are empty.
+ */
+export function isNodeEmpty(
+  node: ProseMirrorNode,
+  { checkChildren }: { checkChildren: boolean } = { checkChildren: true },
+): boolean {
+  if (node.isText) {
+    return !node.text
+  }
+
+  if (node.content.childCount === 0) {
+    return true
+  }
 
-  if (!defaultContent) {
+  if (node.isLeaf) {
     return false
   }
 
-  return node.eq(defaultContent)
+  if (checkChildren) {
+    let hasSameContent = true
+
+    node.content.forEach(childNode => {
+      if (hasSameContent === false) {
+        // Exit early for perf
+        return
+      }
+
+      if (!isNodeEmpty(childNode)) {
+        hasSameContent = false
+      }
+    })
+
+    return hasSameContent
+  }
+
+  return false
 }