Refactor to remove unneeded utilities

Author: wooorm

index.js

@@ -7,7 +7,7 @@
 
 import {any} from './lib/any.js'
 import {parse} from './lib/parse.js'
-import {root} from './lib/util.js'
+import {parent} from './lib/util.js'
 
 /**
  * Check that the given `node` matches `selector`.
@@ -84,7 +84,13 @@ function createState(tree) {
     results: [],
     any,
     iterator: undefined,
-    scopeNodes: tree ? (root(tree) ? tree.children : [tree]) : [],
+    scopeNodes: tree
+      ? parent(tree) &&
+        // Root in nlcst.
+        (tree.type === 'RootNode' || tree.type === 'root')
+        ? tree.children
+        : [tree]
+      : [],
     one: false,
     shallow: false,
     index: false,

lib/attribute.js

@@ -36,6 +36,8 @@ export function attribute(query, node) {
 }
 
 /**
+ * Check whether an attribute exists.
+ *
  * `[attr]`
  *
  * @param {RuleAttr} query
@@ -48,6 +50,8 @@ function exists(query, node) {
 }
 
 /**
+ * Check whether an attribute has an exact value.
+ *
  * `[attr=value]`
  *
  * @param {RuleAttr} query
@@ -60,6 +64,11 @@ function exact(query, node) {
 }
 
 /**
+ * Check whether an attribute, as a list, contains a value.
+ *
+ * When the attribute value is not a list, checks that the serialized value
+ * is the queried one.
+ *
  * `[attr~=value]`
  *
  * @param {RuleAttr} query
@@ -86,6 +95,8 @@ function containsArray(query, node) {
 }
 
 /**
+ * Check whether an attribute has a substring as its start.
+ *
  * `[attr^=value]`
  *
  * @param {RuleAttr} query
@@ -105,6 +116,8 @@ function begins(query, node) {
 }
 
 /**
+ * Check whether an attribute has a substring as its end.
+ *
  * `[attr$=value]`
  *
  * @param {RuleAttr} query
@@ -124,6 +137,8 @@ function ends(query, node) {
 }
 
 /**
+ * Check whether an attribute contains a substring.
+ *
  * `[attr*=value]`
  *
  * @param {RuleAttr} query

lib/name.js

@@ -4,6 +4,8 @@
  */
 
 /**
+ * Check whether an element has a type.
+ *
  * @param {Rule} query
  * @param {Node} node
  */

lib/nest.js

@@ -18,13 +18,15 @@ const handle = zwitch('nestingOperator', {
   invalid: topScan, // `undefined` is the top query selector.
   handlers: {
     null: descendant, // `null` is the descendant combinator.
-    '>': child,
+    '>': directChild,
     '+': adjacentSibling,
     '~': generalSibling
   }
 })
 
 /**
+ * Nest a rule.
+ *
  * @param {Rule} query
  * @param {Node} node
  * @param {number | undefined} index
@@ -35,31 +37,16 @@ export function nest(query, node, index, parent, state) {
   handle(query, node, index, parent, state)
 }
 
-// Shouldn’t be called, parser gives correct data.
-/**
- * @param {unknown} query
- * @returns {never}
- */
-/* c8 ignore next 4 */
-function unknownNesting(query) {
-  // @ts-expect-error: `nestingOperator` guaranteed.
-  throw new Error('Unexpected nesting `' + query.nestingOperator + '`')
-}
-
 /**
+ * Top-most scan.
+ *
  * @param {Rule} query
  * @param {Node} node
  * @param {number | undefined} index
  * @param {Parent | undefined} parent
  * @param {SelectState} state
  */
 function topScan(query, node, index, parent, state) {
-  // Shouldn’t happen.
-  /* c8 ignore next 7 */
-  if (parent) {
-    throw new Error('topScan is supposed to be called from the root node')
-  }
-
   if (!state.iterator) {
     throw new Error('Expected `iterator` to be defined')
   }
@@ -75,6 +62,8 @@ function topScan(query, node, index, parent, state) {
 }
 
 /**
+ * Handle a descendant nesting operator (`a b`).
+ *
  * @param {Rule} query
  * @param {Node} node
  * @param {number | undefined} index
@@ -90,36 +79,40 @@ function descendant(query, node, index, parent, state) {
 
   const previous = state.iterator
 
-  state.iterator = iterator
-  child(query, node, index, parent, state)
+  state.iterator = descendantIterator
+  directChild(query, node, index, parent, state)
 
   /** @type {SelectIterator} */
-  function iterator(query, node, index, parent, state) {
+  function descendantIterator(query, node, index, parent, state) {
     state.iterator = previous
     previous(query, node, index, parent, state)
-    state.iterator = iterator
+    state.iterator = descendantIterator
 
     if (state.one && state.found) return
 
-    child(query, node, index, parent, state)
+    directChild(query, node, index, parent, state)
   }
 }
 
 /**
+ * Handle a direct child nesting operator (`a > b`).
+ *
+ * Also reused by normal descendant operators.
+ *
  * @param {Rule} query
  * @param {Node} node
  * @param {number | undefined} _1
  * @param {Parent | undefined} _2
  * @param {SelectState} state
  */
-function child(query, node, _1, _2, state) {
-  if (!parent(node)) return
-  if (node.children.length === 0) return
-
+function directChild(query, node, _1, _2, state) {
+  if (!parent(node) || node.children.length === 0) return
   new WalkIterator(query, node, state).each(undefined, undefined).done()
 }
 
 /**
+ * Handle an adjacent sibling nesting operator (`a + b`).
+ *
  * @param {Rule} query
  * @param {Node} _
  * @param {number | undefined} index
@@ -145,6 +138,8 @@ function adjacentSibling(query, _, index, parent, state) {
 }
 
 /**
+ * Handle a general sibling nesting operator (`a ~ b`).
+ *
  * @param {Rule} query
  * @param {Node} _
  * @param {number | undefined} index
@@ -168,6 +163,17 @@ function generalSibling(query, _, index, parent, state) {
     .done()
 }
 
+// Shouldn’t be called, parser gives correct data.
+/**
+ * @param {unknown} query
+ * @returns {never}
+ */
+/* c8 ignore next 4 */
+function unknownNesting(query) {
+  // @ts-expect-error: `nestingOperator` guaranteed.
+  throw new Error('Unexpected nesting `' + query.nestingOperator + '`')
+}
+
 class WalkIterator {
   /**
    * Handles typeIndex and typeCount properties for every walker.