Refactor some code

Author: wooorm

lib/revert.js

@@ -7,23 +7,17 @@
  * @typedef {import('./state.js').State} State
  */
 
-/**
- * @typedef {Extract<Nodes, Reference>} References
- */
-
 // Make VS Code show references to the above types.
 ''
 
-// To do: next major: always return array.
-
 /**
  * Return the content of a reference without definition as plain text.
  *
  * @param {State} state
  *   Info passed around.
- * @param {References} node
+ * @param {Extract<Nodes, Reference>} node
  *   Reference node (image, link).
- * @returns {Array<ElementContent> | ElementContent}
+ * @returns {Array<ElementContent>}
  *   hast content.
  */
 export function revert(state, node) {
@@ -37,7 +31,7 @@ export function revert(state, node) {
   }
 
   if (node.type === 'imageReference') {
-    return {type: 'text', value: '![' + node.alt + suffix}
+    return [{type: 'text', value: '![' + node.alt + suffix}]
   }
 
   const contents = state.all(node)

test/core.js

@@ -1,12 +1,20 @@
+/**
+ * @typedef {import('hast').Element} Element
+ * @typedef {import('mdast').Paragraph} Paragraph
+ * @typedef {import('mdast').Nodes} Nodes
+ */
+
 import assert from 'node:assert/strict'
 import test from 'node:test'
 import {h} from 'hastscript'
 import {toHast} from '../index.js'
-import * as mod from '../index.js'
 
 test('toHast', async function (t) {
   await t.test('should expose the public api', async function () {
-    assert.deepEqual(Object.keys(mod).sort(), ['defaultHandlers', 'toHast'])
+    assert.deepEqual(Object.keys(await import('../index.js')).sort(), [
+      'defaultHandlers',
+      'toHast'
+    ])
   })
 
   await t.test('should throw on non-nodes', async function () {
@@ -241,4 +249,78 @@ test('toHast', async function (t) {
       )
     }
   )
+
+  /** @type {Paragraph} */
+  const customMdast = {
+    type: 'paragraph',
+    children: [
+      // @ts-expect-error: check how a custom literal is handled.
+      {type: 'a', value: 'alpha'},
+      // @ts-expect-error: check how a custom parent is handled.
+      {type: 'b', children: [{type: 'image', url: 'bravo'}]},
+      {type: 'text', value: 'charlie'}
+    ]
+  }
+
+  await t.test('should override default handlers', async function () {
+    assert.deepEqual(
+      toHast(
+        {type: 'paragraph', children: [{type: 'text', value: 'alpha'}]},
+        {
+          handlers: {
+            paragraph(h, /** @type {Paragraph} */ node) {
+              /** @type {Element} */
+              const result = {
+                type: 'element',
+                tagName: 'p',
+                properties: {},
+                children: [{type: 'text', value: 'bravo'}]
+              }
+              h.patch(node, result)
+              return h.applyData(node, result)
+            }
+          }
+        }
+      ),
+      h('p', 'bravo')
+    )
+  })
+
+  await t.test('should support unknown nodes by default', async function () {
+    assert.deepEqual(
+      toHast(customMdast),
+      h('p', ['alpha', h('div', [h('img', {src: 'bravo'})]), 'charlie'])
+    )
+  })
+
+  await t.test('should support `unknownHandler`', async function () {
+    assert.deepEqual(
+      toHast(customMdast, {
+        // To do: improved test.
+        // @ts-expect-error `hast` expected, but this returns unknown mdast nodes.
+        unknownHandler(_, /** @type {Nodes} */ node) {
+          return node
+        }
+      }),
+      h('p', [
+        {type: 'a', value: 'alpha'},
+        // To do: register custom?
+        // @ts-expect-error: custom.
+        {type: 'b', children: [{type: 'image', url: 'bravo'}]},
+        'charlie'
+      ])
+    )
+  })
+
+  await t.test('should support `passThrough`', async function () {
+    assert.deepEqual(
+      toHast(customMdast, {passThrough: ['a', 'b']}),
+      h('p', [
+        {type: 'a', value: 'alpha'},
+        // @ts-expect-error: custom.
+        {type: 'b', children: [h('img', {src: 'bravo'})]},
+        'charlie'
+      ])
+    )
+  })
 })

test/handlers-option.js

@@ -8,11 +8,13 @@ test('imageReference', async function (t) {
     'should fall back on `imageReference`s without definition',
     async function () {
       assert.deepEqual(
-        toHast(
-          // @ts-expect-error: check how missing `referenceType` is handled.
-          {type: 'imageReference', identifier: 'alpha', alt: 'bravo'}
-        ),
-        {type: 'text', value: '![bravo]'}
+        toHast({
+          type: 'imageReference',
+          referenceType: 'shortcut',
+          identifier: 'alpha',
+          alt: 'bravo'
+        }),
+        {type: 'root', children: [{type: 'text', value: '![bravo]'}]}
       )
     }
   )
@@ -25,7 +27,7 @@ test('imageReference', async function (t) {
         referenceType: 'full',
         alt: 'delta'
       }),
-      {type: 'text', value: '![delta][charlie]'}
+      {type: 'root', children: [{type: 'text', value: '![delta][charlie]'}]}
     )
   })
 
@@ -39,7 +41,7 @@ test('imageReference', async function (t) {
           referenceType: 'collapsed',
           alt: 'foxtrot'
         }),
-        {type: 'text', value: '![foxtrot][]'}
+        {type: 'root', children: [{type: 'text', value: '![foxtrot][]'}]}
       )
     }
   )
@@ -89,7 +91,7 @@ test('imageReference', async function (t) {
           referenceType: 'full',
           alt: 'mike'
         }),
-        {type: 'text', value: '![mike][Lima]'}
+        {type: 'root', children: [{type: 'text', value: '![mike][Lima]'}]}
       )
     }
   )

test/image-reference.js

@@ -1,8 +1,8 @@
 /* eslint-disable import/no-unassigned-import */
-import './core.js'
 import './blockquote.js'
 import './break.js'
 import './code.js'
+import './core.js'
 import './definition.js'
 import './delete.js'
 import './emphasis.js'
@@ -26,5 +26,4 @@ import './text.js'
 import './thematic-break.js'
 import './toml.js'
 import './yaml.js'
-import './handlers-option.js'
 /* eslint-enable import/no-unassigned-import */