@thomasjahoda-forks/tiptap-extension-list 3.0.8 → 3.18.0-1

package/src/ordered-list/utils.ts

@@ -0,0 +1,234 @@
+import type { JSONContent, MarkdownLexerConfiguration, MarkdownParseHelpers, MarkdownToken } from '@tiptap/core'
+
+/**
+ * Matches an ordered list item line with optional leading whitespace.
+ * Captures: (1) indentation spaces, (2) item number, (3) content after marker
+ * Example matches: "1. Item", "  2. Nested item", "    3. Deeply nested"
+ */
+const ORDERED_LIST_ITEM_REGEX = /^(\s*)(\d+)\.\s+(.*)$/
+
+/**
+ * Matches any line that starts with whitespace (indented content).
+ * Used to identify continuation content that belongs to a list item.
+ */
+const INDENTED_LINE_REGEX = /^\s/
+
+/**
+ * Represents a parsed ordered list item with indentation information
+ */
+export interface OrderedListItem {
+  indent: number
+  number: number
+  content: string
+  raw: string
+}
+
+/**
+ * Collects all ordered list items from lines, parsing them into a flat array
+ * with indentation information. Stops collecting continuation content when
+ * encountering nested list items, allowing them to be processed separately.
+ *
+ * @param lines - Array of source lines to parse
+ * @returns Tuple of [listItems array, number of lines consumed]
+ */
+export function collectOrderedListItems(lines: string[]): [OrderedListItem[], number] {
+  const listItems: OrderedListItem[] = []
+  let currentLineIndex = 0
+  let consumed = 0
+
+  while (currentLineIndex < lines.length) {
+    const line = lines[currentLineIndex]
+    const match = line.match(ORDERED_LIST_ITEM_REGEX)
+
+    if (!match) {
+      break
+    }
+
+    const [, indent, number, content] = match
+    const indentLevel = indent.length
+    let itemContent = content
+    let nextLineIndex = currentLineIndex + 1
+    const itemLines = [line]
+
+    // Collect continuation lines for this item (but NOT nested list items)
+    while (nextLineIndex < lines.length) {
+      const nextLine = lines[nextLineIndex]
+      const nextMatch = nextLine.match(ORDERED_LIST_ITEM_REGEX)
+
+      // If it's another list item (nested or not), stop collecting
+      if (nextMatch) {
+        break
+      }
+
+      // Check for continuation content (non-list content)
+      if (nextLine.trim() === '') {
+        // Empty line
+        itemLines.push(nextLine)
+        itemContent += '\n'
+        nextLineIndex += 1
+      } else if (nextLine.match(INDENTED_LINE_REGEX)) {
+        // Indented content - part of this item (but not a list item)
+        itemLines.push(nextLine)
+        itemContent += `\n${nextLine.slice(indentLevel + 2)}` // Remove list marker indent
+        nextLineIndex += 1
+      } else {
+        // Non-indented line means end of list
+        break
+      }
+    }
+
+    listItems.push({
+      indent: indentLevel,
+      number: parseInt(number, 10),
+      content: itemContent.trim(),
+      raw: itemLines.join('\n'),
+    })
+
+    consumed = nextLineIndex
+    currentLineIndex = nextLineIndex
+  }
+
+  return [listItems, consumed]
+}
+
+/**
+ * Recursively builds a nested structure from a flat array of list items
+ * based on their indentation levels. Creates proper markdown tokens with
+ * nested lists where appropriate.
+ *
+ * @param items - Flat array of list items with indentation info
+ * @param baseIndent - The indentation level to process at this recursion level
+ * @param lexer - Markdown lexer for parsing inline and block content
+ * @returns Array of list_item tokens with proper nesting
+ */
+export function buildNestedStructure(
+  items: OrderedListItem[],
+  baseIndent: number,
+  lexer: MarkdownLexerConfiguration,
+): unknown[] {
+  const result: unknown[] = []
+  let currentIndex = 0
+
+  while (currentIndex < items.length) {
+    const item = items[currentIndex]
+
+    if (item.indent === baseIndent) {
+      // This item belongs at the current level
+      const contentLines = item.content.split('\n')
+      const mainText = contentLines[0]?.trim() || ''
+
+      const tokens = []
+
+      // Always wrap the main text in a paragraph token
+      if (mainText) {
+        tokens.push({
+          type: 'paragraph',
+          raw: mainText,
+          tokens: lexer.inlineTokens(mainText),
+        })
+      }
+
+      // Handle additional content after the main text
+      const additionalContent = contentLines.slice(1).join('\n').trim()
+      if (additionalContent) {
+        // Parse as block tokens (handles mixed unordered lists, etc.)
+        const blockTokens = lexer.blockTokens(additionalContent)
+        tokens.push(...blockTokens)
+      }
+
+      // Look ahead to find nested items at deeper indent levels
+      let lookAheadIndex = currentIndex + 1
+      const nestedItems = []
+
+      while (lookAheadIndex < items.length && items[lookAheadIndex].indent > baseIndent) {
+        nestedItems.push(items[lookAheadIndex])
+        lookAheadIndex += 1
+      }
+
+      // If we have nested items, recursively build their structure
+      if (nestedItems.length > 0) {
+        // Find the next indent level (immediate children)
+        const nextIndent = Math.min(...nestedItems.map(nestedItem => nestedItem.indent))
+
+        // Build the nested list recursively with all nested items
+        // The recursive call will handle further nesting
+        const nestedListItems = buildNestedStructure(nestedItems, nextIndent, lexer)
+
+        // Create a nested list token
+        tokens.push({
+          type: 'list',
+          ordered: true,
+          start: nestedItems[0].number,
+          items: nestedListItems,
+          raw: nestedItems.map(nestedItem => nestedItem.raw).join('\n'),
+        })
+      }
+
+      result.push({
+        type: 'list_item',
+        raw: item.raw,
+        tokens,
+      })
+
+      // Skip the nested items we just processed
+      currentIndex = lookAheadIndex
+    } else {
+      // This item has deeper indent than we're currently processing
+      // It should be handled by a recursive call
+      currentIndex += 1
+    }
+  }
+
+  return result
+}
+
+/**
+ * Parses markdown list item tokens into Tiptap JSONContent structure,
+ * ensuring text content is properly wrapped in paragraph nodes.
+ *
+ * @param items - Array of markdown tokens representing list items
+ * @param helpers - Markdown parse helpers for recursive parsing
+ * @returns Array of listItem JSONContent nodes
+ */
+export function parseListItems(items: MarkdownToken[], helpers: MarkdownParseHelpers): JSONContent[] {
+  return items.map(item => {
+    if (item.type !== 'list_item') {
+      return helpers.parseChildren([item])[0]
+    }
+
+    // Parse the tokens within the list item
+    const content: JSONContent[] = []
+
+    if (item.tokens && item.tokens.length > 0) {
+      item.tokens.forEach(itemToken => {
+        // If it's already a proper block node (paragraph, list, etc.), parse it directly
+        if (
+          itemToken.type === 'paragraph' ||
+          itemToken.type === 'list' ||
+          itemToken.type === 'blockquote' ||
+          itemToken.type === 'code'
+        ) {
+          content.push(...helpers.parseChildren([itemToken]))
+        } else if (itemToken.type === 'text' && itemToken.tokens) {
+          // If it's inline text tokens, wrap them in a paragraph
+          const inlineContent = helpers.parseChildren([itemToken])
+          content.push({
+            type: 'paragraph',
+            content: inlineContent,
+          })
+        } else {
+          // For any other content, try to parse it
+          const parsed = helpers.parseChildren([itemToken])
+          if (parsed.length > 0) {
+            content.push(...parsed)
+          }
+        }
+      })
+    }
+
+    return {
+      type: 'listItem',
+      content,
+    }
+  })
+}

