Refactor internal types

Author: wooorm

index.js

@@ -4,6 +4,7 @@
  * @typedef {import('./lib/types.js').Space} Space
  */
 
+import {html, svg} from 'property-information'
 import {any} from './lib/any.js'
 import {parse} from './lib/parse.js'
 
@@ -25,13 +26,10 @@ import {parse} from './lib/parse.js'
  *   Whether `node` matches `selector`.
  */
 export function matches(selector, node, space) {
-  return Boolean(
-    any(parse(selector), node || undefined, {
-      space: space || undefined,
-      one: true,
-      shallow: true
-    })[0]
-  )
+  const state = createState(node, space)
+  state.one = true
+  state.shallow = true
+  return Boolean(any(parse(selector), node || undefined, state)[0])
 }
 
 /**
@@ -44,19 +42,16 @@ export function matches(selector, node, space) {
  *   Tree to search.
  * @param {Space | null | undefined} [space='html']
  *   Name of namespace (`'svg'` or `'html'`).
- * @returns {Element|null}
+ * @returns {Element | null}
  *   First element in `tree` that matches `selector` or `null` if nothing is
  *   found.
  *   This could be `tree` itself.
  */
 export function select(selector, tree, space) {
+  const state = createState(tree, space)
+  state.one = true
   // To do in major: return `undefined` instead.
-  return (
-    any(parse(selector), tree || undefined, {
-      space: space || undefined,
-      one: true
-    })[0] || null
-  )
+  return any(parse(selector), tree || undefined, state)[0] || null
 }
 
 /**
@@ -74,5 +69,33 @@ export function select(selector, tree, space) {
  *   This could include `tree` itself.
  */
 export function selectAll(selector, tree, space) {
-  return any(parse(selector), tree || undefined, {space: space || undefined})
+  const state = createState(tree, space)
+  return any(parse(selector), tree || undefined, state)
+}
+
+/**
+ * @param {Node | null | undefined} [tree]
+ *   Tree to search.
+ * @param {Space | null | undefined} [space='html']
+ *   Name of namespace (`'svg'` or `'html'`).
+ * @returns {import('./lib/types.js').SelectState} SelectState
+ */
+function createState(tree, space) {
+  return {
+    // @ts-expect-error assume elements.
+    scopeElements: tree ? (tree.type === 'root' ? tree.children : [tree]) : [],
+    iterator: undefined,
+    one: false,
+    shallow: false,
+    index: false,
+    found: false,
+    schema: space === 'svg' ? svg : html,
+    language: undefined,
+    direction: 'ltr',
+    editableOrEditingHost: false,
+    typeIndex: undefined,
+    elementIndex: undefined,
+    typeCount: undefined,
+    elementCount: undefined
+  }
 }

lib/any.js

@@ -8,62 +8,86 @@
  * @typedef {import('./types.js').SelectState} SelectState
  */
 
-import {html, svg} from 'property-information'
 import {zwitch} from 'zwitch'
 import {enterState} from './enter-state.js'
 import {nest} from './nest.js'
 import {pseudo} from './pseudo.js'
 import {test} from './test.js'
 
