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 {Node, Parent} from 'unist'
 import {assert, parent} from './index.js'
 

lib/index.js

@@ -1,12 +1,22 @@
 /**
- * @typedef {import('assert').AssertionError} AssertionError
- *   Assertion error from `node:assert`.
+ * @typedef {import('node:assert').AssertionError} AssertionError
  *
+ * @typedef {import('unist').Literal} Literal
  * @typedef {import('unist').Node} Node
  * @typedef {import('unist').Parent} Parent
- * @typedef {import('unist').Literal} Literal
- * @typedef {import('unist').Position} Position
  * @typedef {import('unist').Point} Point
+ * @typedef {import('unist').Position} Position
+ */
+
+/**
+ * @template T
+ * @callback CustomAssertion
+ * @param {any} [node]
+ * @param {Parent | null | undefined} [parent]
+ * @returns {asserts node is T}
+ */
+
+/**
  * @typedef {Node & {children: never, value: never}} _Void
  *
  * @typedef SeenErrorFields
@@ -100,9 +110,9 @@ const defined = new Set(['type', 'value', 'children', 'position'])
  *
  * @template {Node} T
  *   Node type.
- * @param {(node?: any, parent?: Parent | null | undefined) => asserts node is T} fn
+ * @param {CustomAssertion<T>} fn
  *   Custom assertion.
- * @returns {(node?: any, parent?: Parent | null | undefined) => asserts node is T}
+ * @returns {CustomAssertion<T>}
  *   Assertion.
  */
 export function wrap(fn) {
@@ -115,7 +125,7 @@ export function wrap(fn) {
    *   Optional, valid parent.
    * @throws {AssertionError}
    *   Whether `node` is a node but neither parent nor literal.
-   * @returns {void}
+   * @returns {undefined}
    *   Nothing.
    */
   function wrapped(node, parent) {
@@ -153,43 +163,36 @@ function assertNode(node) {
     node && typeof node === 'object' && !Array.isArray(node),
     'node should be an object'
   )
+  indexable(node)
 
   nodeAssert.ok(own.call(node, 'type'), 'node should have a type')
   nodeAssert.strictEqual(
-    // @ts-expect-error Looks like an indexed object.
     typeof node.type,
     'string',
     '`type` should be a string'
   )
-  // @ts-expect-error Looks like an indexed object.
   nodeAssert.notStrictEqual(node.type, '', '`type` should not be empty')
 
-  // @ts-expect-error Looks like an indexed object.
   if (node.value !== null && node.value !== undefined) {
     nodeAssert.strictEqual(
-      // @ts-expect-error Looks like an indexed object.
       typeof node.value,
       'string',
       '`value` should be a string'
     )
   }
 
-  // @ts-expect-error Looks like an indexed object.
   position(node.position)
 
   /** @type {string} */
   let key
 
   for (key in node) {
     if (!defined.has(key)) {
-      /** @type {unknown} */
-      // @ts-expect-error: hush.
       const value = node[key]
       vanilla(key, value)
     }
   }
 
-  // @ts-expect-error Looks like an indexed object.
   if (node.children !== null && node.children !== undefined) {
     /** @type {Parent} */
     // @ts-expect-error Looks like parent.
@@ -324,9 +327,8 @@ function position(position) {
       '`position` should be an object'
     )
 
-    // @ts-expect-error: indexable.
+    indexable(position)
     point(position.start, 'position.start')
-    // @ts-expect-error: indexable.
     point(position.end, 'position.end')
   }
 }
@@ -374,3 +376,22 @@ function point(point, label) {
     }
   }
 }
+
+/**
+ * TypeScript helper to check if something is indexable (any object is
+ * indexable in JavaScript).
+ *
+ * @param {unknown} value
+ *   Thing to check.
+ * @returns {asserts value is Record<string, unknown>}
+ *   Nothing.
+ * @throws {Error}
+ *   When `value` is not an object.
+ */
+function indexable(value) {
+  // Always called when something is an object, this is just for TS.
+  /* c8 ignore next 3 */
+  if (!value || typeof value !== 'object') {
+    throw new Error('Expected object')
+  }
+}

package.json

@@ -83,6 +83,16 @@
     "strict": true
   },
   "xo": {
+    "overrides": [
+      {
+        "files": [
+          "test/**/*.js"
+        ],
+        "rules": {
+          "import/no-unassigned-import": "off"
+        }
+      }
+    ],
     "prettier": true
   }
 }

