Fix lists collapsing into thematic breaks

This fixes two cases where lists collapsed into thematic breaks:

Thematic break in list item as head:

```markdown
- ***
```

Empty list item in two lists:

```markdown
- * *
```

Closes GH-6.

Author: wooorm

lib/handle/list-item.js

@@ -17,9 +17,9 @@ import {indentLines} from '../util/indent-lines.js'
  */
 export function listItem(node, parent, context) {
   const listItemIndent = checkListItemIndent(context)
-  /** @type {string} */
-  let bullet = checkBullet(context)
+  let bullet = context.currentBullet || checkBullet(context)
 
+  // Add the marker value for ordered lists.
   if (parent && parent.type === 'list' && parent.ordered) {
     bullet =
       (typeof parent.start === 'number' && parent.start > -1
@@ -28,15 +28,15 @@ export function listItem(node, parent, context) {
       (context.options.incrementListMarker === false
         ? 0
         : parent.children.indexOf(node)) +
-      '.'
+      bullet
   }
 
   let size = bullet.length + 1
 
   if (
     listItemIndent === 'tab' ||
     (listItemIndent === 'mixed' &&
-      ((parent && 'spread' in parent && parent.spread) || node.spread))
+      ((parent && parent.type === 'list' && parent.spread) || node.spread))
   ) {
     size = Math.ceil(size / 4) * 4
   }

lib/handle/list.js

@@ -4,14 +4,83 @@
  */
 
 import {containerFlow} from '../util/container-flow.js'
+import {checkBullet} from '../util/check-bullet.js'
+import {checkOtherBullet} from '../util/check-other-bullet.js'
+import {checkRule} from '../util/check-rule.js'
 
 /**
  * @type {Handle}
  * @param {List} node
  */
 export function list(node, _, context) {
   const exit = context.enter('list')
+  const currentBullet = context.currentBullet
+  /** @type {string} */
+  let bullet = checkBullet(context)
+  const otherBullet = checkOtherBullet(context)
+
+  if (node.ordered) {
+    bullet = '.'
+  } else {
+    const firstListItem = node.children ? node.children[0] : undefined
+    let useDifferentMarker = false
+
+    // If there’s an empty first list item, directly in two list items,
+    // we have to use a different bullet:
+    //
+    // ```markdown
+    // * - *
+    // ```
+    //
+    // …because otherwise it would become one big thematic break.
+    if (
+      firstListItem &&
+      // Empty list item:
+      (!firstListItem.children || !firstListItem.children[0]) &&
+      // Directly in two other list items:
+      context.stack[context.stack.length - 2] === 'listItem' &&
+      context.stack[context.stack.length - 4] === 'listItem'
+    ) {
+      // Note: this is only needed for first children of first children,
+      // but the code checks for *children*, not *first*.
+      // So this might generate different bullets where not really needed.
+      useDifferentMarker = true
+    }
+
+    // If there’s a thematic break at the start of the first list item,
+    // we have to use a different bullet:
+    //
+    // ```markdown
+    // * ---
+    // ```
+    //
+    // …because otherwise it would become one big thematic break.
+    if (checkRule(context) === bullet && firstListItem) {
+      let index = -1
+
+      while (++index < node.children.length) {
+        const item = node.children[index]
+        if (
+          item &&
+          item.type === 'listItem' &&
+          item.children &&
+          item.children[0] &&
+          item.children[0].type === 'thematicBreak'
+        ) {
+          useDifferentMarker = true
+          break
+        }
+      }
+    }
+
+    if (useDifferentMarker) {
+      bullet = otherBullet
+    }
+  }
+
+  context.currentBullet = bullet
   const value = containerFlow(node, context)
+  context.currentBullet = currentBullet
   exit()
   return value
 }

lib/types.js

@@ -32,6 +32,7 @@
  * @property {Array.<Join>} join
  * @property {Handle} handle
  * @property {Handlers} handlers
+ * @property {string|undefined} currentBullet
  */
 
 /**
@@ -71,6 +72,7 @@
 /**
  * @typedef Options
  * @property {'-'|'*'|'+'} [bullet]
+ * @property {'-'|'*'|'+'} [otherBullet]
  * @property {boolean} [closeAtx]
  * @property {'_'|'*'} [emphasis]
  * @property {'~'|'`'} [fence]

lib/util/check-other-bullet.js

@@ -0,0 +1,39 @@
+/**
+ * @typedef {import('../types.js').Context} Context
+ * @typedef {import('../types.js').Options} Options
+ */
+
+import {checkBullet} from './check-bullet.js'
+
+/**
+ * @param {Context} context
+ * @returns {Exclude<Options['bullet'], undefined>}
+ */
+export function checkOtherBullet(context) {
+  const bullet = checkBullet(context)
+  const otherBullet = context.options.otherBullet
+
+  if (!otherBullet) {
+    return bullet === '*' ? '-' : '*'
+  }
+
+  if (otherBullet !== '*' && otherBullet !== '+' && otherBullet !== '-') {
+    throw new Error(
+      'Cannot serialize items with `' +
+        otherBullet +
+        '` for `options.otherBullet`, expected `*`, `+`, or `-`'
+    )
+  }
+
+  if (otherBullet === bullet) {
+    throw new Error(
+      'Expected `bullet` (`' +
+        bullet +
+        '`) and `otherBullet` (`' +
+        otherBullet +
+        '`) to be different'
+    )
+  }
+
+  return otherBullet
+}

test/index.js

@@ -1,3 +1,8 @@
+/**
+ * @typedef {import('mdast').BlockContent} BlockContent
+ * @typedef {import('mdast').List} List
+ */
+
 import test from 'tape'
 import {removePosition} from 'unist-util-remove-position'
 import {fromMarkdown as from} from 'mdast-util-from-markdown'
@@ -554,7 +559,7 @@ test('blockquote', (t) => {
         }
       ]
     }),
