@milkdown/preset-gfm 7.19.0 → 7.19.2

package/src/__test__/table-header-row.spec.ts

@@ -0,0 +1,64 @@
+import '@testing-library/jest-dom/vitest'
+import {
+  defaultValueCtx,
+  Editor,
+  editorViewCtx,
+  schemaCtx,
+  serializerCtx,
+} from '@milkdown/core'
+import { commonmark } from '@milkdown/preset-commonmark'
+import { expect, it } from 'vitest'
+
+import { gfm } from '..'
+
+function createEditor() {
+  const editor = Editor.make()
+  editor.use(commonmark)
+  editor.use(gfm)
+  return editor
+}
+
+it('should not crash when serializing a table with empty header row', async () => {
+  const markdown = `| head |\n| --- |\n| cell |\n`
+  const editor = createEditor()
+  editor.config((ctx) => {
+    ctx.set(defaultValueCtx, markdown)
+  })
+
+  await editor.create()
+
+  const schema = editor.ctx.get(schemaCtx)
+  const serializer = editor.ctx.get(serializerCtx)
+
+  // Create a table with an empty header row (content.size === 0)
+  const tableHeaderRow = schema.nodes.table_header_row!.create()
+  const tableRow = schema.nodes.table_row!.create(null, [
+    schema.nodes.table_cell!.create(
+      null,
+      schema.nodes.paragraph!.create(null, schema.text('cell'))
+    ),
+  ])
+  const table = schema.nodes.table!.create(null, [tableHeaderRow, tableRow])
+  const doc = schema.topNodeType.createAndFill(null, [table])!
+
+  // This should not throw
+  expect(() => serializer(doc)).not.toThrow()
+})
+
+it('should serialize a normal table correctly', async () => {
+  const markdown = `| head |\n| --- |\n| cell |\n`
+  const editor = createEditor()
+  editor.config((ctx) => {
+    ctx.set(defaultValueCtx, markdown)
+  })
+
+  await editor.create()
+
+  const view = editor.ctx.get(editorViewCtx)
+  const serializer = editor.ctx.get(serializerCtx)
+
+  // Serializing the current doc (which has a normal table) should work
+  const result = serializer(view.state.doc)
+  expect(result).toContain('head')
+  expect(result).toContain('cell')
+})

package/src/__test__/vitest.setup.ts

@@ -0,0 +1,65 @@
+// Mock missing DOM APIs that ProseMirror needs but JSDOM doesn't provide
+
+// Mock elementFromPoint
+if (!document.elementFromPoint) {
+  document.elementFromPoint = () => null
+}
+
+// Mock getClientRects for all elements
+Object.defineProperty(Element.prototype, 'getClientRects', {
+  value: function () {
+    return {
+      length: 0,
+      item: () => null,
+      [Symbol.iterator]: function* () {},
+    }
+  },
+})
+
+Object.defineProperty(Element.prototype, 'getBoundingClientRect', {
+  value: function () {
+    return {
+      x: 0,
+      y: 0,
+      width: 0,
+      height: 0,
+      top: 0,
+      right: 0,
+      bottom: 0,
+      left: 0,
+      toJSON: () => ({}),
+    }
+  },
+})
+
+// Mock Range methods
+Object.defineProperty(Range.prototype, 'getClientRects', {
+  value: function () {
+    return {
+      length: 0,
+      item: () => null,
+      [Symbol.iterator]: function* () {},
+    }
+  },
+})
+
+Object.defineProperty(Range.prototype, 'getBoundingClientRect', {
+  value: function () {
+    return {
+      x: 0,
+      y: 0,
+      width: 0,
+      height: 0,
+      top: 0,
+      right: 0,
+      bottom: 0,
+      left: 0,
+      toJSON: () => ({}),
+    }
+  },
+})
+
+// Mock scrollIntoView
+Object.defineProperty(Element.prototype, 'scrollIntoView', {
+  value: function () {},
+})