package/src/task-item/task-item.ts

@@ -1,5 +1,11 @@
 import type { KeyboardShortcutCommand } from '@tiptap/core'
-import { mergeAttributes, Node, wrappingInputRule } from '@tiptap/core'
+import {
+  getRenderedAttributes,
+  mergeAttributes,
+  Node,
+  renderNestedMarkdownContent,
+  wrappingInputRule,
+} from '@tiptap/core'
 import type { Node as ProseMirrorNode } from '@tiptap/pm/model'
 
 export interface TaskItemOptions {
@@ -120,6 +126,38 @@ export const TaskItem = Node.create<TaskItemOptions>({
     ]
   },
 
+  parseMarkdown: (token, h) => {
+    // Parse the task item's text content into paragraph content
+    const content = []
+
+    // First, add the main paragraph content
+    if (token.tokens && token.tokens.length > 0) {
+      // If we have tokens, create a paragraph with the inline content
+      content.push(h.createNode('paragraph', {}, h.parseInline(token.tokens)))
+    } else if (token.text) {
+      // If we have raw text, create a paragraph with text node
+      content.push(h.createNode('paragraph', {}, [h.createNode('text', { text: token.text })]))
+    } else {
+      // Fallback: empty paragraph
+      content.push(h.createNode('paragraph', {}, []))
+    }
+
+    // Then, add any nested content (like nested task lists)
+    if (token.nestedTokens && token.nestedTokens.length > 0) {
+      const nestedContent = h.parseChildren(token.nestedTokens)
+      content.push(...nestedContent)
+    }
+
+    return h.createNode('taskItem', { checked: token.checked || false }, content)
+  },
+
+  renderMarkdown: (node, h) => {
+    const checkedChar = node.attrs?.checked ? 'x' : ' '
+    const prefix = `- [${checkedChar}] `
+
+    return renderNestedMarkdownContent(node, h, prefix)
+  },
+
   addKeyboardShortcuts() {
     const shortcuts: {
       [key: string]: KeyboardShortcutCommand
@@ -146,16 +184,17 @@ export const TaskItem = Node.create<TaskItemOptions>({
       const checkbox = document.createElement('input')
       const content = document.createElement('div')
 
-      const updateA11Y = () => {
+      const updateA11Y = (currentNode: ProseMirrorNode) => {
         checkbox.ariaLabel =
-          this.options.a11y?.checkboxLabel?.(node, checkbox.checked) ||
-          `Task item checkbox for ${node.textContent || 'empty task item'}`
+          this.options.a11y?.checkboxLabel?.(currentNode, checkbox.checked) ||
+          `Task item checkbox for ${currentNode.textContent || 'empty task item'}`
       }
 
-      updateA11Y()
+      updateA11Y(node)
 
       checkboxWrapper.contentEditable = 'false'
       checkbox.type = 'checkbox'
+      checkbox.contentEditable = 'false' // TODO test whether this may help with mobile stuff
       checkbox.addEventListener('mousedown', event => event.preventDefault())
       checkbox.addEventListener('change', event => {
         // if the editor isn’t editable and we don't have a handler for
@@ -220,6 +259,7 @@ export const TaskItem = Node.create<TaskItemOptions>({
         }
       })
 
+      // TODO get changes from upstream regarding updating attributes properly so attributes may be removed
       Object.entries(this.options.HTMLAttributes).forEach(([key, value]) => {
         listItem.setAttribute(key, value)
       })
@@ -234,6 +274,9 @@ export const TaskItem = Node.create<TaskItemOptions>({
         listItem.setAttribute(key, value)
       })
 
+      // Track the keys of previously rendered HTML attributes for proper removal
+      let prevRenderedAttributeKeys = new Set(Object.keys(HTMLAttributes))
+
       return {
         dom: listItem,
         contentDOM: content,
@@ -244,7 +287,43 @@ export const TaskItem = Node.create<TaskItemOptions>({
 
           listItem.dataset.checked = updatedNode.attrs.checked
           checkbox.checked = updatedNode.attrs.checked
-          updateA11Y()
+          updateA11Y(updatedNode)
+
+          // Sync all HTML attributes from the updated node
+          const extensionAttributes = editor.extensionManager.attributes
+          const newHTMLAttributes = getRenderedAttributes(updatedNode, extensionAttributes)
+          const newKeys = new Set(Object.keys(newHTMLAttributes))
+
+          // Remove attributes that were previously rendered but are no longer present
+          // If the attribute exists in static options, restore it instead of removing
+          const staticAttrs = this.options.HTMLAttributes
+
+          prevRenderedAttributeKeys.forEach(key => {
+            if (!newKeys.has(key)) {
+              if (key in staticAttrs) {
+                listItem.setAttribute(key, staticAttrs[key])
+              } else {
+                listItem.removeAttribute(key)
+              }
+            }
+          })
+
+          // Update or add new attributes
+          Object.entries(newHTMLAttributes).forEach(([key, value]) => {
+            if (value === null || value === undefined) {
+              // If the attribute exists in static options, restore it instead of removing
+              if (key in staticAttrs) {
+                listItem.setAttribute(key, staticAttrs[key])
+              } else {
+                listItem.removeAttribute(key)
+              }
+            } else {
+              listItem.setAttribute(key, value)
+            }
+          })
+
+          // Update the tracked keys for next update
+          prevRenderedAttributeKeys = newKeys
 
           return true
         },

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: