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
77
78
79
80
81
82
83
84
85
86
87
88
// Perform a depth-first walk of a tree, ONLY doing the descent (visit)
//
// This uses a stack rather than recursion, so that it can handle deeply
// nested trees without call stack overflows.  (My kingdom for proper TCO!)
//
// This is only used for cases where leave() is not specified.
//
// a
// +-- b
// |   +-- 1
// |   +-- 2
// +-- c
//     +-- 3
//     +-- 4
//
// Expect:
// visit a
// visit b
// visit 1
// visit 2
// visit c
// visit 3
// visit 4
//
// stack.push(tree)
// while stack not empty
//   pop T from stack
//   VISIT(T)
//   get children C of T
//   push each C onto stack
 
const depth = ({
  visit,
  filter,
  getChildren,
  tree,
}) => {
  const stack = []
  const seen = new Map()
 
  const next = () => {
    while (stack.length) {
      const node = stack.pop()
      const res = visitNode(node)
      if (isPromise(res)) {
        return res.then(() => next())
      }
    }
    return seen.get(tree)
  }
 
  const visitNode = (visitTree) => {
    if (seen.has(visitTree)) {
      return seen.get(visitTree)
    }
 
    seen.set(visitTree, null)
    const res = visit ? visit(visitTree) : visitTree
    if (isPromise(res)) {
      const fullResult = res.then(resThen => {
        seen.set(visitTree, resThen)
        return kidNodes(visitTree)
      })
      seen.set(visitTree, fullResult)
      return fullResult
    } else {
      seen.set(visitTree, res)
      return kidNodes(visitTree)
    }
  }
 
  const kidNodes = (kidTree) => {
    const kids = getChildren(kidTree, seen.get(kidTree))
    return isPromise(kids) ? kids.then(processKids) : processKids(kids)
  }
 
  const processKids = (kids) => {
    kids = (kids || []).filter(filter)
    stack.push(...kids)
  }
 
  stack.push(tree)
  return next()
}
 
const isPromise = p => p && typeof p.then === 'function'
 
module.exports = depth