@tiptap/core 3.20.0 → 3.20.2

package/package.json

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

package/src/types.ts

@@ -898,6 +898,8 @@ export type MarkdownParseHelpers = {
   parseInline: (tokens: MarkdownToken[]) => JSONContent[]
   /** Parse an array of block-level tokens */
   parseChildren: (tokens: MarkdownToken[]) => JSONContent[]
+  /** Parse block-level tokens while preserving implicit empty paragraphs from blank lines */
+  parseBlockChildren?: (tokens: MarkdownToken[]) => JSONContent[]
   /** Create a text node with optional marks */
   createTextNode: (text: string, marks?: Array<{ type: string; attrs?: any }>) => JSONContent
   /** Create any node type with attributes and content */
@@ -945,6 +947,7 @@ export type RenderContext = {
   level: number
   meta?: Record<string, any>
   parentType?: string | null
+  previousNode?: JSONContent | null
 }
 
 /** Extension contract for markdown parsing/serialization. */
@@ -1004,6 +1007,9 @@ export type MarkdownRendererHelpers = {
    */
   renderChildren: (nodes: JSONContent | JSONContent[], separator?: string) => string
 
+  /** Render a single child node with its sibling index preserved */
+  renderChild?: (node: JSONContent, index: number) => string
+
   /**
    * Render a text token to a markdown string
    * @param prefix The prefix to add before the content

package/src/utilities/markdown/renderNestedMarkdownContent.ts

@@ -57,6 +57,7 @@ export function renderNestedMarkdownContent(
   node: JSONContent,
   h: {
     renderChildren: (nodes: JSONContent[]) => string
+    renderChild?: (node: JSONContent, index: number) => string
     indent: (text: string) => string
   },
   prefixOrGenerator: string | ((ctx: any) => string),
@@ -73,22 +74,23 @@ export function renderNestedMarkdownContent(
 
   // Render the main content (typically a paragraph)
   const mainContent = h.renderChildren([content])
-  const output = [`${prefix}${mainContent}`]
+  let output = `${prefix}${mainContent}`
 
   // Handle nested children with proper indentation
   if (children && children.length > 0) {
-    children.forEach(child => {
-      const childContent = h.renderChildren([child])
-      if (childContent) {
+    children.forEach((child, index) => {
+      const childContent = h.renderChild?.(child, index + 1) ?? h.renderChildren([child])
+      if (childContent !== undefined && childContent !== null) {
         // Split the child content by lines and indent each line
         const indentedChild = childContent
           .split('\n')
-          .map(line => (line ? h.indent(line) : ''))
+          .map(line => (line ? h.indent(line) : h.indent('')))
           .join('\n')
-        output.push(indentedChild)
+
+        output += child.type === 'paragraph' ? `\n\n${indentedChild}` : `\n${indentedChild}`
       }
     })
   }
 
-  return output.join('\n')
+  return output
 }

package/src/utilities/mergeAttributes.ts

@@ -1,3 +1,76 @@
+/** Splits a CSS style string into declarations, ignoring semicolons inside quotes/parentheses. */
+function splitStyleDeclarations(styles: string): string[] {
+  const result: string[] = []
+
+  let current = ''
+  let inSingleQuote = false
+  let inDoubleQuote = false
+  let parenDepth = 0
+
+  const length = styles.length
+  for (let i = 0; i < length; i += 1) {
+    const char = styles[i]
+    if (char === "'" && !inDoubleQuote) {
+      inSingleQuote = !inSingleQuote
+      current += char
+      continue
+    }
+    if (char === '"' && !inSingleQuote) {
+      inDoubleQuote = !inDoubleQuote
+      current += char
+      continue
+    }
+    if (!inSingleQuote && !inDoubleQuote) {
+      if (char === '(') {
+        parenDepth += 1
+        current += char
+        continue
+      }
+      if (char === ')' && parenDepth > 0) {
+        parenDepth -= 1
+        current += char
+        continue
+      }
+      if (char === ';' && parenDepth === 0) {
+        result.push(current)
+        current = ''
+        continue
+      }
+    }
+    current += char
+  }
+  if (current) {
+    result.push(current)
+  }
+
+  return result
+}
+
+/** Yields property/value pairs from a style string. */
+function parseStyleEntries(styles: string | undefined): [property: string, value: string][] {
+  const pairs: [string, string][] = []
+
+  const declarations = splitStyleDeclarations(styles || '')
+  const numDeclarations = declarations.length
+
+  for (let i = 0; i < numDeclarations; i += 1) {
+    const declaration = declarations[i]
+
+    const firstColonIndex = declaration.indexOf(':')
+    if (firstColonIndex === -1) {
+      continue
+    }
+
+    const property = declaration.slice(0, firstColonIndex).trim()
+    const value = declaration.slice(firstColonIndex + 1).trim()
+    if (property && value) {
+      pairs.push([property, value])
+    }
+  }
+
+  return pairs
+}
+
 export function mergeAttributes(...objects: Record<string, any>[]): Record<string, any> {
   return objects
     .filter(item => !!item)
@@ -21,32 +94,7 @@ export function mergeAttributes(...objects: Record<string, any>[]): Record<strin
 
           mergedAttributes[key] = [...existingClasses, ...insertClasses].join(' ')
         } else if (key === 'style') {
-          const newStyles: string[] = value
-            ? value
-                .split(';')
-                .map((style: string) => style.trim())
-                .filter(Boolean)
-            : []
-          const existingStyles: string[] = mergedAttributes[key]
-            ? mergedAttributes[key]
-                .split(';')
-                .map((style: string) => style.trim())
-                .filter(Boolean)
-            : []
-
-          const styleMap = new Map<string, string>()
-
-          existingStyles.forEach(style => {
-            const [property, val] = style.split(':').map(part => part.trim())
-
-            styleMap.set(property, val)
-          })
-
-          newStyles.forEach(style => {
-            const [property, val] = style.split(':').map(part => part.trim())
-
-            styleMap.set(property, val)
-          })
+          const styleMap = new Map([...parseStyleEntries(mergedAttributes[key]), ...parseStyleEntries(value)])
 
           mergedAttributes[key] = Array.from(styleMap.entries())
             .map(([property, val]) => `${property}: ${val}`)