Refactor code-style

Author: wooorm

index.test-d.ts

@@ -1,4 +1,4 @@
-import {expectType, expectNotType} from 'tsd'
+import {expectNotType, expectType} from 'tsd'
 import type {Nodes, Parents} from 'mdast'
 import {assert, parent} from './index.js'
 

lib/index.js

@@ -1,36 +1,37 @@
 /**
- * @typedef {import('unist-util-assert').AssertionError} AssertionError
- *
- * @typedef {import('unist').Parent} UnistParent
- *
- * @typedef {import('mdast').Root} Root
- * @typedef {import('mdast').Nodes} Nodes
- * @typedef {import('mdast').Parents} Parents
- * @typedef {import('mdast').Literals} Literals
- * @typedef {import('mdast').List} List
- * @typedef {import('mdast').ListItem} ListItem
- * @typedef {import('mdast').Heading} Heading
  * @typedef {import('mdast').Code} Code
- * @typedef {import('mdast').FootnoteDefinition} FootnoteDefinition
  * @typedef {import('mdast').Definition} Definition
- * @typedef {import('mdast').Link} Link
+ * @typedef {import('mdast').FootnoteDefinition} FootnoteDefinition
+ * @typedef {import('mdast').FootnoteReference} FootnoteReference
+ * @typedef {import('mdast').Heading} Heading
  * @typedef {import('mdast').Image} Image
- * @typedef {import('mdast').LinkReference} LinkReference
  * @typedef {import('mdast').ImageReference} ImageReference
- * @typedef {import('mdast').FootnoteReference} FootnoteReference
+ * @typedef {import('mdast').Link} Link
+ * @typedef {import('mdast').LinkReference} LinkReference
+ * @typedef {import('mdast').List} List
+ * @typedef {import('mdast').ListItem} ListItem
+ * @typedef {import('mdast').Literals} Literals
+ * @typedef {import('mdast').Nodes} Nodes
+ * @typedef {import('mdast').Parents} Parents
+ * @typedef {import('mdast').Root} Root
  * @typedef {import('mdast').Table} Table
+ *
+ * @typedef {import('unist').Parent} UnistParent
+ *
+ * @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 mdast node.

test/children.js

@@ -2,35 +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']}]
       })
-    },
-    /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/code.js

@@ -2,40 +2,39 @@ import nodeAssert from 'node:assert/strict'
 import test from 'node:test'
 import {assert} from '../index.js'
 
-test('assert(code)', () => {
-  nodeAssert.throws(
-    () => {
+test('assert(code)', async function (t) {
+  await t.test('should throw if `code` is not a text', async function () {
+    nodeAssert.throws(function () {
       assert({type: 'code'})
-    },
-    /literal should have `value`: `{ type: 'code' }`$/,
-    'should throw if `code` is not a text'
-  )
-
-  nodeAssert.doesNotThrow(() => {
-    assert({type: 'code', value: ''})
-  }, 'should not throw if `code` has no extra properties')
+    }, /literal should have `value`: `{ type: 'code' }`$/)
+  })
+  await t.test('', async function () {
+    nodeAssert.doesNotThrow(function () {
+      assert({
+        type: 'code',
+        value: 'should not throw if `code` has no extra properties'
+      })
+    })
+  })
 
-  nodeAssert.throws(
-    () => {
+  await t.test('should throw if `lang` is not a string', async function () {
+    nodeAssert.throws(function () {
       assert({type: 'code', lang: 0, value: ''})
-    },
-    /`lang` must be `string`: `{ type: 'code', lang: 0, value: '' }`$/,
-    'should throw if `lang` is not a string'
-  )
+    }, /`lang` must be `string`: `{ type: 'code', lang: 0, value: '' }`$/)
+  })
 
-  nodeAssert.throws(
-    () => {
+  await t.test('should throw if `meta` is not a string', async function () {
+    nodeAssert.throws(function () {
       assert({type: 'code', lang: 'js', meta: 1, value: ''})
-    },
-    /`meta` must be `string`: `{ type: 'code', lang: 'js', meta: 1, value: '' }`$/,
-    'should throw if `meta` is not a string'
-  )
+    }, /`meta` must be `string`: `{ type: 'code', lang: 'js', meta: 1, value: '' }`$/)
+  })
 
-  nodeAssert.throws(
-    () => {
-      assert({type: 'code', meta: '', value: ''})
-    },
-    /code with `meta` must also have `lang`: `{ type: 'code', meta: '', value: '' }`$/,
-    'should throw if `meta` is defined but not `lang`'
+  await t.test(
+    'should throw if `meta` is defined but not `lang`',
+    async function () {
+      nodeAssert.throws(function () {
+        assert({type: 'code', meta: '', value: ''})
+      }, /code with `meta` must also have `lang`: `{ type: 'code', meta: '', value: '' }`$/)
+    }
   )
 })

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('assert', () => {
-  nodeAssert.deepEqual(
-    Object.keys(mod).sort(),
-    ['_void', 'assert', 'literal', 'parent', 'wrap'],
-    'should expose the public api'
-  )
+test('assert', 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/definition.js

@@ -2,56 +2,55 @@ import nodeAssert from 'node:assert/strict'
 import test from 'node:test'
 import {assert} from '../index.js'
 
-test('assert(definition)', () => {
-  nodeAssert.throws(
-    () => {
-      assert({type: 'definition'})
-    },
-    /`identifier` must be `string`: `{ type: 'definition' }`$/,
-    'should throw if `definition` has no `identifier`'
+test('assert(definition)', async function (t) {
+  await t.test(
+    'should throw if `definition` has no `identifier`',
+    async function () {
+      nodeAssert.throws(function () {
+        assert({type: 'definition'})
+      }, /`identifier` must be `string`: `{ type: 'definition' }`$/)
+    }
   )
 
-  nodeAssert.throws(
-    () => {
+  await t.test('should throw if `definition` has no `url`', async function () {
+    nodeAssert.throws(function () {
       assert({type: 'definition', identifier: '1'})
-    },
-    /`url` must be `string`: `{ type: 'definition', identifier: '1' }`$/,
-    'should throw if `definition` has no `url`'
-  )
+    }, /`url` must be `string`: `{ type: 'definition', identifier: '1' }`$/)
+  })
 
-  nodeAssert.throws(
-    () => {
-      assert({type: 'definition', identifier: 1})
-    },
-    /`identifier` must be `string`: `{ type: 'definition', identifier: 1 }`$/,
-    'should throw if `identifier` is not a `string`'
+  await t.test(
+    'should throw if `identifier` is not a `string`',
+    async function () {
+      nodeAssert.throws(function () {
+        assert({type: 'definition', identifier: 1})
+      }, /`identifier` must be `string`: `{ type: 'definition', identifier: 1 }`$/)
+    }
   )
 
-  nodeAssert.throws(
-    () => {
+  await t.test('should throw if `url` is not a `string`', async function () {
+    nodeAssert.throws(function () {
       assert({type: 'definition', url: 1})
-    },
-    /`identifier` must be `string`: `{ type: 'definition', url: 1 }`$/,
-    'should throw if `url` is not a `string`'
-  )
+    }, /`identifier` must be `string`: `{ type: 'definition', url: 1 }`$/)
+  })
 
-  nodeAssert.doesNotThrow(() => {
-    assert({type: 'definition', identifier: '1', url: '1'})
-  }, 'should not throw if `definition` has no other properties')
+  await t.test(
+    'should not throw if `definition` has no other properties',
+    async function () {
+      nodeAssert.doesNotThrow(function () {
+        assert({type: 'definition', identifier: '1', url: '1'})
+      })
+    }
+  )
 
-  nodeAssert.throws(
-    () => {
+  await t.test('should throw if `title` is not a `string`', async function () {
+    nodeAssert.throws(function () {
       assert({type: 'definition', identifier: '1', url: '1', title: 1})
-    },
-    /`title` must be `string`: `{ type: 'definition', identifier: '1', url: '1', title: 1 }`$/,
-    'should throw if `title` is not a `string`'
-  )
+    }, /`title` must be `string`: `{ type: 'definition', identifier: '1', url: '1', title: 1 }`$/)
+  })
 
-  nodeAssert.throws(
-    () => {
+  await t.test('should throw if `label` is not a `string`', async function () {
+    nodeAssert.throws(function () {
       assert({type: 'definition', identifier: '1', url: '1', label: 1})
-    },
-    /`label` must be `string`: `{ type: 'definition', identifier: '1', url: '1', label: 1 }`$/,
-    'should throw if `label` is not a `string`'
-  )
+    }, /`label` must be `string`: `{ type: 'definition', identifier: '1', url: '1', label: 1 }`$/)
+  })
 })

test/footnote-definition.js

@@ -2,45 +2,51 @@ import nodeAssert from 'node:assert/strict'
 import test from 'node:test'
 import {assert} from '../index.js'
 
-test('assert(footnoteDefinition)', () => {
-  nodeAssert.throws(
-    () => {
-      assert({type: 'footnoteDefinition'})
-    },
-    /parent should have `children`: `{ type: 'footnoteDefinition' }`$/,
-    'should throw if `footnoteDefinition` is not a parent'
+test('assert(footnoteDefinition)', async function (t) {
+  await t.test(
+    'should throw if `footnoteDefinition` is not a parent',
+    async function () {
+      nodeAssert.throws(function () {
+        assert({type: 'footnoteDefinition'})
+      }, /parent should have `children`: `{ type: 'footnoteDefinition' }`$/)
+    }
   )
 
-  nodeAssert.throws(
-    () => {
-      assert({type: 'footnoteDefinition', children: []})
-    },
-    /`footnoteDefinition` must have `identifier`: `{ type: 'footnoteDefinition', children: \[] }`$/,
-    'should throw if `footnoteDefinition` has no identifier'
+  await t.test(
+    'should throw if `footnoteDefinition` has no identifier',
+    async function () {
+      nodeAssert.throws(function () {
+        assert({type: 'footnoteDefinition', children: []})
+      }, /`footnoteDefinition` must have `identifier`: `{ type: 'footnoteDefinition', children: \[] }`$/)
+    }
   )
 
-  nodeAssert.throws(
-    () => {
-      assert({type: 'footnoteDefinition', identifier: 1, children: []})
-    },
-    /`footnoteDefinition` must have `identifier`: `{ type: 'footnoteDefinition', identifier: 1, children: \[] }`$/,
-    'should throw if `identifier` is not a `string`'
+  await t.test(
+    'should throw if `identifier` is not a `string`',
+    async function () {
+      nodeAssert.throws(function () {
+        assert({type: 'footnoteDefinition', identifier: 1, children: []})
+      }, /`footnoteDefinition` must have `identifier`: `{ type: 'footnoteDefinition', identifier: 1, children: \[] }`$/)
+    }
   )
 
-  nodeAssert.doesNotThrow(() => {
-    assert({type: 'footnoteDefinition', identifier: '1', children: []})
-  }, 'should not throw if `footnoteDefinition` has an identifier')
+  await t.test(
+    'should not throw if `footnoteDefinition` has an identifier',
+    async function () {
+      nodeAssert.doesNotThrow(function () {
+        assert({type: 'footnoteDefinition', identifier: '1', children: []})
+      })
+    }
+  )
 
-  nodeAssert.throws(
-    () => {
+  await t.test('should throw if `label` is not a `string`', async function () {
+    nodeAssert.throws(function () {
       assert({
         type: 'footnoteDefinition',
         identifier: '1',
         label: 1,
         children: []
       })
-    },
-    /`label` must be `string`: `{ type: 'footnoteDefinition',\s+identifier: '1',\s+label: 1,\s+children: \[] }`$/,
-    'should throw if `label` is not a `string`'
-  )
+    }, /`label` must be `string`: `{ type: 'footnoteDefinition',\s+identifier: '1',\s+label: 1,\s+children: \[] }`$/)
+  })
 })