Refactor code-style

Author: wooorm

lib/index.js

@@ -4,9 +4,9 @@
  * @typedef Options
  *   Configuration (optional).
  * @property {boolean | null | undefined} [includeImageAlt=true]
- *   Whether to use `alt` for `image`s.
+ *   Whether to use `alt` for `image`s (default: `true`).
  * @property {boolean | null | undefined} [includeHtml=true]
- *   Whether to use `value` of HTML.
+ *   Whether to use `value` of HTML (default: `true`).
  */
 
 /** @type {Options} */
@@ -18,7 +18,7 @@ const emptyOptions = {}
  * Prefers the node’s plain-text fields, otherwise serializes its children,
  * and if the given value is an array, serialize the nodes in it.
  *
- * @param {unknown} value
+ * @param {unknown} [value]
  *   Thing to serialize, typically `Node`.
  * @param {Options | null | undefined} [options]
  *   Configuration (optional).

test.js

@@ -1,71 +1,84 @@
 import assert from 'node:assert/strict'
 import test from 'node:test'
 import {toString} from './index.js'
-import * as mod from './index.js'
 
-test('toString', () => {
-  assert.deepEqual(
-    Object.keys(mod).sort(),
-    ['toString'],
-    'should expose the public api'
-  )
+test('toString', async function (t) {
+  await t.test('should expose the public api', async function () {
+    assert.deepEqual(Object.keys(await import('./index.js')).sort(), [
+      'toString'
+    ])
+  })
 
-  // @ts-expect-error: runtime.
-  assert.equal(toString(), '', 'should not fail on a missing node')
-  assert.equal(toString(null), '', 'should not fail on `null` missing node')
+  await t.test('should not fail on a missing node', async function () {
+    assert.equal(toString(), '')
+  })
 
-  assert.equal(
-    toString({value: 'foo'}),
-    'foo',
-    'should not fail on nodes w/o type'
-  )
+  await t.test('should not fail on `null` missing node', async function () {
+    assert.equal(toString(null), '')
+  })
 
-  assert.equal(
-    toString({
-      value: 'foo',
-      alt: 'bar',
-      title: 'baz',
-      children: [{value: 'qux'}]
-    }),
-    'foo',
-    'should prefer `value` over all others'
-  )
+  await t.test('should not fail on nodes w/o type', async function () {
+    assert.equal(toString({value: 'foo'}), 'foo')
+  })
 
-  assert.equal(
-    toString({alt: 'bar', title: 'baz', children: [{value: 'qux'}]}),
-    'bar',
-    'should prefer `alt` over all others'
-  )
+  await t.test('should prefer `value` over all others', async function () {
+    assert.equal(
+      toString({
+        value: 'foo',
+        alt: 'bar',
+        title: 'baz',
+        children: [{value: 'qux'}]
+      }),
+      'foo'
+    )
+  })
 
-  assert.equal(
-    toString({title: 'baz', children: [{value: 'qux'}]}),
-    'qux',
-    'should *not* prefer `title` over all others'
-  )
+  await t.test('should prefer `alt` over all others', async function () {
+    assert.equal(
+      toString({alt: 'bar', title: 'baz', children: [{value: 'qux'}]}),
+      'bar'
+    )
+  })
 
-  assert.equal(
-    toString({alt: 'bar'}, {includeImageAlt: false}),
-    '',
-    'should *not* include `alt` w/ `includeImageAlt: false`'
+  await t.test(
+    'should *not* prefer `title` over all others',
+    async function () {
+      assert.equal(toString({title: 'baz', children: [{value: 'qux'}]}), 'qux')
+    }
   )
 
-  assert.equal(
-    toString({type: 'html', value: 'a'}, {includeHtml: false}),
-    '',
-    'should *not* include `html` w/ `includeHtml: false`'
+  await t.test(
+    'should *not* include `alt` w/ `includeImageAlt: false`',
+    async function () {
+      assert.equal(toString({alt: 'bar'}, {includeImageAlt: false}), '')
+    }
   )
 
-  assert.equal(
-    toString({children: [{value: 'foo'}, {alt: 'bar'}, {title: 'baz'}]}),
-    'foobar',
-    'should serialize children'
+  await t.test(
+    'should *not* include `html` w/ `includeHtml: false`',
+    async function () {
+      assert.equal(
+        toString({type: 'html', value: 'a'}, {includeHtml: false}),
+        ''
+      )
+    }
   )
 
-  assert.equal(
-    toString([{value: 'foo'}, {alt: 'bar'}, {title: 'baz'}]),
-    'foobar',
-    'should serialize a list of nodes'
-  )
+  await t.test('should serialize children', async function () {
+    assert.equal(
+      toString({children: [{value: 'foo'}, {alt: 'bar'}, {title: 'baz'}]}),
+      'foobar'
+    )
+  })
+
+  await t.test('should serialize a list of nodes', async function () {
+    assert.equal(
+      toString([{value: 'foo'}, {alt: 'bar'}, {title: 'baz'}]),
+      'foobar'
+    )
+  })
 
-  assert.equal(toString({}), '', 'should produce an empty string otherwise')
+  await t.test('should produce an empty string otherwise', async function () {
+    assert.equal(toString({}), '')
+  })
 })