-
Notifications
You must be signed in to change notification settings - Fork 3
/
resolve-tree.js
212 lines (179 loc) · 5.52 KB
/
resolve-tree.js
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
211
var pull = require('pull-stream')
var pt = require('pull-traverse')
var semver = require('semver')
var cat = require('pull-cat')
var clean = require('./clean')
var paramap = require('pull-paramap')
var Local = require('./local')
module.exports = createResolve
function check(pkg, name, range) {
if(!pkg) return false
if(pkg.tree[name] && semver.satisfies(pkg.tree[name].version, range, true))
return true
return check(pkg.parent, name, range)
}
function fixModule (module) {
if('string' === typeof module) {
var parts = module.split('@')
return {name: parts.shift(), version: parts.shift() || '*'}
}
return module
}
function niceError(err, parent, name, range) {
if(!err) return
err.message = 'package: '
+ parent.name + '@' + parent.version
+ ' could not resolve '
+ name + '@' + range
+ '\n' + err.message
return err
}
function merge (a, b) {
var c = {}
a = a || {}
b = b || {}
for(var k in a)
c[k] = a[k]
for(var k in b)
c[k] = b[k]
return c
}
function isPackage(pkg) {
return pkg.name && pkg.version && (pkg.dependencies || pkg.devDependencies)
}
function has(deps, module, vrange) {
if(!deps || !deps[module]) return false
return semver.satisfies(deps[module].version, vrange, true)
}
function hasDep(pkg, module, vrange) {
if(pkg.tree && pkg.tree[module]) return pkg.tree[module]
// if(pkg.tree && has(pkg.tree, module, vrange)) return pkg.tree[module]
else if(pkg.parent)
return hasDep(pkg.parent, module, vrange)
return null
}
var unresolved = {}
function createResolve (resolvePackage) {
function resolveTree (module, opts, cb) {
var local = Local(opts)
module = fixModule(module)
var filter = opts.filter || function (pkg, root) {
if(!pkg) return
pkg.parent.tree[pkg.name] = pkg
}
if(!module) return cb(null, {})
//this is the root package - if we are resolving from a package.json
//we should just use that, instead of calling resolve pkg.
var root
if(isPackage(module)) tree(module)
else
resolvePackage(module.name, module.version, opts, function (err, pkg) {
if(err) return cb(err)
tree(pkg)
})
function tree (root) {
if(opts.available) {
root.parent = {tree: opts.available}
}
pull(cat([
pull.values([root]),
pt.depthFirst(root, function (pkg) {
var deps = merge(
pkg.dependencies || {},
opts.optional === false ? {} : pkg.optionalDependencies
)
//merge deps and dev deps if this is the root module and we are in --dev mode
if(opts.dev && pkg === root)
deps = pkg.dependencies = merge(pkg.devDependencies, deps)
pkg.tree = {}
return pull(
pull.values(Object.keys(deps)),
//this could be parallel,
//but it's not the bottle neck.
paramap(function (name, cb) {
//check if a usable module is already in the tree.
//if a module was found, but did not conflict then use that.
var _pkg = hasDep(pkg, name)
if(_pkg && semver.satisfies(_pkg.version, deps[name]))
return cb()
//check if this module is already installed
local(name, opts, function (_, _pkg) {
if(_pkg) {
_pkg.installed = true
root.tree[_pkg.name] = _pkg
if(semver.satisfies(_pkg.version, deps[name]))
return cb()
}
//filter out versions that we already have.
//if(opts.check !== false && check(pkg, name, deps[name]))
// return cb()
unresolved[name + '@' + deps[name]] = true
resolvePackage(name, deps[name], opts, function (err, _pkg) {
delete unresolved[name + '@' + deps[name]]
cb(niceError(err, pkg, name, deps[name]), _pkg)
})
})
}),
pull.filter(),
pull.through(function (_pkg) {
_pkg.parent = pkg
filter(_pkg, root)
})
)
})
]),
pull.drain(null, function (err) {
cb(err, clean(root))
}))
}
}
//install non-conflicting modules as low in the tree as possible.
function resolveTreeGreedy (module, opts, cb) {
if(!cb) cb = opts, opts = null
opts = opts || {}
opts.filter = function (pkg, root) {
if(!pkg) return
if(!root.tree[pkg.name]) {
root.tree[pkg.name] = pkg
pkg.parent = root
}
else {
pkg.parent.tree[pkg.name] = pkg
}
return pkg
}
resolveTree(module, opts, cb)
}
return function (module, opts, cb) {
if(!cb)
cb = opts, opts = {}
function resolve(module, cb) {
if(opts && opts.greedy)
resolveTreeGreedy(module, opts, cb)
else
resolveTree(module, opts, cb)
}
if(Array.isArray(module) && module.length > 1) {
var n = module.length, a = {}
module.forEach(function (m) {
resolve(m, next)
})
function next (err, tree) {
if(err) return n = 0, cb(err)
a[tree.name] = tree
if(--n) return
cb(null, a)
}
} else {
if(Array.isArray(module))
module = module.shift()
resolve(module, cb)
}
}
}
//This Should Never Happen.
process.on('exit', function () {
var keys = Object.keys(unresolved)
if(keys.length)
throw new Error('resolve did not callback: ' + keys.join(', '))
})