Refactor code-style

Author: wooorm

lib/index.js

@@ -1,15 +1,18 @@
 /**
- * @typedef {import('unist').Node} UnistNode
  * @typedef {import('estree-jsx').Node} EstreeNode
- *
+ * @typedef {import('unist').Node} UnistNode
+ */
+
+/**
  * @typedef Options
- *   Configuration (optional).
+ *   Configuration.
  * @property {boolean | null | undefined} [dirty=false]
- *   Leave discouraged fields in the tree.
+ *   Leave discouraged fields in the tree (default: `false`).
  */
 
-import {positionFromEstree} from 'unist-util-position-from-estree'
+import {ok as assert} from 'devlop'
 import {visit} from 'estree-util-visit'
+import {positionFromEstree} from 'unist-util-position-from-estree'
 
 const own = {}.hasOwnProperty
 
@@ -37,7 +40,7 @@ export function fromEstree(estree, options = {}) {
           ? parent
           : // @ts-expect-error: indexable.
             parent[field]
-      /** @type {string | number | undefined} */
+      /** @type {number | string | undefined} */
       const prop = index === undefined ? field : index
       /** @type {UnistNode} */
       const copy = {}
@@ -60,8 +63,7 @@ export function fromEstree(estree, options = {}) {
             continue
           }
 
-          /** @type {unknown} */
-          // @ts-expect-error: indexable.
+          indexable(node)
           let value = node[key]
 
           // If this is a bigint or regex literal, reset value.
@@ -90,7 +92,7 @@ export function fromEstree(estree, options = {}) {
             }
           }
 
-          // @ts-expect-error: indexable.
+          indexable(copy)
           copy[key] = value
         }
       }
@@ -100,12 +102,27 @@ export function fromEstree(estree, options = {}) {
       if (prop === undefined) {
         tail = copy
       } else {
-        // @ts-expect-error: indexable.
+        indexable(context)
         context[prop] = copy
       }
     }
   })
 
-  // @ts-expect-error: always one node.
+  assert(tail, 'expected a node')
   return tail
 }
+
+/**
+ * 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) {
+  assert(value && typeof value === 'object', 'expected object')
+}

package.json

@@ -38,6 +38,7 @@
   "types": "index.d.ts",
   "dependencies": {
     "@types/estree-jsx": "^1.0.0",
+    "devlop": "^1.0.0",
     "estree-util-visit": "^2.0.0",
     "unist-util-position-from-estree": "^2.0.0"
   },

test.js

@@ -1,25 +1,31 @@
+/**
+ * @typedef {import('estree-jsx').Program} EstreeProgram
+ */
+
 import assert from 'node:assert/strict'
 import test from 'node:test'
 import {Parser} from 'acorn'
 import jsx from 'acorn-jsx'
 import {fromEstree} from './index.js'
-import * as mod from './index.js'
 
 const parser = Parser.extend(jsx())
 
