Refactor code-style

Author: wooorm

lib/index.js

@@ -1,18 +1,20 @@
 /**
- * @typedef {import('nlcst').Content} Content
- * @typedef {import('nlcst').Root} Root
+ * @typedef {import('nlcst').Nodes} Nodes
  */
 
+/** @type {Readonly<Array<Nodes>>} */
+const emptyNodes = []
+
 /**
  * Get the text content of a node or list of nodes.
  *
  * 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 {Root | Content | Array<Content>} value
+ * @param {Array<Nodes> | Nodes} value
  *   Node or list of nodes to serialize.
  * @param {string | null | undefined} [separator='']
- *   Separator to use.
+ *   Separator to use (default: `''`).
  * @returns {string}
  *   Result.
  */
@@ -24,17 +26,9 @@ export function toString(value, separator) {
     throw new Error('Expected node, not `' + value + '`')
   }
 
-  // @ts-expect-error Looks like a literal.
-  if (typeof value.value === 'string') return value.value
-
-  /** @type {Array<Content|Root>} */
-  // @ts-expect-error Looks like a list of nodes or parent.
-  const children = (Array.isArray(value) ? value : value.children) || []
+  if ('value' in value) return value.value
 
-  // Shortcut: This is pretty common, and a small performance win.
-  if (children.length === 1 && 'value' in children[0]) {
-    return children[0].value
-  }
+  const children = (Array.isArray(value) ? value : value.children) || emptyNodes
 
   /** @type {Array<string>} */
   const values = []

test.js

@@ -2,80 +2,87 @@ import assert from 'node:assert/strict'
 import test from 'node:test'
 import {u} from 'unist-builder'
 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'
+    ])
+  })
 
-  assert.throws(
-    () => {
-      // @ts-expect-error: runtime.
+  await t.test('should throw when not given a node (#1)', async function () {
+    assert.throws(function () {
+      // @ts-expect-error: check how the runtime handles no node.
       toString()
-    },
-    /undefined/,
-    'should throw when not given a node (#1)'
-  )
+    })
+  })
 
-  assert.throws(
-    () => {
-      // @ts-expect-error: missing `type`.
+  await t.test('should throw when not given a node (#2)', async function () {
+    assert.throws(function () {
+      // @ts-expect-error: check how the runtime handles no `type`.
       toString({value: 'foo'})
-    },
-    /\[object Object]/,
-    'should throw when not given a node (#2)'
-  )
+    })
+  })
 
-  assert.equal(toString(u('TextNode', 'AT')), 'AT', 'should support texts')
+  await t.test('should support texts', async function () {
+    assert.equal(toString(u('TextNode', 'AT')), 'AT')
+  })
 
-  assert.equal(
-    toString(
-      u('WordNode', [
-        u('TextNode', 'AT'),
-        u('SymbolNode', '&'),
-        u('TextNode', 'T')
-      ])
-    ),
-    'AT&T',
-    'should support parents'
-  )
+  await t.test('should support parents', async function () {
+    assert.equal(
+      toString(
+        u('WordNode', [
+          u('TextNode', 'AT'),
+          u('SymbolNode', '&'),
+          u('TextNode', 'T')
+        ])
+      ),
+      'AT&T'
+    )
+  })
 
-  assert.equal(
-    toString([u('TextNode', 'AT'), u('SymbolNode', '&'), u('TextNode', 'T')]),
-    'AT&T',
-    'should support nodes'
-  )
+  await t.test('should support nodes', async function () {
+    assert.equal(
+      toString([u('TextNode', 'AT'), u('SymbolNode', '&'), u('TextNode', 'T')]),
+      'AT&T'
+    )
+  })
 
-  assert.equal(
-    toString(
-      // @ts-expect-error: custom.
-      u('WordNode', [
-        u('TextNode', 'AT'),
-        u('SomeNode', [u('TextNode', '&')]),
-        u('TextNode', 'T')
-      ])
-    ),
-    'AT&T',
-    'should support parents with mixed children'
-  )
+  await t.test('should support parents with mixed children', async function () {
+    assert.equal(
+      toString(
+        u('WordNode', [
+          u('TextNode', 'AT'),
+          u('SymbolNode', '&'),
+          u('TextNode', 'T')
+        ])
+      ),
+      'AT&T'
+    )
+  })
 
-  assert.equal(
-    toString(
-      // @ts-expect-error: custom.
-      u('WordNode', [
-        u('TextNode', 'AT'),
-        u('WordNode', [u('TextNode', '&')]),
-        u('TextNode', 'T')
-      ]),
-      ','
-    ),
-    'AT,&,T',
-    'should support separators'
-  )
+  await t.test('should support separators', async function () {
+    assert.equal(
+      toString(
+        u('WordNode', [
+          u('TextNode', 'AT'),
+          u('SymbolNode', '&'),
+          u('TextNode', 'T')
+        ]),
+        ','
+      ),
+      'AT,&,T'
+    )
+  })
 
-  // @ts-expect-error: custom node.
-  assert.equal(toString(u('VoidNode')), '', 'should support voids')
+  await t.test('should support voids', async function () {
+    assert.equal(
+      toString(
+        // @ts-expect-error: check how the runtime handles custom nodes.
+
+        u('VoidNode')
+      ),
+      ''
+    )
+  })
 })