package/src/node/table/input.ts

@@ -1,7 +1,12 @@
 import { commandsCtx } from '@milkdown/core'
 import { paragraphSchema } from '@milkdown/preset-commonmark'
 import { InputRule } from '@milkdown/prose/inputrules'
-import { Fragment, Slice } from '@milkdown/prose/model'
+import {
+  type Fragment as FragmentType,
+  Fragment,
+  type Node as ProsemirrorNode,
+  Slice,
+} from '@milkdown/prose/model'
 import { TextSelection } from '@milkdown/prose/state'
 import { $inputRule, $pasteRule, $useKeymap } from '@milkdown/utils'
 
@@ -11,7 +16,12 @@ import {
   goToNextTableCellCommand,
   goToPrevTableCellCommand,
 } from './command'
-import { tableHeaderSchema, tableSchema } from './schema'
+import {
+  tableHeaderRowSchema,
+  tableHeaderSchema,
+  tableRowSchema,
+  tableSchema,
+} from './schema'
 import { createTable } from './utils'
 
 /// A input rule for creating table.
@@ -52,35 +62,53 @@ withMeta(insertTableInputRule, {
 /// A paste rule for fixing tables without header cells.
 /// This is a workaround for some editors (e.g. Google Docs) which allow creating tables without header cells,
 /// which is not supported by Markdown schema.
-/// This paste rule will add header cells to the first row if it's missing.
+/// This paste rule will promote the first data row to header, or add empty header cells as a fallback.
 export const tablePasteRule = $pasteRule((ctx) => ({
   run: (slice, _view, isPlainText) => {
     if (isPlainText) {
       return slice
     }
-    let fragment = slice.content
 
-    slice.content.forEach((node, _offset, index) => {
-      if (node?.type !== tableSchema.type(ctx)) {
-        return
-      }
+    function fixTable(node: ProsemirrorNode): ProsemirrorNode {
       const rowsCount = node.childCount
       const colsCount = node.lastChild?.childCount ?? 0
       if (rowsCount === 0 || colsCount === 0) {
-        fragment = fragment.replaceChild(
-          index,
-          paragraphSchema.type(ctx).create()
-        )
-        return
+        return paragraphSchema.type(ctx).create()
       }
 
       const headerRow = node.firstChild
       const needToFixHeaderRow =
         colsCount > 0 && headerRow && headerRow.childCount === 0
       if (!needToFixHeaderRow) {
-        return
+        return node
       }
-      // Fix for tables with rows but no cells in the first row
+
+      // If there are 2+ data rows (3+ total: empty header + 2+ data rows),
+      // promote the first data row to header
+      if (rowsCount >= 3) {
+        const firstDataRow = node.child(1)
+        const headerCells: ProsemirrorNode[] = []
+        for (let i = 0; i < firstDataRow.childCount; i++) {
+          const cell = firstDataRow.child(i)
+          headerCells.push(
+            tableHeaderSchema
+              .type(ctx)
+              .create(cell.attrs, cell.content, cell.marks)
+          )
+        }
+        const newHeaderRow = headerRow.type.create(headerRow.attrs, headerCells)
+
+        // Collect remaining data rows (skip promoted row at index 1)
+        const remainingRows: ProsemirrorNode[] = []
+        for (let i = 2; i < rowsCount; i++) {
+          remainingRows.push(node.child(i))
+        }
+
+        return node.type.create(node.attrs, [newHeaderRow, ...remainingRows])
+      }
+
+      // Fallback: only 1 data row, can't promote (would leave 0 data rows).
+      // Fill the empty header with blank cells.
       const headerCells = Array(colsCount)
         .fill(0)
         .map(() => tableHeaderSchema.type(ctx).createAndFill()!)
@@ -93,9 +121,97 @@ export const tablePasteRule = $pasteRule((ctx) => ({
         headerRow.nodeSize,
         new Slice(Fragment.from(newHeaderRow), 0, 0)
       )
-      fragment = fragment.replaceChild(index, newTable)
-    })
+      return newTable
+    }
+
+    // Wrap consecutive orphaned table_row nodes (at the top level of a fragment)
+    // into a proper table. This happens when ProseMirror's parseSlice breaks
+    // a table apart (e.g. when pasting multiple tables from Google Docs).
+    function wrapOrphanedRows(fragment: FragmentType): FragmentType {
+      const rowType = tableRowSchema.type(ctx)
+      const nodes: ProsemirrorNode[] = []
+      let pendingRows: ProsemirrorNode[] = []
+      let hasOrphans = false
+
+      function flushPendingRows() {
+        if (pendingRows.length === 0) return
+
+        // Create an empty table_header_row, then fixTable will promote the first data row
+        const emptyHeaderRow = tableHeaderRowSchema.type(ctx).createAndFill()!
+        const table = tableSchema
+          .type(ctx)
+          .create(null, [emptyHeaderRow, ...pendingRows])
+        nodes.push(fixTable(table))
+        pendingRows = []
+      }
+
+      fragment.forEach((node) => {
+        if (node.type === rowType) {
+          hasOrphans = true
+          pendingRows.push(node)
+        } else {
+          flushPendingRows()
+          nodes.push(node)
+        }
+      })
+      flushPendingRows()
+
+      return hasOrphans ? Fragment.from(nodes) : fragment
+    }
+
+    function fixFragment(fragment: FragmentType): FragmentType {
+      // First, wrap any orphaned table_row nodes into tables
+      let result = wrapOrphanedRows(fragment)
+
+      // Then fix existing tables and recurse into children
+      let changed = result !== fragment
+      const fixed: ProsemirrorNode[] = []
+      result.forEach((node) => {
+        if (node.type === tableSchema.type(ctx)) {
+          const fixedNode = fixTable(node)
+          if (fixedNode !== node) changed = true
+          fixed.push(fixedNode)
+        } else if (node.childCount > 0) {
+          const fixedContent = fixFragment(node.content)
+          if (fixedContent !== node.content) {
+            changed = true
+            fixed.push(node.copy(fixedContent))
+          } else {
+            fixed.push(node)
+          }
+        } else {
+          fixed.push(node)
+        }
+      })
+      return changed ? Fragment.from(fixed) : fragment
+    }
+
+    // Remove empty paragraphs that directly precede a table
+    // (artifacts of broken table parsing from Google Docs)
+    function cleanEmptyParagraphs(fragment: FragmentType): FragmentType {
+      const nodes: ProsemirrorNode[] = []
+      const allNodes: ProsemirrorNode[] = []
+      fragment.forEach((node) => allNodes.push(node))
+
+      for (let i = 0; i < allNodes.length; i++) {
+        const node = allNodes[i]!
+        const next = allNodes[i + 1]
+        if (
+          node.type === paragraphSchema.type(ctx) &&
+          node.content.size === 0 &&
+          next &&
+          next.type === tableSchema.type(ctx)
+        ) {
+          continue // skip empty paragraph before table
+        }
+        nodes.push(node)
+      }
+
+      return nodes.length < allNodes.length ? Fragment.from(nodes) : fragment
+    }
 
+    let fragment = fixFragment(slice.content)
+    fragment = cleanEmptyParagraphs(fragment)
     return new Slice(Fragment.from(fragment), slice.openStart, slice.openEnd)
   },
 }))

package/src/node/table/schema.ts

@@ -104,6 +104,11 @@ export const tableHeaderRowSchema = $nodeSchema('table_header_row', () => ({
   toMarkdown: {
     match: (node) => node.type.name === 'table_header_row',
     runner: (state, node) => {
+      // if the row is empty, we don't need to create a table row
+      // prevent remark from crashing
+      if (node.content.size === 0) {
+        return
+      }
       state.openNode('tableRow', undefined, { isHeader: true })
       state.next(node.content)
       state.closeNode()