Refactor collecting of results

Author: wooorm

index.js

@@ -2,6 +2,7 @@
  * @typedef {import('./lib/types.js').Element} Element
  * @typedef {import('./lib/types.js').Node} Node
  * @typedef {import('./lib/types.js').Space} Space
+ * @typedef {import('./lib/types.js').SelectState} SelectState
  */
 
 import {html, svg} from 'property-information'
@@ -29,7 +30,8 @@ export function matches(selector, node, space) {
   const state = createState(node, space)
   state.one = true
   state.shallow = true
-  return Boolean(any(parse(selector), node || undefined, state)[0])
+  any(parse(selector), node || undefined, state)
+  return state.results.length > 0
 }
 
 /**
@@ -50,8 +52,9 @@ export function matches(selector, node, space) {
 export function select(selector, tree, space) {
   const state = createState(tree, space)
   state.one = true
+  any(parse(selector), tree || undefined, state)
   // To do in major: return `undefined` instead.
-  return any(parse(selector), tree || undefined, state)[0] || null
+  return state.results[0] || null
 }
 
 /**
@@ -70,18 +73,20 @@ export function select(selector, tree, space) {
  */
 export function selectAll(selector, tree, space) {
   const state = createState(tree, space)
-  return any(parse(selector), tree || undefined, state)
+  any(parse(selector), tree || undefined, state)
+  return state.results
 }
 
 /**
  * @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
+ * @returns {SelectState} SelectState
  */
-function createState(tree, space) {
+export function createState(tree, space) {
   return {
+    results: [],
     // @ts-expect-error assume elements.
     scopeElements: tree ? (tree.type === 'root' ? tree.children : [tree]) : [],
     iterator: undefined,

lib/any.js

@@ -30,11 +30,12 @@ const type = zwitch('type', {
  *   Tree.
  * @param {SelectState} state
  *   State.
- * @returns {Array<Element>}
- *   Results.
+ * @returns {void}
  */
 export function any(query, node, state) {
-  return query && node ? type(query, node, state) : []
+  if (query && node) {
+    type(query, node, state)
+  }
 }
 
 /**
@@ -46,19 +47,15 @@ export function any(query, node, state) {
  *   Tree.
  * @param {SelectState} state
  *   State.
- * @returns {Array<Element>}
- *   Results.
+ * @returns {void}
  */
 function selectors(query, node, state) {
-  const collector = new Collector(state.one)
   let index = -1
 
   while (++index < query.selectors.length) {
     const set = query.selectors[index]
-    collector.collectAll(rule(set.rule, node, state))
+    rule(set.rule, node, state)
   }
-
-  return collector.result
 }
 
 /**
@@ -70,11 +67,10 @@ function selectors(query, node, state) {
  *   Tree.
  * @param {SelectState} state
  *   State.
- * @returns {Array<Element>}
- *   Results.
+ * @returns {void}
  */
 function ruleSet(query, node, state) {
-  return rule(query.rule, node, state)
+  rule(query.rule, node, state)
 }
 
 /**
@@ -86,12 +82,9 @@ function ruleSet(query, node, state) {
  *   Tree.
  * @param {SelectState} state
  *   State.
- * @returns {Array<Element>}
- *   Results.
+ * @returns {void}
  */
 function rule(query, tree, state) {
-  const collector = new Collector(state.one)
-
   if (state.shallow && query.rule) {
     throw new Error('Expected selector without nesting')
   }
@@ -102,8 +95,6 @@ function rule(query, tree, state) {
     index: needsIndex(query)
   })
 
-  return collector.result
-
   /** @type {SelectIterator} */
   function iterator(query, node, index, parent, state) {
     const exit = enterState(state, node)
@@ -117,7 +108,7 @@ function rule(query, tree, state) {
         })
       } else {
         // @ts-expect-error `test` also asserts `node is Element`
-        collector.collect(node)
+        if (!state.results.includes(node)) state.results.push(node)
         state.found = true
       }
     }
@@ -161,63 +152,3 @@ function unknownType(query) {
 function invalidType() {
   throw new Error('Invalid type')
 }
-
-/**
- * Collect elements.
- */
-class Collector {
-  /**
-   * @param {boolean | undefined} one
-   */
-  constructor(one) {
-    /**
-     * Found elements.
-     *
-     * @type {Array<Element>}
-     */
-    this.result = []
-
-    /**
-     * Whether we’re looking for one result.
-     *
-     * @type {boolean}
-     */
-    this.one = one || false
-
-    /**
-     * Whether we’ve found something.
-     *
-     * @type {boolean}
-     */
-    this.found = false
-  }
-
-  /**
-   * Add multiple elements.
-   *
-   * @param {Array<Element>} elements
-   */
-  collectAll(elements) {
-    let index = -1
-
-    while (++index < elements.length) {
-      this.collect(elements[index])
-    }
-  }
-
-  /**
-   * Add one element.
-   *
-   * @param {Element} element
-   */
-  collect(element) {
-    if (this.one) {
-      // Shouldn’t happen, safeguards performance problems.
-      /* c8 ignore next */
-      if (this.found) return
-      this.found = true
-    }
-
-    if (!this.result.includes(element)) this.result.push(element)
-  }
-}

lib/pseudo.js

@@ -104,17 +104,19 @@ export function pseudo(query, element, index, parent, state) {
  * @returns {boolean}
  */
 function matches(query, element, _, parent, state) {
-  const {shallow, one} = state
+  const {shallow, one, results} = state
 
   state.shallow = false
   state.one = true
-
-  const result = any(query.value, element, state)[0] === element
+  state.results = []
+  any(query.value, element, state)
+  const matches = state.results[0] === element
 
   state.shallow = shallow
   state.one = one
+  state.results = results
 
-  return result
+  return matches
 }
 
 /**
@@ -541,19 +543,21 @@ function assertDeep(state, query) {
 function has(query, element, _1, _2, state) {
   /** @type {Root} */
   const fragment = {type: 'root', children: element.children}
-  const {shallow, one, scopeElements} = state
+  const {shallow, one, scopeElements, results} = state
 
   state.shallow = false
   state.one = true
   state.scopeElements = [element]
-
-  const result = any(query.value, fragment, state).length > 0
+  state.results = []
+  any(query.value, fragment, state)
+  const has = state.results.length > 0
 
   state.shallow = shallow
   state.one = one
   state.scopeElements = scopeElements
+  state.results = results
 
-  return result
+  return has
 }
 
 /**

lib/types.js

@@ -59,6 +59,8 @@
  *
  * @typedef SelectState
  *   Current state.
+ * @property {Array<Element>} results
+ *   Matches.
  * @property {Array<Element>} scopeElements
  *   Elements in scope.
  * @property {SelectIterator | undefined} iterator