Current File : //opt/alt/alt-nodejs16/root/lib/node_modules/npm/node_modules.bundled/treeverse/lib/depth.js
// Perform a depth-first walk of a tree.
//
// `visit(node)` is called when the node is first encountered.
// `leave(node, children)` is called when all of the node's children
// have been left or (in the case of cyclic graphs) visited.
//
// Only one of visit or leave is required. (Technically both are optional,
// but if you don't provide at least one, the tree is just walked without
// doing anything, which is a bit pointless.) If visit is provided, and
// leave is not, then this is a root->leaf traversal. If leave is provided,
// and visit is not, then it's leaf->root. Both can be provided for a
// map-reduce operation.
//
// If either visit or leave return a Promise for any node, then the
// walk returns a Promise.
const depthDescent = require('./depth-descent.js')
const depth = ({
visit,
leave,
filter = () => true,
seen = new Map(),
getChildren,
tree,
}) => {
if (!leave) {
return depthDescent({ visit, filter, getChildren, tree })
}
if (seen.has(tree)) {
return seen.get(tree)
}
seen.set(tree, null)
const visitNode = () => {
const res = visit ? visit(tree) : tree
if (isPromise(res)) {
const fullResult = res.then(resThen => {
seen.set(tree, resThen)
return kidNodes()
})
seen.set(tree, fullResult)
return fullResult
} else {
seen.set(tree, res)
return kidNodes()
}
}
const kidNodes = () => {
const kids = getChildren(tree, seen.get(tree))
return isPromise(kids) ? kids.then(processKids) : processKids(kids)
}
const processKids = nodes => {
const kids = (nodes || []).filter(filter).map(kid =>
depth({ visit, leave, filter, seen, getChildren, tree: kid }))
return kids.some(isPromise)
? Promise.all(kids).then(leaveNode)
: leaveNode(kids)
}
const leaveNode = kids => {
const res = leave(seen.get(tree), kids)
seen.set(tree, res)
// if it's a promise at this point, the caller deals with it
return res
}
return visitNode()
}
const isPromise = p => p && typeof p.then === 'function'
module.exports = depth
Mini Shell