Fix support for passing just a table row, cell

Author: wooorm

lib/handlers/index.js

@@ -18,6 +18,8 @@ import {paragraph} from './paragraph.js'
 import {root} from './root.js'
 import {strong} from './strong.js'
 import {table} from './table.js'
+import {tableRow} from './table-row.js'
+import {tableCell} from './table-cell.js'
 import {text} from './text.js'
 import {thematicBreak} from './thematic-break.js'
 
@@ -42,6 +44,8 @@ export const handlers = {
   root,
   strong,
   table,
+  tableCell,
+  tableRow,
   text,
   thematicBreak,
   toml: ignore,

lib/handlers/list-item.js

@@ -3,7 +3,6 @@
  * @typedef {import('hast').ElementContent} ElementContent
  * @typedef {import('hast').Properties} Properties
  * @typedef {import('mdast').Content} Content
- * @typedef {import('mdast').List} List
  * @typedef {import('mdast').ListItem} ListItem
  * @typedef {import('mdast').Parent} Parent
  * @typedef {import('mdast').Root} Root

lib/handlers/table-cell.js

@@ -0,0 +1,31 @@
+/**
+ * @typedef {import('hast').Element} Element
+ * @typedef {import('mdast').TableCell} TableCell
+ * @typedef {import('../index.js').H} H
+ */
+
+import {all} from '../traverse.js'
+
+/**
+ * Turn an mdast `tableCell` node into hast.
+ *
+ * @param {H} h
+ *   Info passed around.
+ * @param {TableCell} node
+ *   mdast node.
+ * @returns {Element}
+ *   hast node.
+ */
+export function tableCell(h, node) {
+  // Note: this function is normally not called: see `table-row` for how rows
+  // and their cells are compiled.
+  /** @type {Element} */
+  const result = {
+    type: 'element',
+    tagName: 'td', // Assume body cell.
+    properties: {},
+    children: all(h, node)
+  }
+  h.patch(node, result)
+  return h.applyData(node, result)
+}

lib/handlers/table-row.js

@@ -0,0 +1,75 @@
+/**
+ * @typedef {import('hast').Properties} Properties
+ * @typedef {import('hast').Element} Element
+ * @typedef {import('hast').ElementContent} ElementContent
+ * @typedef {import('mdast').Content} Content
+ * @typedef {import('mdast').Parent} Parent
+ * @typedef {import('mdast').Root} Root
+ * @typedef {import('mdast').TableRow} TableRow
+ * @typedef {import('../index.js').H} H
+ */
+
+/**
+ * @typedef {Root | Content} Nodes
+ * @typedef {Extract<Nodes, Parent>} Parents
+ */
+
+import {wrap} from '../wrap.js'
+import {all} from '../traverse.js'
+
+/**
+ * Turn an mdast `tableRow` node into hast.
+ *
+ * @param {H} h
+ *   Info passed around.
+ * @param {TableRow} node
+ *   mdast node.
+ * @param {Parents | null | undefined} parent
+ *   Parent of `node`.
+ * @returns {Element}
+ *   hast node.
+ */
+export function tableRow(h, node, parent) {
+  const siblings = parent ? parent.children : undefined
+  // Generate a body row when without parent.
+  const rowIndex = siblings ? siblings.indexOf(node) : 1
+  const tagName = rowIndex === 0 ? 'th' : 'td'
+  const align = parent && parent.type === 'table' ? parent.align : undefined
+  const length = align ? align.length : node.children.length
+  let cellIndex = -1
+  /** @type {Array<ElementContent>} */
+  const cells = []
+
+  while (++cellIndex < length) {
+    // Note: can also be undefined.
+    const cell = node.children[cellIndex]
+    /** @type {Properties} */
+    const properties = {}
+    const alignValue = align ? align[cellIndex] : undefined
+
+    if (alignValue) {
+      properties.align = alignValue
+    }
+
+    /** @type {Element} */
+    let result = {type: 'element', tagName, properties, children: []}
+
+    if (cell) {
+      result.children = all(h, cell)
+      h.patch(cell, result)
+      result = h.applyData(node, result)
+    }
+
+    cells.push(result)
+  }
+
+  /** @type {Element} */
+  const result = {
+    type: 'element',
+    tagName: 'tr',
+    properties: {},
+    children: wrap(cells, true)
+  }
+  h.patch(node, result)
+  return h.applyData(node, result)
+}

lib/handlers/table.js

@@ -1,8 +1,6 @@
 /**
  * @typedef {import('hast').Element} Element
- * @typedef {import('hast').ElementContent} ElementContent
  * @typedef {import('mdast').Table} Table
- * @typedef {import('mdast').TableCell} TableCell
  * @typedef {import('../index.js').H} H
  */
 
@@ -21,78 +19,35 @@ import {all} from '../traverse.js'
  *   hast node.
  */
 export function table(h, node) {
-  let index = -1
-  const align = node.align || []
+  const rows = all(h, node)
+  const firstRow = rows.shift()
   /** @type {Array<Element>} */
-  const rows = []
-
-  while (++index < node.children.length) {
-    const row = node.children[index]
-    const tagName = index === 0 ? 'th' : 'td'
-    const length = node.align ? align.length : row.children.length
-    let cellIndex = -1
-    /** @type {Array<ElementContent>} */
-    const cells = []
-
-    while (++cellIndex < length) {
-      // Note: can also be undefined.
-      const cell = row.children[cellIndex]
-
-      /** @type {Element} */
-      let result = {
-        type: 'element',
-        tagName,
-        properties: {align: align[cellIndex]},
-        children: []
-      }
-
-      if (cell) {
-        result.children = all(h, cell)
-        h.patch(cell, result)
-        result = h.applyData(node, result)
-      }
-
-      cells.push(result)
-    }
+  const tableContent = []
 
+  if (firstRow) {
     /** @type {Element} */
-    const result = {
+    const head = {
       type: 'element',
-      tagName: 'tr',
+      tagName: 'thead',
       properties: {},
-      children: wrap(cells, true)
+      children: wrap([firstRow], true)
     }
-    h.patch(row, result)
-    rows.push(h.applyData(row, result))
-  }
-
-  // Always one row:
-  /** @type {Element} */
-  const head = {
-    type: 'element',
-    tagName: 'thead',
-    properties: {},
-    children: wrap([rows[0]], true)
+    h.patch(node.children[0], head)
+    tableContent.push(head)
   }
-  h.patch(node.children[0], head)
 
-  const tableContent = [head]
-
-  if (rows.length > 1) {
+  if (rows.length > 0) {
     /** @type {Element} */
     const body = {
       type: 'element',
       tagName: 'tbody',
       properties: {},
-      children: wrap(rows.slice(1), true)
+      children: wrap(rows, true)
     }
 
     const start = pointStart(node.children[1])
     const end = pointEnd(node.children[node.children.length - 1])
-    if (start.line && end.line) {
-      body.position = {start, end}
-    }
-
+    if (start.line && end.line) body.position = {start, end}
     tableContent.push(body)
   }
 

test/table.js

@@ -78,13 +78,9 @@ test('Table', (t) => {
         u('text', '\n'),
         u('element', {tagName: 'tr', properties: {}}, [
           u('text', '\n'),
-          u('element', {tagName: 'th', properties: {align: undefined}}, [
-            u('text', 'a')
-          ]),
+          u('element', {tagName: 'th', properties: {}}, [u('text', 'a')]),
           u('text', '\n'),
-          u('element', {tagName: 'th', properties: {align: undefined}}, [
-            u('text', 'b')
-          ]),
+          u('element', {tagName: 'th', properties: {}}, [u('text', 'b')]),
           u('text', '\n')
         ]),
         u('text', '\n')
@@ -94,5 +90,77 @@ test('Table', (t) => {
     'should not add a `tbody` if w/o second row'
   )
 
+  t.deepEqual(
+    toHast({type: 'table', children: []}),
+    {
+      type: 'element',
+      tagName: 'table',
+      properties: {},
+      children: [{type: 'text', value: '\n'}]
+    },
+    'should handle a table node w/o rows'
+  )
+
+  t.deepEqual(
+    toHast({
+      type: 'tableRow',
+      children: [
+        {type: 'tableCell', children: [{type: 'text', value: 'a'}]},
+        {type: 'tableCell', children: [{type: 'text', value: 'b'}]}
+      ]
+    }),
+    {
+      type: 'element',
+      tagName: 'tr',
+      properties: {},
+      children: [
+        {type: 'text', value: '\n'},
+        {
+          type: 'element',
+          tagName: 'td',
+          properties: {},
+          children: [{type: 'text', value: 'a'}]
+        },
+        {type: 'text', value: '\n'},
+        {
+          type: 'element',
+          tagName: 'td',
+          properties: {},
+          children: [{type: 'text', value: 'b'}]
+        },
+        {type: 'text', value: '\n'}
+      ]
+    },
+    'should handle a table row node w/ cells'
+  )
+
+  t.deepEqual(
+    toHast({type: 'tableRow', children: []}),
+    {
+      type: 'element',
+      tagName: 'tr',
+      properties: {},
+      children: [{type: 'text', value: '\n'}]
+    },
+    'should handle a table row node w/o cells'
+  )
+
+  t.deepEqual(
+    toHast({type: 'tableCell', children: [{type: 'text', value: 'a'}]}),
+    {
+      type: 'element',
+      tagName: 'td',
+      properties: {},
+      children: [{type: 'text', value: 'a'}]
+    },
+    'should handle a table cell node w/ children'
+  )
+
+  t.deepEqual(
+    toHast({type: 'tableCell', children: []}),
+    {type: 'element', tagName: 'td', properties: {}, children: []},
+    'should handle a table cell node w/o children'
+  )
+
   t.end()
 })