@tiptap/extension-list 3.6.6 → 3.7.0

package/src/task-list/task-list.ts

@@ -1,4 +1,4 @@
-import { mergeAttributes, Node } from '@tiptap/core'
+import { mergeAttributes, Node, parseIndentedBlocks } from '@tiptap/core'
 
 export interface TaskListOptions {
   /**
@@ -61,6 +61,110 @@ export const TaskList = Node.create<TaskListOptions>({
     return ['ul', mergeAttributes(this.options.HTMLAttributes, HTMLAttributes, { 'data-type': this.name }), 0]
   },
 
+  parseMarkdown: (token, h) => {
+    return h.createNode('taskList', {}, h.parseChildren(token.items || []))
+  },
+
+  renderMarkdown: (node, h) => {
+    if (!node.content) {
+      return ''
+    }
+
+    return h.renderChildren(node.content, '\n')
+  },
+
+  markdownTokenizer: {
+    name: 'taskList',
+    level: 'block',
+    start(src) {
+      // Look for the start of a task list item
+      const index = src.match(/^\s*[-+*]\s+\[([ xX])\]\s+/)?.index
+      return index !== undefined ? index : -1
+    },
+    tokenize(src, tokens, lexer) {
+      // Helper function to recursively parse task lists
+      const parseTaskListContent = (content: string): any[] | undefined => {
+        const nestedResult = parseIndentedBlocks(
+          content,
+          {
+            itemPattern: /^(\s*)([-+*])\s+\[([ xX])\]\s+(.*)$/,
+            extractItemData: match => ({
+              indentLevel: match[1].length,
+              mainContent: match[4],
+              checked: match[3].toLowerCase() === 'x',
+            }),
+            createToken: (data, nestedTokens) => ({
+              type: 'taskItem',
+              raw: '',
+              mainContent: data.mainContent,
+              indentLevel: data.indentLevel,
+              checked: data.checked,
+              text: data.mainContent,
+              tokens: lexer.inlineTokens(data.mainContent),
+              nestedTokens,
+            }),
+            // Allow recursive nesting
+            customNestedParser: parseTaskListContent,
+          },
+          lexer,
+        )
+
+        if (nestedResult) {
+          // Return as task list token
+          return [
+            {
+              type: 'taskList',
+              raw: nestedResult.raw,
+              items: nestedResult.items,
+            },
+          ]
+        }
+
+        // Fall back to regular markdown parsing if not a task list
+        return lexer.blockTokens(content)
+      }
+
+      const result = parseIndentedBlocks(
+        src,
+        {
+          itemPattern: /^(\s*)([-+*])\s+\[([ xX])\]\s+(.*)$/,
+          extractItemData: match => ({
+            indentLevel: match[1].length,
+            mainContent: match[4],
+            checked: match[3].toLowerCase() === 'x',
+          }),
+          createToken: (data, nestedTokens) => ({
+            type: 'taskItem',
+            raw: '',
+            mainContent: data.mainContent,
+            indentLevel: data.indentLevel,
+            checked: data.checked,
+            text: data.mainContent,
+            tokens: lexer.inlineTokens(data.mainContent),
+            nestedTokens,
+          }),
+          // Use the recursive parser for nested content
+          customNestedParser: parseTaskListContent,
+        },
+        lexer,
+      )
+
+      if (!result) {
+        return undefined
+      }
+
+      return {
+        type: 'taskList',
+        raw: result.raw,
+        items: result.items,
+      }
+    },
+  },
+
+  markdownOptions: {
+    indentsContent: true,
+  },
+
   addCommands() {
     return {
       toggleTaskList: