Refactor code-style

Author: wooorm

lib/index.js

@@ -34,7 +34,7 @@ export function shiftHeading(tree, shift) {
     throw new Error('Expected a non-null finite integer, not `' + shift + '`')
   }
 
-  visit(tree, 'element', (node) => {
+  visit(tree, 'element', function (node) {
     let rank = headingRank(node)
 
     if (rank) {

test.js

@@ -2,86 +2,74 @@ import assert from 'node:assert/strict'
 import test from 'node:test'
 import {h} from 'hastscript'
 import {shiftHeading} from './index.js'
-import * as mod from './index.js'
 
-test('shiftHeading', () => {
-  assert.deepEqual(
-    Object.keys(mod).sort(),
-    ['shiftHeading'],
-    'should expose the public api'
-  )
+test('shiftHeading', async function (t) {
+  await t.test('should expose the public api', async function () {
+    assert.deepEqual(Object.keys(await import('./index.js')).sort(), [
+      'shiftHeading'
+    ])
+  })
 
-  assert.throws(
-    () => {
-      // @ts-ignore runtime.
+  await t.test('should throw when not given a number', async function () {
+    assert.throws(function () {
+      // @ts-ignore: check how a missing `shift` is handled.
       shiftHeading(h(''))
-    },
-    /^Error: Expected a non-null finite integer, not `undefined`$/,
-    'should throw when not given a number'
-  )
+    }, /^Error: Expected a non-null finite integer, not `undefined`$/)
+  })
 
-  assert.throws(
-    () => {
+  await t.test('should throw when given not a number', async function () {
+    assert.throws(function () {
       shiftHeading(h(''), Number.NaN)
-    },
-    /^Error: Expected a non-null finite integer, not `NaN`$/,
-    'should throw when given not a number'
-  )
+    }, /^Error: Expected a non-null finite integer, not `NaN`$/)
+  })
 
-  assert.throws(
-    () => {
+  await t.test('should throw when not given an integer', async function () {
+    assert.throws(function () {
       shiftHeading(h(''), 0.1)
-    },
-    /^Error: Expected a non-null finite integer, not `0.1`$/,
-    'should throw when not given an integer'
-  )
+    }, /^Error: Expected a non-null finite integer, not `0.1`$/)
+  })
 
-  assert.throws(
-    () => {
-      shiftHeading(h(''), Number.POSITIVE_INFINITY)
-    },
-    /^Error: Expected a non-null finite integer, not `Infinity`$/,
-    'should throw when not given a finite number'
+  await t.test(
+    'should throw when not given a finite number',
+    async function () {
+      assert.throws(function () {
+        shiftHeading(h(''), Number.POSITIVE_INFINITY)
+      }, /^Error: Expected a non-null finite integer, not `Infinity`$/)
+    }
   )
 
-  assert.throws(
-    () => {
-      shiftHeading(h(''), 0)
-    },
-    /^Error: Expected a non-null finite integer, not `0`$/,
-    'should throw when not given a non-null number'
+  await t.test(
+    'should throw when not given a non-null number',
+    async function () {
+      assert.throws(function () {
+        shiftHeading(h(''), 0)
+      }, /^Error: Expected a non-null finite integer, not `0`$/)
+    }
   )
 
-  assert.deepEqual(
-    shiftHeading(h('h1', 'Alpha'), 1),
-    h('h2', 'Alpha'),
-    'should shift nodes upwards'
-  )
+  await t.test('should shift nodes upwards', async function () {
+    assert.deepEqual(shiftHeading(h('h1', 'Alpha'), 1), h('h2', 'Alpha'))
+  })
 
-  assert.deepEqual(
-    shiftHeading(h('h2', 'Bravo'), -1),
-    h('h1', 'Bravo'),
-    'should shift nodes downwards'
-  )
+  await t.test('should shift nodes downwards', async function () {
+    assert.deepEqual(shiftHeading(h('h2', 'Bravo'), -1), h('h1', 'Bravo'))
+  })
 
-  assert.deepEqual(
-    shiftHeading(h('h2', 'Charlie'), -2),
-    h('h1', 'Charlie'),
-    'should not shift upwards past h1'
-  )
+  await t.test('should not shift upwards past h1', async function () {
+    assert.deepEqual(shiftHeading(h('h2', 'Charlie'), -2), h('h1', 'Charlie'))
+  })
 
-  assert.deepEqual(
-    shiftHeading(h('h5', 'Delta'), 2),
-    h('h6', 'Delta'),
-    'should not shift downwards past h6'
-  )
+  await t.test('should not shift downwards past h6', async function () {
+    assert.deepEqual(shiftHeading(h('h5', 'Delta'), 2), h('h6', 'Delta'))
+  })
 
-  assert.deepEqual(
-    shiftHeading(
-      h('main', [h('h1', 'Echo'), h('p', 'Foxtrot'), h('h5', 'Golf')]),
-      2
-    ),
-    h('main', [h('h3', 'Echo'), h('p', 'Foxtrot'), h('h6', 'Golf')]),
-    'should change a tree'
-  )
+  await t.test('should change a tree', async function () {
+    assert.deepEqual(
+      shiftHeading(
+        h('main', [h('h1', 'Echo'), h('p', 'Foxtrot'), h('h5', 'Golf')]),
+        2
+      ),
+      h('main', [h('h3', 'Echo'), h('p', 'Foxtrot'), h('h6', 'Golf')])
+    )
+  })
 })