readme.md

@@ -69,7 +69,7 @@ In browsers with [`esm.sh`][esmsh]:
 ## Use
 
 ```js
-import {assert, parent, _void} from 'unist-util-assert'
+import {_void, assert, parent} from 'unist-util-assert'
 
 assert({type: 'root', children: []})
 assert({type: 'break'})

test/children.js

@@ -2,29 +2,33 @@ import nodeAssert from 'node:assert/strict'
 import test from 'node:test'
 import {assert} from '../index.js'
 
-test('children', () => {
-  nodeAssert.throws(
-    () => {
-      assert({type: 'foo', children: {alpha: 'bravo'}})
-    },
-    /`children` should be an array: `{ type: 'foo', 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: 'foo', children: {alpha: 'bravo'}})
+      }, /`children` should be an array: `{ type: 'foo', children: { alpha: 'bravo' } }`$/)
+    }
   )
 
-  nodeAssert.throws(
-    () => {
-      assert({type: 'foo', children: ['one']})
-    },
-    /node should be an object: `'one'` in `{ type: 'foo', 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: 'foo', children: ['one']})
+      }, /node should be an object: `'one'` in `{ type: 'foo', children: \[ 'one' ] }`$/)
+    }
   )
 
-  nodeAssert.doesNotThrow(() => {
-    assert({type: 'parent', 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: 'parent', children: [{type: 'text', value: 'alpha'}]})
+    })
+  })
 
-  nodeAssert.throws(
-    () => {
+  await t.test('should throw on invalid descendants', async function () {
+    nodeAssert.throws(function () {
       assert({
         type: 'foo',
         children: [
@@ -34,8 +38,6 @@ test('children', () => {
           }
         ]
       })
-    },
-    /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/core.js

@@ -1,11 +1,14 @@
 import assert from 'node:assert/strict'
 import test from 'node:test'
-import * as mod from '../index.js'
 
-test('assert', () => {
-  assert.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 () {
+    assert.deepEqual(Object.keys(await import('../index.js')).sort(), [
+      '_void',
+      'assert',
+      'literal',
+      'parent',
+      'wrap'
+    ])
+  })
 })

test/index.js

@@ -1,12 +1,10 @@
-/* eslint-disable import/no-unassigned-import */
+import './children.js'
 import './core.js'
+import './literal.js'
 import './node.js'
-import './type.js'
-import './value.js'
-import './children.js'
-import './position.js'
 import './non-defined.js'
 import './parent.js'
-import './literal.js'
+import './position.js'
+import './type.js'
+import './value.js'
 import './void.js'
-/* eslint-enable import/no-unassigned-import */

test/literal.js

@@ -2,32 +2,34 @@ import assert from 'node:assert/strict'
 import test from 'node:test'
 import {literal} from '../index.js'
 
-test('literal()', () => {
-  assert.throws(
-    () => {
+test('literal()', async function (t) {
+  await t.test('should throw the same errors as `assert()`', async function () {
+    assert.throws(function () {
       literal({})
-    },
-    /node should have a type: `{}`$/,
-    'should throw the same errors as `assert()`'
-  )
+    }, /node should have a type: `{}`$/)
+  })
 
-  assert.throws(
-    () => {
-      literal({type: 'strong', children: []})
-    },
-    /literal should not have `children`: `{ type: 'strong', children: \[] }`$/,
-    'should throw if the given node has `children`'
+  await t.test(
+    'should throw if the given node has `children`',
+    async function () {
+      assert.throws(function () {
+        literal({type: 'strong', children: []})
+      }, /literal should not have `children`: `{ type: 'strong', children: \[] }`$/)
+    }
   )
 
-  assert.throws(
-    () => {
-      literal({type: 'break'})
-    },
-    /literal should have `value`: `{ type: 'break' }`$/,
-    'should throw if the given node has no `value`'
+  await t.test(
+    'should throw if the given node has no `value`',
+    async function () {
+      assert.throws(function () {
+        literal({type: 'break'})
+      }, /literal should have `value`: `{ type: 'break' }`$/)
+    }
   )
 
-  assert.doesNotThrow(() => {
-    literal({type: 'text', value: 'foo'})
-  }, 'should not throw on valid text nodes')
+  await t.test('should not throw on valid text nodes', async function () {
+    assert.doesNotThrow(function () {
+      literal({type: 'text', value: 'foo'})
+    })
+  })
 })

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`$/)
+  })
 })