Refactor code-style

Author: wooorm

index.test-d.ts

@@ -1,22 +1,18 @@
-import {expectType, expectNotType} from 'tsd'
-import type {Parent as UnistParent} from 'unist'
-import type {Root, Content} from 'hast'
+import type {Nodes, Parents} from 'hast'
+import {expectNotType, expectType} from 'tsd'
 import {assert, parent} from './index.js'
 
-type Node = Root | Content
-type Parent = Extract<Node, UnistParent>
-
 const emptyNode = {type: 'doctype'}
 const literalNode = {type: 'text', value: 'a'}
 const parentNode = {type: 'element', children: [emptyNode, literalNode]}
 
-expectNotType<Node>(emptyNode)
-expectNotType<Node>(literalNode)
-expectNotType<Node>(parentNode)
+expectNotType<Nodes>(emptyNode)
+expectNotType<Nodes>(literalNode)
+expectNotType<Nodes>(parentNode)
 
 assert(emptyNode)
-expectType<Node>(emptyNode)
+expectType<Nodes>(emptyNode)
 
-expectNotType<Parent>(parentNode)
+expectNotType<Parents>(parentNode)
 parent(parentNode)
-expectType<Parent>(parentNode)
+expectType<Parents>(parentNode)

lib/index.js

@@ -1,30 +1,26 @@
 /**
- * @typedef {import('unist-util-assert').AssertionError} AssertionError
+ * @typedef {import('hast').Literals} Literals
+ * @typedef {import('hast').Element} Element
+ * @typedef {import('hast').Nodes} Nodes
+ * @typedef {import('hast').Parents} Parents
+ * @typedef {import('hast').Root} Root
  *
  * @typedef {import('unist').Node} UnistNode
  * @typedef {import('unist').Parent} UnistParent
- * @typedef {import('unist').Literal} UnistLiteral
- * @typedef {import('hast').Root} Root
- * @typedef {import('hast').Content} Content
- * @typedef {import('hast').Element} Element
- */
-
-/**
- * @typedef {Root | Content} Node
- * @typedef {Extract<Node, UnistParent>} Parent
- * @typedef {Extract<Node, UnistLiteral>} Literal
+ *
+ * @typedef {import('unist-util-assert').AssertionError} AssertionError
  */
 
 import nodeAssert from 'node:assert'
-import {zwitch} from 'zwitch'
 import {mapz} from 'mapz'
 import {
+  _void,
   assert as unistAssert,
-  parent as unistParent,
   literal as unistLiteral,
-  wrap,
-  _void
+  parent as unistParent,
+  wrap
 } from 'unist-util-assert'
