init

马宇豪

2024-07-16 f591c27b57e2418c9495bc02ae8cfff84d35bc18

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
// 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