-test('fromEstree', () => {
-  assert.deepEqual(
-    Object.keys(mod).sort(),
-    ['fromEstree'],
-    'should expose the public api'
-  )
+test('fromEstree', async function (t) {
+  await t.test('should expose the public api', async function () {
+    assert.deepEqual(Object.keys(await import('./index.js')).sort(), [
+      'fromEstree'
+    ])
+  })
+
+  await t.test('should transform', async function () {
+    /** @type {EstreeProgram} */
+    // @ts-expect-error: acorn looks like estree.
+    const tree = parser.parse('console.log(1)', {
+      locations: true,
+      ecmaVersion: 2021
+    })
 
-  assert.deepEqual(
-    fromEstree(
-      // @ts-expect-error Similar enough.
-      parser.parse('console.log(1)', {locations: true, ecmaVersion: 2021})
-    ),
-    {
+    assert.deepEqual(fromEstree(tree), {
       type: 'Program',
       body: [
         {
@@ -78,35 +84,35 @@ test('fromEstree', () => {
         start: {line: 1, column: 1, offset: 0},
         end: {line: 1, column: 15, offset: 14}
       }
-    },
-    'should transform'
-  )
+    })
+  })
 
-  assert.deepEqual(
-    fromEstree(
-      // @ts-expect-error Hush, it’s fine.
-      parser.parse('/(?:)/', {locations: true, ecmaVersion: 2021}).body[0]
-        .expression
-    ),
-    {
+  await t.test('should transform regexes', async function () {
+    /** @type {EstreeProgram} */
+    // @ts-expect-error: acorn looks like estree.
+    const tree = parser.parse('/(?:)/', {locations: true, ecmaVersion: 2021})
+    const statement = tree.body[0]
+    assert(statement.type === 'ExpressionStatement')
+
+    assert.deepEqual(fromEstree(statement.expression), {
       type: 'Literal',
       value: null,
       regex: {pattern: '(?:)', flags: ''},
       position: {
         start: {line: 1, column: 1, offset: 0},
         end: {line: 1, column: 7, offset: 6}
       }
-    },
-    'should transform regexes'
-  )
+    })
+  })
+
+  await t.test('should transform jsx fragments', async function () {
+    /** @type {EstreeProgram} */
+    // @ts-expect-error: acorn looks like estree.
+    const tree = parser.parse('<>b</>', {locations: true, ecmaVersion: 2021})
+    const statement = tree.body[0]
+    assert(statement.type === 'ExpressionStatement')
 
-  assert.deepEqual(
-    fromEstree(
-      // @ts-expect-error Hush, it’s fine.
-      parser.parse('<>b</>', {locations: true, ecmaVersion: 2021}).body[0]
-        .expression
-    ),
-    {
+    assert.deepEqual(fromEstree(statement.expression), {
       type: 'JSXFragment',
       openingFragment: {
         type: 'JSXOpeningFragment',
@@ -136,32 +142,36 @@ test('fromEstree', () => {
         start: {line: 1, column: 1, offset: 0},
         end: {line: 1, column: 7, offset: 6}
       }
-    },
-    'should transform jsx fragments'
-  )
+    })
+  })
 
-  const bigInts = [
-    ['1n', 'dec'],
-    ['0X1n', 'hex, cap'],
-    ['0x1n', 'hex, low'],
-    ['0O1n', 'oct, cap'],
-    ['0o1n', 'oct, low'],
-    ['0B1n', 'bin, cap'],
-    ['0b1n', 'bin, low']
-  ]
-  let index = -1
+  await t.test('should transform and normalize bigints', async function () {
+    const bigInts = [
+      ['1n', 'dec'],
+      ['0X1n', 'hex, cap'],
+      ['0x1n', 'hex, low'],
+      ['0O1n', 'oct, cap'],
+      ['0o1n', 'oct, low'],
+      ['0B1n', 'bin, cap'],
+      ['0b1n', 'bin, low']
+    ]
+    let index = -1
 
-  while (++index < bigInts.length) {
-    const tree = fromEstree(
-      // @ts-expect-error Hush, it’s fine.
-      parser.parse(bigInts[index][0], {locations: true, ecmaVersion: 2021})
-    )
+    while (++index < bigInts.length) {
+      /** @type {EstreeProgram} */
+      // @ts-expect-error: acorn looks like estree.
+      const tree = parser.parse(bigInts[index][0], {
+        locations: true,
+        ecmaVersion: 2021
+      })
+      fromEstree(tree)
+      const statement = tree.body[0]
+      assert(statement.type === 'ExpressionStatement')
+      const expression = statement.expression
+      assert(expression.type === 'Literal')
+      assert('bigint' in expression)
 
-    assert.deepEqual(
-      // @ts-expect-error Hush, it’s fine.
-      tree.body[0].expression.bigint,
-      '1',
-      'should transform and normalize bigints (`' + bigInts[index][1] + '`)'
-    )
-  }
+      assert.deepEqual(expression.bigint, '1')
+    }
+  })
 })