142 lines
5.0 KiB
JavaScript
142 lines
5.0 KiB
JavaScript
import { isTag, hasChildren } from "domhandler";
|
|
/**
|
|
* Search a node and its children for nodes passing a test function. If `node` is not an array, it will be wrapped in one.
|
|
*
|
|
* @category Querying
|
|
* @param test Function to test nodes on.
|
|
* @param node Node to search. Will be included in the result set if it matches.
|
|
* @param recurse Also consider child nodes.
|
|
* @param limit Maximum number of nodes to return.
|
|
* @returns All nodes passing `test`.
|
|
*/
|
|
export function filter(test, node, recurse = true, limit = Infinity) {
|
|
return find(test, Array.isArray(node) ? node : [node], recurse, limit);
|
|
}
|
|
/**
|
|
* Search an array of nodes and their children for nodes passing a test function.
|
|
*
|
|
* @category Querying
|
|
* @param test Function to test nodes on.
|
|
* @param nodes Array of nodes to search.
|
|
* @param recurse Also consider child nodes.
|
|
* @param limit Maximum number of nodes to return.
|
|
* @returns All nodes passing `test`.
|
|
*/
|
|
export function find(test, nodes, recurse, limit) {
|
|
const result = [];
|
|
/** Stack of the arrays we are looking at. */
|
|
const nodeStack = [Array.isArray(nodes) ? nodes : [nodes]];
|
|
/** Stack of the indices within the arrays. */
|
|
const indexStack = [0];
|
|
for (;;) {
|
|
// First, check if the current array has any more elements to look at.
|
|
if (indexStack[0] >= nodeStack[0].length) {
|
|
// If we have no more arrays to look at, we are done.
|
|
if (indexStack.length === 1) {
|
|
return result;
|
|
}
|
|
// Otherwise, remove the current array from the stack.
|
|
nodeStack.shift();
|
|
indexStack.shift();
|
|
// Loop back to the start to continue with the next array.
|
|
continue;
|
|
}
|
|
const elem = nodeStack[0][indexStack[0]++];
|
|
if (test(elem)) {
|
|
result.push(elem);
|
|
if (--limit <= 0)
|
|
return result;
|
|
}
|
|
if (recurse && hasChildren(elem) && elem.children.length > 0) {
|
|
/*
|
|
* Add the children to the stack. We are depth-first, so this is
|
|
* the next array we look at.
|
|
*/
|
|
indexStack.unshift(0);
|
|
nodeStack.unshift(elem.children);
|
|
}
|
|
}
|
|
}
|
|
/**
|
|
* Finds the first element inside of an array that matches a test function. This is an alias for `Array.prototype.find`.
|
|
*
|
|
* @category Querying
|
|
* @param test Function to test nodes on.
|
|
* @param nodes Array of nodes to search.
|
|
* @returns The first node in the array that passes `test`.
|
|
* @deprecated Use `Array.prototype.find` directly.
|
|
*/
|
|
export function findOneChild(test, nodes) {
|
|
return nodes.find(test);
|
|
}
|
|
/**
|
|
* Finds one element in a tree that passes a test.
|
|
*
|
|
* @category Querying
|
|
* @param test Function to test nodes on.
|
|
* @param nodes Node or array of nodes to search.
|
|
* @param recurse Also consider child nodes.
|
|
* @returns The first node that passes `test`.
|
|
*/
|
|
export function findOne(test, nodes, recurse = true) {
|
|
const searchedNodes = Array.isArray(nodes) ? nodes : [nodes];
|
|
for (let i = 0; i < searchedNodes.length; i++) {
|
|
const node = searchedNodes[i];
|
|
if (isTag(node) && test(node)) {
|
|
return node;
|
|
}
|
|
if (recurse && hasChildren(node) && node.children.length > 0) {
|
|
const found = findOne(test, node.children, true);
|
|
if (found)
|
|
return found;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
/**
|
|
* Checks if a tree of nodes contains at least one node passing a test.
|
|
*
|
|
* @category Querying
|
|
* @param test Function to test nodes on.
|
|
* @param nodes Array of nodes to search.
|
|
* @returns Whether a tree of nodes contains at least one node passing the test.
|
|
*/
|
|
export function existsOne(test, nodes) {
|
|
return (Array.isArray(nodes) ? nodes : [nodes]).some((node) => (isTag(node) && test(node)) ||
|
|
(hasChildren(node) && existsOne(test, node.children)));
|
|
}
|
|
/**
|
|
* Search an array of nodes and their children for elements passing a test function.
|
|
*
|
|
* Same as `find`, but limited to elements and with less options, leading to reduced complexity.
|
|
*
|
|
* @category Querying
|
|
* @param test Function to test nodes on.
|
|
* @param nodes Array of nodes to search.
|
|
* @returns All nodes passing `test`.
|
|
*/
|
|
export function findAll(test, nodes) {
|
|
const result = [];
|
|
const nodeStack = [Array.isArray(nodes) ? nodes : [nodes]];
|
|
const indexStack = [0];
|
|
for (;;) {
|
|
if (indexStack[0] >= nodeStack[0].length) {
|
|
if (nodeStack.length === 1) {
|
|
return result;
|
|
}
|
|
// Otherwise, remove the current array from the stack.
|
|
nodeStack.shift();
|
|
indexStack.shift();
|
|
// Loop back to the start to continue with the next array.
|
|
continue;
|
|
}
|
|
const elem = nodeStack[0][indexStack[0]++];
|
|
if (isTag(elem) && test(elem))
|
|
result.push(elem);
|
|
if (hasChildren(elem) && elem.children.length > 0) {
|
|
indexStack.unshift(0);
|
|
nodeStack.unshift(elem.children);
|
|
}
|
|
}
|
|
}
|
|
//# sourceMappingURL=querying.js.map
|