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
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
|
const archy = require('archy')
const Arborist = require('@npmcli/arborist')
const chalk = require('chalk')
const pacote = require('pacote')
const semver = require('semver')
const npa = require('npm-package-arg')
const { depth } = require('treeverse')
const {
readTree: getFundingInfo,
normalizeFunding,
isValidFunding,
} = require('libnpmfund')
const npm = require('./npm.js')
const completion = require('./utils/completion/installed-deep.js')
const output = require('./utils/output.js')
const openUrl = require('./utils/open-url.js')
const usageUtil = require('./utils/usage.js')
const usage = usageUtil(
'fund',
'npm fund',
'npm fund [--json] [--browser] [--unicode] [[<@scope>/]<pkg> [--which=<fundingSourceNumber>]'
)
const cmd = (args, cb) => fund(args).then(() => cb()).catch(cb)
function printJSON (fundingInfo) {
return JSON.stringify(fundingInfo, null, 2)
}
const getPrintableName = ({ name, version }) => {
const printableVersion = version ? `@${version}` : ''
return `${name}${printableVersion}`
}
function printHuman (fundingInfo, { color, unicode }) {
const seenUrls = new Map()
const tree = obj =>
archy(obj, '', { unicode })
const result = depth({
tree: fundingInfo,
// composes human readable package name
// and creates a new archy item for readable output
visit: ({ name, version, funding }) => {
const [fundingSource] = []
.concat(normalizeFunding(funding))
.filter(isValidFunding)
const { url } = fundingSource || {}
const pkgRef = getPrintableName({ name, version })
let item = {
label: pkgRef,
}
if (url) {
item.label = tree({
label: color ? chalk.bgBlack.white(url) : url,
nodes: [pkgRef],
}).trim()
// stacks all packages together under the same item
if (seenUrls.has(url)) {
item = seenUrls.get(url)
item.label += `, ${pkgRef}`
return null
} else
seenUrls.set(url, item)
}
return item
},
// puts child nodes back into returned archy
// output while also filtering out missing items
leave: (item, children) => {
if (item)
item.nodes = children.filter(Boolean)
return item
},
// turns tree-like object return by libnpmfund
// into children to be properly read by treeverse
getChildren: (node) =>
Object.keys(node.dependencies || {})
.map(key => ({
name: key,
...node.dependencies[key],
})),
})
const res = tree(result)
return color ? chalk.reset(res) : res
}
async function openFundingUrl ({ path, tree, spec, fundingSourceNumber }) {
const arg = npa(spec, path)
const retrievePackageMetadata = () => {
if (arg.type === 'directory') {
if (tree.path === arg.fetchSpec) {
// matches cwd, e.g: npm fund .
return tree.package
} else {
// matches any file path within current arborist inventory
for (const item of tree.inventory.values()) {
if (item.path === arg.fetchSpec)
return item.package
}
}
} else {
// tries to retrieve a package from arborist inventory
// by matching resulted package name from the provided spec
const [item] = [...tree.inventory.query('name', arg.name)]
.filter(i => semver.valid(i.package.version))
.sort((a, b) => semver.rcompare(a.package.version, b.package.version))
if (item)
return item.package
}
}
const { funding } = retrievePackageMetadata() ||
await pacote.manifest(arg, npm.flatOptions).catch(() => ({}))
const validSources = []
.concat(normalizeFunding(funding))
.filter(isValidFunding)
const matchesValidSource =
validSources.length === 1 ||
(fundingSourceNumber > 0 && fundingSourceNumber <= validSources.length)
if (matchesValidSource) {
const index = fundingSourceNumber ? fundingSourceNumber - 1 : 0
const { type, url } = validSources[index]
const typePrefix = type ? `${type} funding` : 'Funding'
const msg = `${typePrefix} available at the following URL`
return new Promise((resolve, reject) =>
openUrl(url, msg, err => err
? reject(err)
: resolve()
))
} else if (validSources.length && !(fundingSourceNumber >= 1)) {
validSources.forEach(({ type, url }, i) => {
const typePrefix = type ? `${type} funding` : 'Funding'
const msg = `${typePrefix} available at the following URL`
output(`${i + 1}: ${msg}: ${url}`)
})
output('Run `npm fund [<@scope>/]<pkg> --which=1`, for example, to open the first funding URL listed in that package')
} else {
const noFundingError = new Error(`No valid funding method available for: ${spec}`)
noFundingError.code = 'ENOFUND'
throw noFundingError
}
}
const fund = async (args) => {
const opts = npm.flatOptions
const spec = args[0]
const numberArg = opts.which
const fundingSourceNumber = numberArg && parseInt(numberArg, 10)
const badFundingSourceNumber =
numberArg !== undefined &&
(String(fundingSourceNumber) !== numberArg || fundingSourceNumber < 1)
if (badFundingSourceNumber) {
const err = new Error('`npm fund [<@scope>/]<pkg> [--which=fundingSourceNumber]` must be given a positive integer')
err.code = 'EFUNDNUMBER'
throw err
}
if (opts.global) {
const err = new Error('`npm fund` does not support global packages')
err.code = 'EFUNDGLOBAL'
throw err
}
const where = npm.prefix
const arb = new Arborist({ ...opts, path: where })
const tree = await arb.loadActual()
if (spec) {
await openFundingUrl({
path: where,
tree,
spec,
fundingSourceNumber,
})
return
}
const print = opts.json
? printJSON
: printHuman
output(
print(
getFundingInfo(tree),
opts
)
)
}
module.exports = Object.assign(cmd, { usage, completion })
|