-    '> a\n> b\n>\n> *   c\n>     d\n>\n> *   ***\n>\n> *   e\n>     f\n',
+    '> a\n> b\n>\n> -   c\n>     d\n>\n> -   ***\n>\n> -   e\n>     f\n',
     'should support a list in a block quote'
   )
 
@@ -1931,7 +1936,7 @@ test('list', (t) => {
         }
       ]
     }),
-    '*   a\n\n*   ***\n\n*   b\n',
+    '-   a\n\n-   ***\n\n-   b\n',
     'should support a list w/ items'
   )
 
@@ -1952,7 +1957,7 @@ test('list', (t) => {
         }
       ]
     }),
-    '*   a\n*   ***\n',
+    '-   a\n-   ***\n',
     'should not use blank lines between items for lists w/ `spread: false`'
   )
 
@@ -1974,7 +1979,7 @@ test('list', (t) => {
         }
       ]
     }),
-    '*   a\n\n    b\n*   ***\n',
+    '-   a\n\n    b\n-   ***\n',
     'should support a list w/ `spread: false`, w/ a spread item'
   )
 
@@ -2442,6 +2447,122 @@ test('listItem', (t) => {
     'should not use blank lines between child blocks for items w/ `spread: false`'
   )
 
+  /**
+   * @param {BlockContent|BlockContent[]} [d]
+   * @returns {List}
+   */
+  function createList(d) {
+    return {
+      type: 'list',
+      children: [
+        {type: 'listItem', children: Array.isArray(d) ? d : d ? [d] : []}
+      ]
+    }
+  }
+
+  t.equal(
+    to(createList(createList(createList())), {otherBullet: '+'}),
+    '*   *   +\n',
+    'should support `otherBullet`'
+  )
+
+  t.equal(
+    to(createList(createList(createList())), {bullet: '-'}),
+    '-   -   *\n',
+    'should default to an `otherBullet` different from `bullet` (1)'
+  )
+
+  t.equal(
+    to(createList(createList(createList())), {bullet: '*'}),
+    '*   *   -\n',
+    'should default to an `otherBullet` different from `bullet` (2)'
+  )
+
+  t.throws(
+    () => {
+      // @ts-expect-error: runtime.
+      to(createList(createList(createList())), {otherBullet: '?'})
+    },
+    /Cannot serialize items with `\?` for `options\.otherBullet`, expected/,
+    'should throw when given an incorrect `otherBullet`'
+  )
+
+  t.throws(
+    () => {
+      to(createList(createList(createList())), {bullet: '-', otherBullet: '-'})
+    },
+    /Expected `bullet` \(`-`\) and `otherBullet` \(`-`\) to be different/,
+    'should throw when an `otherBullet` is given equal to `bullet`'
+  )
+
+  t.equal(
+    to({
+      type: 'list',
+      children: [{type: 'listItem', children: [{type: 'thematicBreak'}]}]
+    }),
+    '-   ***\n',
+    'should use a different bullet than a thematic rule marker, if the first child of a list item is a thematic break (1)'
+  )
+
+  t.equal(
+    to({
+      type: 'list',
+      children: [
+        {
+          type: 'listItem',
+          children: [
+            {type: 'paragraph', children: [{type: 'text', value: 'a'}]}
+          ]
+        },
+        {type: 'listItem', children: [{type: 'thematicBreak'}]}
+      ]
+    }),
+    '-   a\n\n-   ***\n',
+    'should use a different bullet than a thematic rule marker, if the first child of a list item is a thematic break (2)'
+  )
+
+  t.equal(
+    to(createList(createList())),
+    '*   *\n',
+    'should *not* use a different bullet for an empty list item in two lists'
+  )
+
+  t.equal(
+    to(createList(createList(createList()))),
+    '*   *   -\n',
+    'should use a different bullet for an empty list item in three lists'
+  )
+
+  t.equal(
+    to(createList(createList(createList(createList())))),
+    '*   *   *   -\n',
+    'should use a different bullet for an empty list item in four lists'
+  )
+
+  t.equal(
+    to(createList(createList(createList(createList(createList()))))),
+    '*   *   *   *   -\n',
+    'should use a different bullet for an empty list item in five lists'
+  )
+
+  // Note: this case isn’t needed, but there’s no way to check in the code
+  // that each list item is the head of its parental list.
+  t.equal(
+    to(
+      createList(
+        createList([
+          createList({
+            type: 'paragraph',
+            children: [{type: 'text', value: 'a'}]
+          }),
+          createList()
+        ])
+      )
+    ),
+    '*   *   *   a\n\n        <!---->\n\n        -\n',
+    'should use a different bullet for an empty list item at non-head in two lists'
+  )
+
   t.end()
 })
 
@@ -3064,5 +3185,21 @@ test('roundtrip', (t) => {
     'should roundtrip a sole blank line in fenced code'
   )
 
+  doc = '*   *   -\n'
+
+  t.equal(
+    to(from(doc)),
+    doc,
+    'should roundtrip an empty list item in two more lists'
+  )
+
+  doc = '-   ***\n'
+
+  t.equal(
+    to(from(doc)),
+    doc,
+    'should roundtrip a thematic break at the start of a list item'
+  )
+
   t.end()
 })