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
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
|
'use strict'
const URL = require('url').URL
exports.getFundingInfo = getFundingInfo
exports.validFundingUrl = validFundingUrl
// Is the value of a `funding` property of a `package.json`
// a valid type+url for `npm fund` to display?
function validFundingUrl (funding) {
if (!funding || !funding.url) {
return false
}
try {
var parsed = new URL(funding.url)
} catch (error) {
return false
}
if (
parsed.protocol !== 'https:' &&
parsed.protocol !== 'http:'
) return false
return Boolean(parsed.host)
}
function getFundingInfo (idealTree, opts) {
let length = 0
const seen = new Set()
const { countOnly } = opts || {}
const empty = () => Object.create(null)
const _trailingDependencies = Symbol('trailingDependencies')
function tracked (name, version) {
const key = String(name) + String(version)
if (seen.has(key)) {
return true
}
seen.add(key)
}
function retrieveDependencies (dependencies) {
const trailing = dependencies[_trailingDependencies]
if (trailing) {
return Object.assign(
empty(),
dependencies,
trailing
)
}
return dependencies
}
function hasDependencies (dependencies) {
return dependencies && (
Object.keys(dependencies).length ||
dependencies[_trailingDependencies]
)
}
function getFundingDependencies (tree) {
const deps = tree && tree.dependencies
if (!deps) return empty()
// broken into two steps to make sure items appearance
// within top levels takes precedence over nested ones
return (Object.keys(deps)).map((key) => {
const dep = deps[key]
const { name, funding, version } = dep
const fundingItem = {}
// avoids duplicated items within the funding tree
if (tracked(name, version)) return empty()
if (version) {
fundingItem.version = version
}
if (funding && validFundingUrl(funding)) {
fundingItem.funding = funding
length++
}
return {
dep,
fundingItem
}
}).reduce((res, { dep, fundingItem }, i) => {
if (!fundingItem) return res
// recurse
const dependencies = dep.dependencies &&
Object.keys(dep.dependencies).length > 0 &&
getFundingDependencies(dep)
// if we're only counting items there's no need
// to add all the data to the resulting object
if (countOnly) return null
if (hasDependencies(dependencies)) {
fundingItem.dependencies = retrieveDependencies(dependencies)
}
if (fundingItem.funding) {
res[dep.name] = fundingItem
} else if (fundingItem.dependencies) {
res[_trailingDependencies] =
Object.assign(
empty(),
res[_trailingDependencies],
fundingItem.dependencies
)
}
return res
}, empty())
}
const idealTreeDependencies = getFundingDependencies(idealTree)
const result = {
length
}
if (!countOnly) {
result.name = idealTree.name || idealTree.path
if (idealTree && idealTree.version) {
result.version = idealTree.version
}
if (idealTree && idealTree.funding) {
result.funding = idealTree.funding
}
result.dependencies =
retrieveDependencies(idealTreeDependencies)
}
return result
}
|
