@tiptap/core 3.10.6 → 3.10.8

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tiptap/core",
   "description": "headless rich text editor",
-  "version": "3.10.6",
+  "version": "3.10.8",
   "homepage": "https://tiptap.dev",
   "keywords": [
     "tiptap",
@@ -52,10 +52,10 @@
     "jsx-dev-runtime"
   ],
   "devDependencies": {
-    "@tiptap/pm": "^3.10.6"
+    "@tiptap/pm": "^3.10.8"
   },
   "peerDependencies": {
-    "@tiptap/pm": "^3.10.6"
+    "@tiptap/pm": "^3.10.8"
   },
   "repository": {
     "type": "git",

package/src/commands/resetAttributes.ts

@@ -43,23 +43,31 @@ export const resetAttributes: RawCommands['resetAttributes'] =
       markType = getMarkType(typeOrName as MarkType, state.schema)
     }
 
-    if (dispatch) {
-      tr.selection.ranges.forEach(range => {
-        state.doc.nodesBetween(range.$from.pos, range.$to.pos, (node, pos) => {
-          if (nodeType && nodeType === node.type) {
+    let canReset = false
+
+    tr.selection.ranges.forEach(range => {
+      state.doc.nodesBetween(range.$from.pos, range.$to.pos, (node, pos) => {
+        if (nodeType && nodeType === node.type) {
+          canReset = true
+
+          if (dispatch) {
             tr.setNodeMarkup(pos, undefined, deleteProps(node.attrs, attributes))
           }
+        }
+
+        if (markType && node.marks.length) {
+          node.marks.forEach(mark => {
+            if (markType === mark.type) {
+              canReset = true
 
-          if (markType && node.marks.length) {
-            node.marks.forEach(mark => {
-              if (markType === mark.type) {
+              if (dispatch) {
                 tr.addMark(pos, pos + node.nodeSize, markType.create(deleteProps(mark.attrs, attributes)))
               }
-            })
-          }
-        })
+            }
+          })
+        }
       })
-    }
+    })
 
-    return true
+    return canReset
   }

package/src/commands/updateAttributes.ts

@@ -53,45 +53,55 @@ export const updateAttributes: RawCommands['updateAttributes'] =
       markType = getMarkType(typeOrName as MarkType, state.schema)
     }
 
-    if (dispatch) {
-      tr.selection.ranges.forEach((range: SelectionRange) => {
-        const from = range.$from.pos
-        const to = range.$to.pos
-
-        let lastPos: number | undefined
-        let lastNode: Node | undefined
-        let trimmedFrom: number
-        let trimmedTo: number
-
-        if (tr.selection.empty) {
-          state.doc.nodesBetween(from, to, (node: Node, pos: number) => {
+    let canUpdate = false
+
+    tr.selection.ranges.forEach((range: SelectionRange) => {
+      const from = range.$from.pos
+      const to = range.$to.pos
+
+      let lastPos: number | undefined
+      let lastNode: Node | undefined
+      let trimmedFrom: number
+      let trimmedTo: number
+
+      if (tr.selection.empty) {
+        state.doc.nodesBetween(from, to, (node: Node, pos: number) => {
+          if (nodeType && nodeType === node.type) {
+            canUpdate = true
+            trimmedFrom = Math.max(pos, from)
+            trimmedTo = Math.min(pos + node.nodeSize, to)
+            lastPos = pos
+            lastNode = node
+          }
+        })
+      } else {
+        state.doc.nodesBetween(from, to, (node: Node, pos: number) => {
+          if (pos < from && nodeType && nodeType === node.type) {
+            canUpdate = true
+            trimmedFrom = Math.max(pos, from)
+            trimmedTo = Math.min(pos + node.nodeSize, to)
+            lastPos = pos
+            lastNode = node
+          }
+
+          if (pos >= from && pos <= to) {
             if (nodeType && nodeType === node.type) {
-              trimmedFrom = Math.max(pos, from)
-              trimmedTo = Math.min(pos + node.nodeSize, to)
-              lastPos = pos
-              lastNode = node
-            }
-          })
-        } else {
-          state.doc.nodesBetween(from, to, (node: Node, pos: number) => {
-            if (pos < from && nodeType && nodeType === node.type) {
-              trimmedFrom = Math.max(pos, from)
-              trimmedTo = Math.min(pos + node.nodeSize, to)
-              lastPos = pos
-              lastNode = node
-            }
+              canUpdate = true
 
-            if (pos >= from && pos <= to) {
-              if (nodeType && nodeType === node.type) {
+              if (dispatch) {
                 tr.setNodeMarkup(pos, undefined, {
                   ...node.attrs,
                   ...attributes,
                 })
               }
+            }
+
+            if (markType && node.marks.length) {
+              node.marks.forEach((mark: Mark) => {
+                if (markType === mark.type) {
+                  canUpdate = true
 
-              if (markType && node.marks.length) {
-                node.marks.forEach((mark: Mark) => {
-                  if (markType === mark.type) {
+                  if (dispatch) {
                     const trimmedFrom2 = Math.max(pos, from)
                     const trimmedTo2 = Math.min(pos + node.nodeSize, to)
 
@@ -104,37 +114,37 @@ export const updateAttributes: RawCommands['updateAttributes'] =
                       }),
                     )
                   }
-                })
-              }
+                }
+              })
             }
+          }
+        })
+      }
+
+      if (lastNode) {
+        if (lastPos !== undefined && dispatch) {
+          tr.setNodeMarkup(lastPos, undefined, {
+            ...lastNode.attrs,
+            ...attributes,
           })
         }
 
-        if (lastNode) {
-          if (lastPos !== undefined) {
-            tr.setNodeMarkup(lastPos, undefined, {
-              ...lastNode.attrs,
-              ...attributes,
-            })
-          }
-
-          if (markType && lastNode.marks.length) {
-            lastNode.marks.forEach((mark: Mark) => {
-              if (markType === mark.type) {
-                tr.addMark(
-                  trimmedFrom,
-                  trimmedTo,
-                  markType.create({
-                    ...mark.attrs,
-                    ...attributes,
-                  }),
-                )
-              }
-            })
-          }
+        if (markType && lastNode.marks.length) {
+          lastNode.marks.forEach((mark: Mark) => {
+            if (markType === mark.type && dispatch) {
+              tr.addMark(
+                trimmedFrom,
+                trimmedTo,
+                markType.create({
+                  ...mark.attrs,
+                  ...attributes,
+                }),
+              )
+            }
+          })
         }
-      })
-    }
+      }
+    })
 
-    return true
+    return canUpdate
   }

package/src/helpers/getSchemaByResolvedExtensions.ts

@@ -34,8 +34,8 @@ function buildAttributeSpec(
 ): [string, Record<string, any>] {
   const spec: Record<string, any> = {}
 
-  // Only include 'default' if the attribute is not required and default is defined
-  if (!extensionAttribute?.attribute?.isRequired && extensionAttribute?.attribute?.default !== undefined) {
+  // Only include 'default' if the attribute is not required and default is set on the attribute
+  if (!extensionAttribute?.attribute?.isRequired && 'default' in (extensionAttribute?.attribute || {})) {
     spec.default = extensionAttribute.attribute.default
   }
 

package/src/types.ts

@@ -442,17 +442,71 @@ export interface EditorOptions {
 export type HTMLContent = string
 
 /**
- * Loosely describes a JSON representation of a Prosemirror document or node
+ * A Tiptap JSON node or document. Tiptap JSON is the standard format for
+ * storing and manipulating Tiptap content. It is equivalent to the JSON
+ * representation of a Prosemirror node.
+ *
+ * Tiptap JSON documents are trees of nodes. The root node is usually of type
+ * `doc`. Nodes can have other nodes as children. Nodes can also have marks and
+ * attributes. Text nodes (nodes with type `text`) have a `text` property and no
+ * children.
+ *
+ * @example
+ * ```ts
+ * const content: JSONContent = {
+ *   type: 'doc',
+ *   content: [
+ *     {
+ *       type: 'paragraph',
+ *       content: [
+ *         {
+ *           type: 'text',
+ *           text: 'Hello ',
+ *         },
+ *         {
+ *           type: 'text',
+ *           text: 'world',
+ *           marks: [{ type: 'bold' }],
+ *         },
+ *       ],
+ *     },
+ *   ],
+ * }
+ * ```
  */
 export type JSONContent = {
+  /**
+   * The type of the node
+   */
   type?: string
+  /**
+   * The attributes of the node. Attributes can have any JSON-serializable value.
+   */
   attrs?: Record<string, any> | undefined
+  /**
+   * The children of the node. A node can have other nodes as children.
+   */
   content?: JSONContent[]
+  /**
+   * A list of marks of the node. Inline nodes can have marks.
+   */
   marks?: {
+    /**
+     * The type of the mark
+     */
     type: string
+    /**
+     * The attributes of the mark. Attributes can have any JSON-serializable value.
+     */
     attrs?: Record<string, any>
     [key: string]: any
   }[]
+  /**
+   * The text content of the node. This property is only present on text nodes
+   * (i.e. nodes with `type: 'text'`).
+   *
+   * Text nodes cannot have children, but they can have marks.
+   */
   text?: string
   [key: string]: any
 }

package/src/utilities/markdown/parseIndentedBlocks.ts

@@ -103,6 +103,7 @@ export function parseIndentedBlocks(
         break
       } else if (currentLine.trim() === '') {
         i += 1
+        totalRaw = `${totalRaw}${currentLine}\n`
         continue
       } else {
         return undefined
@@ -188,6 +189,6 @@ export function parseIndentedBlocks(
 
   return {
     items,
-    raw: totalRaw.trim(),
+    raw: totalRaw,
   }
 }