+import {zwitch} from 'zwitch'
 
 /**
  * Assert that `tree` is a valid hast node.
@@ -37,7 +33,7 @@ import {
  *   Thing to assert.
  * @param {UnistParent | null | undefined} [parent]
  *   Optional, valid parent.
- * @returns {asserts tree is Node}
+ * @returns {asserts tree is Nodes}
  *   Nothing.
  * @throws {AssertionError}
  *   When `tree` (or its descendants) is not a hast node.
@@ -57,7 +53,7 @@ export function assert(tree, parent) {
  *   Thing to assert.
  * @param {UnistParent | null | undefined} [parent]
  *   Optional, valid parent.
- * @returns {asserts tree is Parent}
+ * @returns {asserts tree is Parents}
  *   Nothing.
  * @throws {AssertionError}
  *   When `tree` is not a parent or its descendants are not nodes.
@@ -75,7 +71,7 @@ export function parent(tree, parent) {
  *   Thing to assert.
  * @param {UnistParent | null | undefined} [parent]
  *   Optional, valid parent.
- * @returns {asserts node is Literal}
+ * @returns {asserts node is Literals}
  *   Nothing.
  * @throws {AssertionError}
  *   When `node` is not a hast literal.
@@ -125,7 +121,7 @@ function unknown(node, parent) {
  *
  * @param {unknown} [tree]
  *   Thing to assert.
- * @returns {asserts tree is Parent}
+ * @returns {asserts tree is Parents}
  *   Nothing.
  * @throws {AssertionError}
  *   When `tree` is not a parent or its descendants are not nodes.
@@ -142,7 +138,7 @@ function assertParent(tree) {
  *
  * @param {unknown} [node]
  *   Thing to assert.
- * @returns {asserts node is Literal}
+ * @returns {asserts node is Literals}
  *   Nothing.
  * @throws {AssertionError}
  *   When `node` is not a hast literal.
@@ -192,18 +188,11 @@ function assertRoot(tree, parent) {
 function assertElement(tree) {
   assertParent(tree)
 
-  nodeAssert.strictEqual(
-    // @ts-expect-error: hush.
-    typeof tree.tagName,
-    'string',
+  nodeAssert.ok(
+    'tagName' in tree && typeof tree.tagName === 'string',
     '`element` should have a `tagName`'
   )
-  nodeAssert.notStrictEqual(
-    // @ts-expect-error: hush.
-    tree.tagName,
-    '',
-    '`element.tagName` should not be empty'
-  )
+  nodeAssert.ok(tree.tagName !== '', '`element.tagName` should not be empty')
 }
 
 export {_void, wrap} from 'unist-util-assert'

test/children.js

@@ -2,40 +2,37 @@ import nodeAssert from 'node:assert/strict'
 import test from 'node:test'
 import {assert} from '../index.js'
 
-test('children', () => {
-  nodeAssert.throws(
-    () => {
-      assert({type: 'paragraph', children: {alpha: 'bravo'}})
-    },
-    /`children` should be an array: `{ type: 'paragraph', children: { alpha: 'bravo' } }`$/,
-    'should throw if given a non-node child in children'
+test('children', async function (t) {
+  await t.test(
+    'should throw if given a non-node child in children',
+    async function () {
+      nodeAssert.throws(function () {
+        assert({type: 'paragraph', children: {alpha: 'bravo'}})
+      }, /`children` should be an array: `{ type: 'paragraph', children: { alpha: 'bravo' } }`$/)
+    }
   )
 
-  nodeAssert.throws(
-    () => {
-      assert({type: 'paragraph', children: ['one']})
-    },
-    /node should be an object: `'one'` in `{ type: 'paragraph', children: \[ 'one' ] }`$/,
-    'should throw if given a non-node child in children'
+  await t.test(
+    'should throw if given a non-node child in children',
+    async function () {
+      nodeAssert.throws(function () {
+        assert({type: 'paragraph', children: ['one']})
+      }, /node should be an object: `'one'` in `{ type: 'paragraph', children: \[ 'one' ] }`$/)
+    }
   )
 
-  nodeAssert.doesNotThrow(() => {
-    assert({type: 'paragraph', children: [{type: 'text', value: 'alpha'}]})
-  }, 'should not throw on vald children')
+  await t.test('should not throw on vald children', async function () {
+    nodeAssert.doesNotThrow(function () {
+      assert({type: 'paragraph', children: [{type: 'text', value: 'alpha'}]})
+    })
+  })
 
-  nodeAssert.throws(
-    () => {
+  await t.test('should throw on invalid descendants', async function () {
+    nodeAssert.throws(function () {
       assert({
         type: 'paragraph',
-        children: [
-          {
-            type: 'bar',
-            children: ['one']
-          }
-        ]
+        children: [{type: 'bar', children: ['one']}]
       })
-    },
-    /node should be an object: `'one'` in `{ type: 'bar', children: \[ 'one' ] }`$/,
-    'should throw on invalid descendants'
-  )
+    }, /node should be an object: `'one'` in `{ type: 'bar', children: \[ 'one' ] }`$/)
+  })
 })

test/comment.js

@@ -2,16 +2,19 @@ import nodeAssert from 'node:assert/strict'
 import test from 'node:test'
 import {assert} from '../index.js'
 
-test('assert(comment)', () => {
-  nodeAssert.throws(
-    () => {
-      assert({type: 'comment'})
-    },
-    /literal should have `value`: `{ type: 'comment' }`$/,
-    'should throw if a `comment` doesn’t have a value'
+test('assert(comment)', async function (t) {
+  await t.test(
+    'should throw if a `comment` doesn’t have a value',
+    async function () {
+      nodeAssert.throws(function () {
+        assert({type: 'comment'})
+      }, /literal should have `value`: `{ type: 'comment' }`$/)
+    }
   )
 
-  nodeAssert.doesNotThrow(() => {
-    assert({type: 'comment', value: 'Alpha'})
-  }, 'should allow `value`')
+  await t.test('should allow `value`', async function () {
+    nodeAssert.doesNotThrow(function () {
+      assert({type: 'comment', value: 'Alpha'})
+    })
+  })
 })

test/core.js

@@ -1,11 +1,14 @@
 import nodeAssert from 'node:assert/strict'
 import test from 'node:test'
-import * as mod from '../index.js'
 
-test('api', () => {
-  nodeAssert.deepEqual(
-    Object.keys(mod).sort(),
-    ['_void', 'assert', 'literal', 'parent', 'wrap'],
-    'should expose the public api'
-  )
+test('api', async function (t) {
+  await t.test('should expose the public api', async function () {
+    nodeAssert.deepEqual(Object.keys(await import('../index.js')).sort(), [
+      '_void',
+      'assert',
+      'literal',
+      'parent',
+      'wrap'
+    ])
+  })
 })

test/doctype.js

@@ -2,8 +2,10 @@ import nodeAssert from 'node:assert/strict'
 import test from 'node:test'
 import {assert} from '../index.js'
 
-test('assert(doctype)', () => {
-  nodeAssert.doesNotThrow(() => {
-    assert({type: 'doctype'})
-  }, 'should allow doctypes')
+test('assert(doctype)', async function (t) {
+  await t.test('should allow doctypes', async function () {
+    nodeAssert.doesNotThrow(function () {
+      assert({type: 'doctype'})
+    })
+  })
 })

test/element.js

@@ -2,28 +2,31 @@ import nodeAssert from 'node:assert/strict'
 import test from 'node:test'
 import {assert} from '../index.js'
 
-test('assert(element)', () => {
-  nodeAssert.throws(
-    () => {
-      assert({type: 'element'})
-    },
-    /parent should have `children`: `{ type: 'element' }`$/,
-    'should throw if a `element` is not a parent'
+test('assert(element)', async function (t) {
+  await t.test(
+    'should throw if a `element` is not a parent',
+    async function () {
+      nodeAssert.throws(function () {
+        assert({type: 'element'})
+      }, /parent should have `children`: `{ type: 'element' }`$/)
+    }
   )
 
-  nodeAssert.throws(
-    () => {
-      assert({type: 'element', children: []})
-    },
-    /`element` should have a `tagName`: `{ type: 'element', children: \[] }`$/,
-    'should throw if a `element` has no `tagName`'
+  await t.test(
+    'should throw if a `element` has no `tagName`',
+    async function () {
+      nodeAssert.throws(function () {
+        assert({type: 'element', children: []})
+      }, /`element` should have a `tagName`: `{ type: 'element', children: \[] }`$/)
+    }
   )
 
-  nodeAssert.throws(
-    () => {
-      assert({type: 'element', tagName: '', children: []})
-    },
-    /`element.tagName` should not be empty: `{ type: 'element', tagName: '', children: \[] }`$/,
-    'should throw if a `element` has an empty `tagName`'
+  await t.test(
+    'should throw if a `element` has an empty `tagName`',
+    async function () {
+      nodeAssert.throws(function () {
+        assert({type: 'element', tagName: '', children: []})
+      }, /`element.tagName` should not be empty: `{ type: 'element', tagName: '', children: \[] }`$/)
+    }
   )
 })

test/index.js

@@ -1,11 +1,11 @@
 /* eslint-disable import/no-unassigned-import */
