@tiptap/core 3.20.1 → 3.20.3

package/package.json

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

package/src/Extendable.ts

@@ -291,6 +291,28 @@ export interface ExtendableConfig<
      * Defines if this markdown element should indent it's child elements
      */
     indentsContent?: boolean
+
+    /**
+     * Lets a mark tell the Markdown serializer which inline HTML tags it can
+     * safely use when plain markdown delimiters would become ambiguous.
+     *
+     * This is mainly useful for overlapping marks. For example, bold followed
+     * by bold+italic followed by italic cannot always be written back with only
+     * `*` and `**` in a way that still parses correctly. In that case, the
+     * serializer can close the overlapping section with markdown and reopen the
+     * remaining tail with HTML instead.
+     *
+     * Example:
+     * - desired formatting: `**123` + `*456*` + `789 italic`
+     * - serialized result: `**123*456***<em>789</em>`
+     *
+     * If your extension defines custom mark names, set `htmlReopen` on that
+     * extension so the serializer can reuse its HTML form for overlap cases.
+     */
+    htmlReopen?: {
+      open: string
+      close: string
+    }
   }
 
   /**

package/src/helpers/isNodeEmpty.ts

@@ -25,7 +25,7 @@ export function isNodeEmpty(
       return true
     }
     if (node.isText) {
-      return /^\s*$/m.test(node.text ?? '')
+      return !/\S/.test(node.text ?? '')
     }
   }
 

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. */
@@ -956,6 +959,10 @@ export interface MarkdownExtensionSpec {
   parseMarkdown?: (token: MarkdownToken, helpers: MarkdownParseHelpers) => MarkdownParseResult
   renderMarkdown?: (node: any, helpers: MarkdownRendererHelpers, ctx: RenderContext) => string
   isIndenting?: boolean
+  htmlReopen?: {
+    open: string
+    close: string
+  }
   /** Custom tokenizer for marked.js to handle non-standard markdown syntax */
   tokenizer?: MarkdownTokenizer
 }
@@ -1004,6 +1011,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
 }