-/** @type {(query: Selectors|RuleSet|Rule, element: Node, state: SelectState) => Array<Element>} */
+/** @type {(query: Selectors | RuleSet | Rule, element: Node, state: SelectState) => Array<Element>} */
 const type = zwitch('type', {
   unknown: unknownType,
   invalid: invalidType,
   handlers: {selectors, ruleSet, rule}
 })
 
 /**
- * @param {Selectors|RuleSet|Rule} query
- * @param {Node|undefined} node
+ * Handle an optional query and node.
+ *
+ * @param {Selectors | RuleSet | Rule | undefined} query
+ *   Thing to find.
+ * @param {Node | undefined} node
+ *   Tree.
  * @param {SelectState} state
+ *   State.
  * @returns {Array<Element>}
+ *   Results.
  */
 export function any(query, node, state) {
   return query && node ? type(query, node, state) : []
 }
 
 /**
+ * Handle selectors.
+ *
  * @param {Selectors} query
+ *   Multiple selectors.
  * @param {Node} node
+ *   Tree.
  * @param {SelectState} state
+ *   State.
  * @returns {Array<Element>}
+ *   Results.
  */
 function selectors(query, node, state) {
   const collector = new Collector(state.one)
   let index = -1
 
   while (++index < query.selectors.length) {
-    collector.collectAll(ruleSet(query.selectors[index], node, state))
+    const set = query.selectors[index]
+    collector.collectAll(rule(set.rule, node, state))
   }
 
   return collector.result
 }
 
 /**
+ * Handle a selector.
+ *
  * @param {RuleSet} query
+ *   One selector.
  * @param {Node} node
+ *   Tree.
  * @param {SelectState} state
+ *   State.
  * @returns {Array<Element>}
+ *   Results.
  */
 function ruleSet(query, node, state) {
   return rule(query.rule, node, state)
 }
 
 /**
+ * Handle a rule.
+ *
  * @param {Rule} query
+ *   One rule.
  * @param {Node} tree
+ *   Tree.
  * @param {SelectState} state
+ *   State.
  * @returns {Array<Element>}
+ *   Results.
  */
 function rule(query, tree, state) {
   const collector = new Collector(state.one)
@@ -72,30 +96,11 @@ function rule(query, tree, state) {
     throw new Error('Expected selector without nesting')
   }
 
-  nest(
-    query,
-    tree,
-    0,
-    undefined,
-    configure(query, {
-      // @ts-expect-error assume elements.
-      scopeElements: tree.type === 'root' ? tree.children : [tree],
-      iterator,
-      one: state.one,
-      shallow: state.shallow,
-      index: false,
-      found: false,
-      space: state.space,
-      schema: state.space === 'svg' ? svg : html,
-      language: undefined,
-      direction: 'ltr',
-      editableOrEditingHost: false,
-      typeIndex: state.typeIndex,
-      elementIndex: state.elementIndex,
-      typeCount: state.typeCount,
-      elementCount: state.elementCount
-    })
-  )
+  nest(query, tree, 0, undefined, {
+    ...state,
+    iterator,
+    index: needsIndex(query)
+  })
 
   return collector.result
 
@@ -105,7 +110,11 @@ function rule(query, tree, state) {
 
     if (test(query, node, index, parent, state)) {
       if (query.rule) {
-        nest(query.rule, node, index, parent, configure(query.rule, state))
+        nest(query.rule, node, index, parent, {
+          ...state,
+          iterator,
+          index: needsIndex(query.rule)
+        })
       } else {
         // @ts-expect-error `test` also asserts `node is Element`
         collector.collect(node)
@@ -115,26 +124,25 @@ function rule(query, tree, state) {
 
     exit()
   }
+}
 
-  /**
-   * @template {SelectState} S
-   * @param {Rule} query
-   * @param {S} state
-   * @returns {S}
-   */
-  function configure(query, state) {
-    const pseudos = query.pseudos || []
-    let index = -1
+/**
+ * Check if indexing is needed.
+ *
+ * @param {Rule} query
+ * @returns {boolean}
+ */
+function needsIndex(query) {
+  const pseudos = query.pseudos || []
+  let index = -1
 
-    while (++index < pseudos.length) {
-      if (pseudo.needsIndex.includes(pseudos[index].name)) {
-        state.index = true
-        break
-      }
+  while (++index < pseudos.length) {
+    if (pseudo.needsIndex.includes(pseudos[index].name)) {
+      return true
     }
-
-    return state
   }
+
+  return false
 }
 
 // Shouldn’t be called, all data is handled.
@@ -154,21 +162,38 @@ function invalidType() {
   throw new Error('Invalid type')
 }
 
+/**
+ * Collect elements.
+ */
 class Collector {
   /**
-   * @param {boolean|undefined} [one]
+   * @param {boolean | undefined} one
    */
   constructor(one) {
-    /** @type {Array<Element>} */
+    /**
+     * Found elements.
+     *
+     * @type {Array<Element>}
+     */
     this.result = []
-    /** @type {boolean|undefined} */
-    this.one = one
-    /** @type {boolean} */
+
+    /**
+     * Whether we’re looking for one result.
+     *
+     * @type {boolean}
+     */
+    this.one = one || false
+
+    /**
+     * Whether we’ve found something.
+     *
+     * @type {boolean}
+     */
     this.found = false
   }
 
   /**
-   * Append nodes to array, filtering out duplicates.
+   * Add multiple elements.
    *
    * @param {Array<Element>} elements
    */
@@ -181,7 +206,7 @@ class Collector {
   }
 
   /**
-   * Append one node.
+   * Add one element.
    *
    * @param {Element} element
    */

lib/attribute.js

@@ -87,7 +87,7 @@ function spaceSeparatedList(query, element, info) {
   const value = element.properties && element.properties[info.property]
 
   return (
-    // If this is a comma-separated list, and the query is contained in it, return
+    // If this is a space-separated list, and the query is contained in it, return
     // true.
     (!info.commaSeparated &&
       value &&