Refactor code-style

Author: wooorm

index.js

@@ -84,6 +84,7 @@ export function selectAll(selector, tree) {
  * @param {Node | null | undefined} tree
  *   Tree to search.
  * @returns {SelectState}
+ *   State.
  */
 function createState(selector, tree) {
   return {

lib/attribute.js

@@ -6,6 +6,7 @@
 
 import {unreachable} from 'devlop'
 import {zwitch} from 'zwitch'
+import {indexable} from './util.js'
 
 /** @type {(query: AstAttribute, node: Node) => boolean} */
 const handle = zwitch('operator', {
@@ -48,7 +49,7 @@ export function attribute(query, node) {
  * @returns {boolean}
  */
 function exists(query, node) {
-  // @ts-expect-error: Looks like a record.
+  indexable(node)
   return node[query.name] !== null && node[query.name] !== undefined
 }
 
@@ -63,8 +64,7 @@ function exists(query, node) {
  */
 function exact(query, node) {
   const queryValue = attributeValue(query)
-
-  // @ts-expect-error: Looks like a record.
+  indexable(node)
   return exists(query, node) && String(node[query.name]) === queryValue
 }
 
@@ -81,8 +81,7 @@ function exact(query, node) {
  * @returns {boolean}
  */
 function containsArray(query, node) {
-  /** @type {unknown} */
-  // @ts-expect-error: Looks like a record.
+  indexable(node)
   const value = node[query.name]
 
   if (value === null || value === undefined) return false
@@ -111,8 +110,7 @@ function containsArray(query, node) {
  * @returns {boolean}
  */
 function begins(query, node) {
-  /** @type {unknown} */
-  // @ts-expect-error: Looks like a record.
+  indexable(node)
   const value = node[query.name]
   const queryValue = attributeValue(query)
 

lib/parse.js

@@ -6,13 +6,6 @@ import {createParser} from 'css-selector-parser'
 
 const cssSelectorParse = createParser({syntax: 'selectors-4'})
 
-// .
-// const parser = new CssSelectorParser()
-
-// parser.registerAttrEqualityMods('~', '^', '$', '*')
-// parser.registerSelectorPseudos('any', 'matches', 'not', 'has')
-// parser.registerNestingOperators('>', '+', '~')
-
 /**
  * @param {string} selector
  * @returns {AstSelector}

lib/pseudo.js

@@ -13,7 +13,7 @@ import {parent} from './util.js'
 import {walk} from './walk.js'
 
 /** @type {import('nth-check').default} */
-// @ts-expect-error
+// @ts-expect-error: `nth-check` types are wrong.
 const nthCheck = fauxEsmNthCheck.default || fauxEsmNthCheck
 
 /** @type {(rule: AstPseudoClass, node: Node, index: number | undefined, parent: Parent | undefined, state: SelectState) => boolean} */

lib/util.js

@@ -3,11 +3,32 @@
  * @typedef {import('unist').Parent} Parent
  */
 
+import {unreachable} from 'devlop'
+
+/**
+ * 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.
+ */
+export function indexable(value) {
+  // Always called when something is an object, this is just for TS.
+  /* c8 ignore next 3 */
+  if (!value || typeof value !== 'object') {
+    unreachable('Expected object')
+  }
+}
+
 /**
  * @param {Node} node
  * @returns {node is Parent}
  */
 export function parent(node) {
-  // @ts-expect-error: looks like a record.
+  indexable(node)
   return Array.isArray(node.children)
 }

lib/walk.js

@@ -84,7 +84,7 @@ function one(state, currentRules, node, index, parentNode) {
  * @param {SelectState} state
  * @param {Nest} nest
  * @param {Parent} node
- * @returns {void}
+ * @returns {undefined}
  */
 function all(state, nest, node) {
   const fromParent = combine(nest.descendant, nest.directChild)
@@ -256,7 +256,7 @@ function add(nest, field, rule) {
  *   Counts.
  * @param {Node} node
  *   Node.
- * @returns {void}
+ * @returns {undefined}
  *   Nothing.
  */
 function count(counts, node) {

package.json

@@ -99,6 +99,8 @@
           "test/**/*.js"
         ],
         "rules": {
+          "import/no-unassigned-import": "off",
+          "max-nested-callbacks": "off",
           "no-await-in-loop": "off"
         }
       }

test/all.js

@@ -3,98 +3,116 @@ import test from 'node:test'
 import {u} from 'unist-builder'
 import {selectAll} from '../index.js'
 
-test('all together now', () => {
-  assert.deepEqual(
-    selectAll(
-      'a > b[d]:nth-of-type(odd)',
-      u('root', [
-        u('a', [
-          u('b', {d: 1}, 'Alpha'),
-          u('c', 'Bravo'),
-          u('b', 'Charlie'),
-          u('c', 'Delta'),
-          u('b', 'Echo'),
-          u('c', 'Foxtrot')
+test('all together now', async function (t) {
+  await t.test('should expose the public api', async function () {
+    assert.deepEqual(Object.keys(await import('../index.js')).sort(), [
+      'matches',
+      'select',
+      'selectAll'
+    ])
+  })
+
+  await t.test('#1', async function () {
+    assert.deepEqual(
+      selectAll(
+        'a > b[d]:nth-of-type(odd)',
+        u('root', [
+          u('a', [
+            u('b', {d: 1}, 'Alpha'),
+            u('c', 'Bravo'),
+            u('b', 'Charlie'),
+            u('c', 'Delta'),
+            u('b', 'Echo'),
+            u('c', 'Foxtrot')
+          ])
         ])
-      ])
-    ),
-    [u('b', {d: 1}, 'Alpha')]
-  )
+      ),
+      [u('b', {d: 1}, 'Alpha')]
+    )
+  })
 
-  assert.deepEqual(
-    selectAll(
-      '[d] ~ c:nth-of-type(even)',
-      u('root', [
-        u('a', [
-          u('b', 'Alpha'),
-          u('c', 'Bravo'),
-          u('b', {d: 1}, 'Charlie'),
-          u('c', 'Delta'),
-          u('b', 'Echo'),
-          u('c', 'Foxtrot'),
-          u('b', 'Golf'),
-          u('c', 'Hotel')
+  await t.test('#2', async function () {
+    assert.deepEqual(
+      selectAll(
+        '[d] ~ c:nth-of-type(even)',
+        u('root', [
+          u('a', [
+            u('b', 'Alpha'),
+            u('c', 'Bravo'),
+            u('b', {d: 1}, 'Charlie'),
+            u('c', 'Delta'),
+            u('b', 'Echo'),
+            u('c', 'Foxtrot'),
+            u('b', 'Golf'),
+            u('c', 'Hotel')
+          ])
         ])
-      ])
-    ),
-    [u('c', 'Delta'), u('c', 'Hotel')]
-  )
+      ),
+      [u('c', 'Delta'), u('c', 'Hotel')]
+    )
+  })
 
-  assert.deepEqual(
-    selectAll(
-      '[d] + c:nth-of-type(even)',
-      u('root', [
-        u('a', [
-          u('b', 'Alpha'),
-          u('c', 'Bravo'),
-          u('b', {d: 1}, 'Charlie'),
-          u('c', 'Delta'),
-          u('b', 'Echo'),
-          u('c', 'Foxtrot'),
-          u('b', 'Golf'),
-          u('c', 'Hotel')
+  await t.test('#3', async function () {
+    assert.deepEqual(
+      selectAll(
+        '[d] + c:nth-of-type(even)',
+        u('root', [
+          u('a', [
+            u('b', 'Alpha'),
+            u('c', 'Bravo'),
+            u('b', {d: 1}, 'Charlie'),
+            u('c', 'Delta'),
+            u('b', 'Echo'),
+            u('c', 'Foxtrot'),
+            u('b', 'Golf'),
+            u('c', 'Hotel')
+          ])
         ])
-      ])
-    ),
-    [u('c', 'Delta')]
-  )
+      ),
+      [u('c', 'Delta')]
+    )
+  })
 
-  assert.deepEqual(
-    selectAll(
-      '[d], :nth-of-type(even), [e]',
-      u('root', [
-        u('a', [
-          u('b', {e: 3}, 'Alpha'),
-          u('c', 'Bravo'),
-          u('b', {d: 1}, 'Charlie'),
-          u('c', 'Delta'),
-          u('b', 'Echo'),
-          u('c', {d: 2, e: 4}, 'Foxtrot'),
-          u('b', 'Golf'),
-          u('c', 'Hotel')
+  await t.test('#4', async function () {
+    assert.deepEqual(
+      selectAll(
+        '[d], :nth-of-type(even), [e]',
+        u('root', [
+          u('a', [
+            u('b', {e: 3}, 'Alpha'),
+            u('c', 'Bravo'),
+            u('b', {d: 1}, 'Charlie'),
+            u('c', 'Delta'),
+            u('b', 'Echo'),
+            u('c', {d: 2, e: 4}, 'Foxtrot'),
+            u('b', 'Golf'),
+            u('c', 'Hotel')
+          ])
         ])
-      ])
-    ),
-    [
-      u('b', {e: 3}, 'Alpha'),
-      u('b', {d: 1}, 'Charlie'),
-      u('c', 'Delta'),
-      u('c', {d: 2, e: 4}, 'Foxtrot'),
-      u('b', 'Golf'),
-      u('c', 'Hotel')
-    ]
-  )
+      ),
+      [
+        u('b', {e: 3}, 'Alpha'),
+        u('b', {d: 1}, 'Charlie'),
+        u('c', 'Delta'),
+        u('c', {d: 2, e: 4}, 'Foxtrot'),
+        u('b', 'Golf'),
+        u('c', 'Hotel')
+      ]
+    )
+  })
 
-  assert.deepEqual(
-    selectAll(
-      'a:not([b])',
-      u('root', [
-        u('a', {id: 'w', b: 'a'}),
-        u('a', {id: 'x'}),
-        u('a', {id: 'y', b: 'a'}),
-        u('a', {id: 'z'})
-      ])
-    ),
-    [u('a', {id: 'x'}), u('a', {id: 'z'})]
-  )
+  await t.test('#5', async function () {
+    assert.deepEqual(
+      selectAll(
+        'a:not([b])',
+        u('root', [
+          u('a', {id: 'w', b: 'a'}),
+          u('a', {id: 'x'}),
+          u('a', {id: 'y', b: 'a'}),
+          u('a', {id: 'z'})
+        ])
+      ),
+      [u('a', {id: 'x'}), u('a', {id: 'z'})]
+    )
+  })
 })

test/index.js

@@ -1,6 +1,4 @@
-/* eslint-disable import/no-unassigned-import */
+import './all.js'
 import './matches.js'
 import './select.js'
 import './select-all.js'
-import './all.js'
-/* eslint-enable import/no-unassigned-import */