+import './children.js'
+import './comment.js'
 import './core.js'
+import './doctype.js'
+import './element.js'
 import './node.js'
 import './parent.js'
-import './children.js'
 import './root.js'
-import './element.js'
-import './doctype.js'
 import './text.js'
-import './comment.js'
 /* eslint-enable import/no-unassigned-import */

test/node.js

@@ -2,36 +2,28 @@ import nodeAssert from 'node:assert/strict'
 import test from 'node:test'
 import {assert} from '../index.js'
 
-test('node', () => {
-  nodeAssert.throws(
-    () => {
+test('node', async function (t) {
+  await t.test('should throw if not given a node (#1)', async function () {
+    nodeAssert.throws(function () {
       assert()
-    },
-    /node should be an object: `undefined`$/,
-    'should throw if not given a node (#1)'
-  )
+    }, /node should be an object: `undefined`$/)
+  })
 
-  nodeAssert.throws(
-    () => {
+  await t.test('should throw if not given a node (#2)', async function () {
+    nodeAssert.throws(function () {
       assert(null)
-    },
-    /node should be an object: `null`$/,
-    'should throw if not given a node (#2)'
-  )
+    }, /node should be an object: `null`$/)
+  })
 
-  nodeAssert.throws(
-    () => {
+  await t.test('should throw if given a non-node (#1)', async function () {
+    nodeAssert.throws(function () {
       assert('foo')
-    },
-    /node should be an object: `'foo'`$/,
-    'should throw if given a non-node (#1)'
-  )
+    }, /node should be an object: `'foo'`$/)
+  })
 
-  nodeAssert.throws(
-    () => {
+  await t.test('should throw if not given a non-node (#2)', async function () {
+    nodeAssert.throws(function () {
       assert(6)
-    },
-    /node should be an object: `6`$/,
-    'should throw if not given a non-node (#2)'
-  )
+    }, /node should be an object: `6`$/)
+  })
 })