Refactor code-style

Author: wooorm

lib/index.js

@@ -11,22 +11,22 @@
  * @returns {boolean}
  *   Whether `node` is a labelable element.
  *
- *   Labelable elements are `button`, `keygen`, `meter`, `output`, `progress`,
- *   `select`, `textarea`, and `input` (excluding `[type=hidden]`).
+ *   Labelable elements are `button`, `input` (excluding `[type=hidden]`),
+ *   `keygen`, `meter`, `output`, `progress`, `select`, and `textarea`.
  */
 export function labelable(node) {
   return Boolean(
     node &&
       typeof node === 'object' &&
       node.type === 'element' &&
       (node.tagName === 'button' ||
+        (node.tagName === 'input' &&
+          (node.properties && node.properties.type) !== 'hidden') ||
         node.tagName === 'keygen' ||
         node.tagName === 'meter' ||
         node.tagName === 'output' ||
         node.tagName === 'progress' ||
         node.tagName === 'select' ||
-        node.tagName === 'textarea' ||
-        (node.tagName === 'input' &&
-          (node.properties && node.properties.type) !== 'hidden'))
+        node.tagName === 'textarea')
   )
 }

test.js

@@ -1,126 +1,152 @@
 import assert from 'node:assert/strict'
 import test from 'node:test'
 import {labelable} from './index.js'
-import * as mod from './index.js'
 
-test('labelable', () => {
-  assert.deepEqual(
-    Object.keys(mod).sort(),
-    ['labelable'],
-    'should expose the public api'
-  )
+test('labelable', async function (t) {
+  await t.test('should expose the public api', async function () {
+    assert.deepEqual(Object.keys(await import('./index.js')).sort(), [
+      'labelable'
+    ])
+  })
 
-  // @ts-expect-error: runtime.
-  assert.equal(labelable(), false, 'should return `false` without node')
+  await t.test('should return `false` without node', async function () {
+    // @ts-expect-error: check that the runtime supports a missing node.
+    assert.equal(labelable(), false)
+  })
 
-  assert.equal(
-    labelable({type: 'text', value: 'Alpha'}),
-    false,
-    'should return `false` without element'
-  )
+  await t.test('should return `false` without element', async function () {
+    assert.equal(labelable({type: 'text', value: 'Alpha'}), false)
+  })
 
-  assert.equal(
-    labelable({type: 'element', tagName: 'div', properties: {}, children: []}),
-    false,
-    'should return `false` for non-labelable elements'
+  await t.test(
+    'should return `false` for non-labelable elements',
+    async function () {
+      assert.equal(
+        labelable({
+          type: 'element',
+          tagName: 'div',
+          properties: {},
+          children: []
+        }),
+        false
+      )
+    }
   )
 
-  assert.equal(
-    labelable({
-      type: 'element',
-      tagName: 'input',
-      properties: {},
-      children: []
-    }),
-    true,
-    'should return `true` for `input` elements'
-  )
+  await t.test('should return `true` for `input` elements', async function () {
+    assert.equal(
+      labelable({
+        type: 'element',
+        tagName: 'input',
+        properties: {},
+        children: []
+      }),
+      true
+    )
+  })
 
-  assert.equal(
-    labelable({
-      type: 'element',
-      tagName: 'input',
-      properties: {type: 'hidden'},
-      children: []
-    }),
-    false,
-    'should return `false` for `input[type=hidden]` elements'
+  await t.test(
+    'should return `false` for `input[type=hidden]` elements',
+    async function () {
+      assert.equal(
+        labelable({
+          type: 'element',
+          tagName: 'input',
+          properties: {type: 'hidden'},
+          children: []
+        }),
+        false
+      )
+    }
   )
 
-  assert.equal(
-    labelable({
-      type: 'element',
-      tagName: 'button',
-      properties: {},
-      children: []
-    }),
-    true,
-    'should return `true` for `button` elements'
-  )
+  await t.test('should return `true` for `button` elements', async function () {
+    assert.equal(
+      labelable({
+        type: 'element',
+        tagName: 'button',
+        properties: {},
+        children: []
+      }),
+      true
+    )
+  })
 
-  assert.equal(
-    labelable({
-      type: 'element',
-      tagName: 'keygen',
-      properties: {},
-      children: []
-    }),
-    true,
-    'should return `true` for `keygen` elements'
-  )
+  await t.test('should return `true` for `keygen` elements', async function () {
+    assert.equal(
+      labelable({
+        type: 'element',
+        tagName: 'keygen',
+        properties: {},
+        children: []
+      }),
+      true
+    )
+  })
 
-  assert.equal(
-    labelable({
-      type: 'element',
-      tagName: 'meter',
-      properties: {},
-      children: []
-    }),
-    true,
-    'should return `true` for `meter` elements'
-  )
+  await t.test('should return `true` for `meter` elements', async function () {
+    assert.equal(
+      labelable({
+        type: 'element',
+        tagName: 'meter',
+        properties: {},
+        children: []
+      }),
+      true
+    )
+  })
 
-  assert.equal(
-    labelable({
-      type: 'element',
-      tagName: 'output',
-      properties: {},
-      children: []
-    }),
-    true,
-    'should return `true` for `output` elements'
-  )
+  await t.test('should return `true` for `output` elements', async function () {
+    assert.equal(
+      labelable({
+        type: 'element',
+        tagName: 'output',
+        properties: {},
+        children: []
+      }),
+      true
+    )
+  })
 
-  assert.equal(
-    labelable({
-      type: 'element',
-      tagName: 'progress',
-      properties: {},
-      children: []
-    }),
-    true,
-    'should return `true` for `progress` elements'
+  await t.test(
+    'should return `true` for `progress` elements',
+    async function () {
+      assert.equal(
+        labelable({
+          type: 'element',
+          tagName: 'progress',
+          properties: {},
+          children: []
+        }),
+        true
+      )
+    }
   )
 
-  assert.equal(
-    labelable({
-      type: 'element',
-      tagName: 'select',
-      properties: {},
-      children: []
-    }),
-    true,
-    'should return `true` for `select` elements'
-  )
+  await t.test('should return `true` for `select` elements', async function () {
+    assert.equal(
+      labelable({
+        type: 'element',
+        tagName: 'select',
+        properties: {},
+        children: []
+      }),
+      true
+    )
+  })
 
-  assert.equal(
-    labelable({
-      type: 'element',
-      tagName: 'textarea',
-      properties: {},
-      children: []
-    }),
-    true,
-    'should return `true` for `textarea` elements'
+  await t.test(
+    'should return `true` for `textarea` elements',
+    async function () {
+      assert.equal(
+        labelable({
+          type: 'element',
+          tagName: 'textarea',
+          properties: {},
+          children: []
+        }),
+        true
+      )
+    }
   )
 })