1 | 'use strict';
|
2 |
|
3 | Object.defineProperty(exports, "__esModule", {
|
4 | value: true
|
5 | });
|
6 |
|
7 | var _asyncToGenerator2;
|
8 |
|
9 | function _load_asyncToGenerator() {
|
10 | return _asyncToGenerator2 = _interopRequireDefault(require('babel-runtime/helpers/asyncToGenerator'));
|
11 | }
|
12 |
|
13 | var _index;
|
14 |
|
15 | function _load_index() {
|
16 | return _index = require('./resolvers/index.js');
|
17 | }
|
18 |
|
19 | var _packageRequest;
|
20 |
|
21 | function _load_packageRequest() {
|
22 | return _packageRequest = _interopRequireDefault(require('./package-request.js'));
|
23 | }
|
24 |
|
25 | var _normalizePattern2;
|
26 |
|
27 | function _load_normalizePattern() {
|
28 | return _normalizePattern2 = require('./util/normalize-pattern.js');
|
29 | }
|
30 |
|
31 | var _requestManager;
|
32 |
|
33 | function _load_requestManager() {
|
34 | return _requestManager = _interopRequireDefault(require('./util/request-manager.js'));
|
35 | }
|
36 |
|
37 | var _blockingQueue;
|
38 |
|
39 | function _load_blockingQueue() {
|
40 | return _blockingQueue = _interopRequireDefault(require('./util/blocking-queue.js'));
|
41 | }
|
42 |
|
43 | var _lockfile;
|
44 |
|
45 | function _load_lockfile() {
|
46 | return _lockfile = _interopRequireDefault(require('./lockfile'));
|
47 | }
|
48 |
|
49 | var _map;
|
50 |
|
51 | function _load_map() {
|
52 | return _map = _interopRequireDefault(require('./util/map.js'));
|
53 | }
|
54 |
|
55 | var _workspaceLayout;
|
56 |
|
57 | function _load_workspaceLayout() {
|
58 | return _workspaceLayout = _interopRequireDefault(require('./workspace-layout.js'));
|
59 | }
|
60 |
|
61 | var _resolutionMap;
|
62 |
|
63 | function _load_resolutionMap() {
|
64 | return _resolutionMap = _interopRequireDefault(require('./resolution-map.js'));
|
65 | }
|
66 |
|
67 | var _resolutionMap2;
|
68 |
|
69 | function _load_resolutionMap2() {
|
70 | return _resolutionMap2 = require('./resolution-map.js');
|
71 | }
|
72 |
|
73 | function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
74 |
|
75 | const invariant = require('invariant');
|
76 |
|
77 | const semver = require('semver');
|
78 |
|
79 | class PackageResolver {
|
80 | constructor(config, lockfile, resolutionMap = new (_resolutionMap || _load_resolutionMap()).default(config)) {
|
81 | this.patternsByPackage = (0, (_map || _load_map()).default)();
|
82 | this.fetchingPatterns = new Set();
|
83 | this.fetchingQueue = new (_blockingQueue || _load_blockingQueue()).default('resolver fetching');
|
84 | this.patterns = (0, (_map || _load_map()).default)();
|
85 | this.resolutionMap = resolutionMap;
|
86 | this.usedRegistries = new Set();
|
87 | this.flat = false;
|
88 |
|
89 | this.reporter = config.reporter;
|
90 | this.lockfile = lockfile;
|
91 | this.config = config;
|
92 | this.delayedResolveQueue = [];
|
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 | isNewPattern(pattern) {
|
137 | return !!this.patterns[pattern].fresh;
|
138 | }
|
139 |
|
140 | updateManifest(ref, newPkg) {
|
141 |
|
142 | const oldPkg = this.patterns[ref.patterns[0]];
|
143 | newPkg._reference = ref;
|
144 | newPkg._remote = ref.remote;
|
145 | newPkg.name = oldPkg.name;
|
146 | newPkg.fresh = oldPkg.fresh;
|
147 | newPkg.prebuiltVariants = oldPkg.prebuiltVariants;
|
148 |
|
149 |
|
150 | for (var _iterator = ref.patterns, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
|
151 | var _ref;
|
152 |
|
153 | if (_isArray) {
|
154 | if (_i >= _iterator.length) break;
|
155 | _ref = _iterator[_i++];
|
156 | } else {
|
157 | _i = _iterator.next();
|
158 | if (_i.done) break;
|
159 | _ref = _i.value;
|
160 | }
|
161 |
|
162 | const pattern = _ref;
|
163 |
|
164 | this.patterns[pattern] = newPkg;
|
165 | }
|
166 |
|
167 | return Promise.resolve();
|
168 | }
|
169 |
|
170 | updateManifests(newPkgs) {
|
171 | for (var _iterator2 = newPkgs, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
|
172 | var _ref2;
|
173 |
|
174 | if (_isArray2) {
|
175 | if (_i2 >= _iterator2.length) break;
|
176 | _ref2 = _iterator2[_i2++];
|
177 | } else {
|
178 | _i2 = _iterator2.next();
|
179 | if (_i2.done) break;
|
180 | _ref2 = _i2.value;
|
181 | }
|
182 |
|
183 | const newPkg = _ref2;
|
184 |
|
185 | if (newPkg._reference) {
|
186 | for (var _iterator3 = newPkg._reference.patterns, _isArray3 = Array.isArray(_iterator3), _i3 = 0, _iterator3 = _isArray3 ? _iterator3 : _iterator3[Symbol.iterator]();;) {
|
187 | var _ref3;
|
188 |
|
189 | if (_isArray3) {
|
190 | if (_i3 >= _iterator3.length) break;
|
191 | _ref3 = _iterator3[_i3++];
|
192 | } else {
|
193 | _i3 = _iterator3.next();
|
194 | if (_i3.done) break;
|
195 | _ref3 = _i3.value;
|
196 | }
|
197 |
|
198 | const pattern = _ref3;
|
199 |
|
200 | const oldPkg = this.patterns[pattern];
|
201 | newPkg.prebuiltVariants = oldPkg.prebuiltVariants;
|
202 |
|
203 | this.patterns[pattern] = newPkg;
|
204 | }
|
205 | }
|
206 | }
|
207 |
|
208 | return Promise.resolve();
|
209 | }
|
210 |
|
211 | |
212 |
|
213 |
|
214 |
|
215 | dedupePatterns(patterns) {
|
216 | const deduped = [];
|
217 | const seen = new Set();
|
218 |
|
219 | for (var _iterator4 = patterns, _isArray4 = Array.isArray(_iterator4), _i4 = 0, _iterator4 = _isArray4 ? _iterator4 : _iterator4[Symbol.iterator]();;) {
|
220 | var _ref4;
|
221 |
|
222 | if (_isArray4) {
|
223 | if (_i4 >= _iterator4.length) break;
|
224 | _ref4 = _iterator4[_i4++];
|
225 | } else {
|
226 | _i4 = _iterator4.next();
|
227 | if (_i4.done) break;
|
228 | _ref4 = _i4.value;
|
229 | }
|
230 |
|
231 | const pattern = _ref4;
|
232 |
|
233 | const info = this.getResolvedPattern(pattern);
|
234 | if (seen.has(info)) {
|
235 | continue;
|
236 | }
|
237 |
|
238 | seen.add(info);
|
239 | deduped.push(pattern);
|
240 | }
|
241 |
|
242 | return deduped;
|
243 | }
|
244 |
|
245 | |
246 |
|
247 |
|
248 |
|
249 | getTopologicalManifests(seedPatterns) {
|
250 | const pkgs = new Set();
|
251 | const skip = new Set();
|
252 |
|
253 | const add = seedPatterns => {
|
254 | for (var _iterator5 = seedPatterns, _isArray5 = Array.isArray(_iterator5), _i5 = 0, _iterator5 = _isArray5 ? _iterator5 : _iterator5[Symbol.iterator]();;) {
|
255 | var _ref5;
|
256 |
|
257 | if (_isArray5) {
|
258 | if (_i5 >= _iterator5.length) break;
|
259 | _ref5 = _iterator5[_i5++];
|
260 | } else {
|
261 | _i5 = _iterator5.next();
|
262 | if (_i5.done) break;
|
263 | _ref5 = _i5.value;
|
264 | }
|
265 |
|
266 | const pattern = _ref5;
|
267 |
|
268 | const pkg = this.getStrictResolvedPattern(pattern);
|
269 | if (skip.has(pkg)) {
|
270 | continue;
|
271 | }
|
272 |
|
273 | const ref = pkg._reference;
|
274 | invariant(ref, 'expected reference');
|
275 | skip.add(pkg);
|
276 | add(ref.dependencies);
|
277 | pkgs.add(pkg);
|
278 | }
|
279 | };
|
280 |
|
281 | add(seedPatterns);
|
282 |
|
283 | return pkgs;
|
284 | }
|
285 |
|
286 | |
287 |
|
288 |
|
289 |
|
290 | getLevelOrderManifests(seedPatterns) {
|
291 | const pkgs = new Set();
|
292 | const skip = new Set();
|
293 |
|
294 | const add = seedPatterns => {
|
295 | const refs = [];
|
296 |
|
297 | for (var _iterator6 = seedPatterns, _isArray6 = Array.isArray(_iterator6), _i6 = 0, _iterator6 = _isArray6 ? _iterator6 : _iterator6[Symbol.iterator]();;) {
|
298 | var _ref6;
|
299 |
|
300 | if (_isArray6) {
|
301 | if (_i6 >= _iterator6.length) break;
|
302 | _ref6 = _iterator6[_i6++];
|
303 | } else {
|
304 | _i6 = _iterator6.next();
|
305 | if (_i6.done) break;
|
306 | _ref6 = _i6.value;
|
307 | }
|
308 |
|
309 | const pattern = _ref6;
|
310 |
|
311 | const pkg = this.getStrictResolvedPattern(pattern);
|
312 | if (skip.has(pkg)) {
|
313 | continue;
|
314 | }
|
315 |
|
316 | const ref = pkg._reference;
|
317 | invariant(ref, 'expected reference');
|
318 |
|
319 | refs.push(ref);
|
320 | skip.add(pkg);
|
321 | pkgs.add(pkg);
|
322 | }
|
323 |
|
324 | for (var _iterator7 = refs, _isArray7 = Array.isArray(_iterator7), _i7 = 0, _iterator7 = _isArray7 ? _iterator7 : _iterator7[Symbol.iterator]();;) {
|
325 | var _ref7;
|
326 |
|
327 | if (_isArray7) {
|
328 | if (_i7 >= _iterator7.length) break;
|
329 | _ref7 = _iterator7[_i7++];
|
330 | } else {
|
331 | _i7 = _iterator7.next();
|
332 | if (_i7.done) break;
|
333 | _ref7 = _i7.value;
|
334 | }
|
335 |
|
336 | const ref = _ref7;
|
337 |
|
338 | add(ref.dependencies);
|
339 | }
|
340 | };
|
341 |
|
342 | add(seedPatterns);
|
343 |
|
344 | return pkgs;
|
345 | }
|
346 |
|
347 | |
348 |
|
349 |
|
350 |
|
351 | getAllDependencyNamesByLevelOrder(seedPatterns) {
|
352 | const names = new Set();
|
353 | for (var _iterator8 = this.getLevelOrderManifests(seedPatterns), _isArray8 = Array.isArray(_iterator8), _i8 = 0, _iterator8 = _isArray8 ? _iterator8 : _iterator8[Symbol.iterator]();;) {
|
354 | var _ref9;
|
355 |
|
356 | if (_isArray8) {
|
357 | if (_i8 >= _iterator8.length) break;
|
358 | _ref9 = _iterator8[_i8++];
|
359 | } else {
|
360 | _i8 = _iterator8.next();
|
361 | if (_i8.done) break;
|
362 | _ref9 = _i8.value;
|
363 | }
|
364 |
|
365 | const _ref8 = _ref9;
|
366 | const name = _ref8.name;
|
367 |
|
368 | names.add(name);
|
369 | }
|
370 | return names;
|
371 | }
|
372 |
|
373 | |
374 |
|
375 |
|
376 |
|
377 | getAllInfoForPackageName(name) {
|
378 | const patterns = this.patternsByPackage[name] || [];
|
379 | return this.getAllInfoForPatterns(patterns);
|
380 | }
|
381 |
|
382 | |
383 |
|
384 |
|
385 |
|
386 | getAllInfoForPatterns(patterns) {
|
387 | const infos = [];
|
388 | const seen = new Set();
|
389 |
|
390 | for (var _iterator9 = patterns, _isArray9 = Array.isArray(_iterator9), _i9 = 0, _iterator9 = _isArray9 ? _iterator9 : _iterator9[Symbol.iterator]();;) {
|
391 | var _ref10;
|
392 |
|
393 | if (_isArray9) {
|
394 | if (_i9 >= _iterator9.length) break;
|
395 | _ref10 = _iterator9[_i9++];
|
396 | } else {
|
397 | _i9 = _iterator9.next();
|
398 | if (_i9.done) break;
|
399 | _ref10 = _i9.value;
|
400 | }
|
401 |
|
402 | const pattern = _ref10;
|
403 |
|
404 | const info = this.patterns[pattern];
|
405 | if (seen.has(info)) {
|
406 | continue;
|
407 | }
|
408 |
|
409 | seen.add(info);
|
410 | infos.push(info);
|
411 | }
|
412 |
|
413 | return infos;
|
414 | }
|
415 |
|
416 | |
417 |
|
418 |
|
419 |
|
420 | getManifests() {
|
421 | const infos = [];
|
422 | const seen = new Set();
|
423 |
|
424 | for (const pattern in this.patterns) {
|
425 | const info = this.patterns[pattern];
|
426 | if (seen.has(info)) {
|
427 | continue;
|
428 | }
|
429 |
|
430 | infos.push(info);
|
431 | seen.add(info);
|
432 | }
|
433 |
|
434 | return infos;
|
435 | }
|
436 |
|
437 | |
438 |
|
439 |
|
440 | replacePattern(pattern, newPattern) {
|
441 | const pkg = this.getResolvedPattern(pattern);
|
442 | invariant(pkg, `missing package ${pattern}`);
|
443 | const ref = pkg._reference;
|
444 | invariant(ref, 'expected package reference');
|
445 | ref.patterns = [newPattern];
|
446 | this.addPattern(newPattern, pkg);
|
447 | this.removePattern(pattern);
|
448 | }
|
449 |
|
450 | |
451 |
|
452 |
|
453 |
|
454 | collapseAllVersionsOfPackage(name, version) {
|
455 | const patterns = this.dedupePatterns(this.patternsByPackage[name]);
|
456 | return this.collapsePackageVersions(name, version, patterns);
|
457 | }
|
458 |
|
459 | |
460 |
|
461 |
|
462 | collapsePackageVersions(name, version, patterns) {
|
463 | const human = `${name}@${version}`;
|
464 |
|
465 |
|
466 | let collapseToReference;
|
467 | let collapseToManifest;
|
468 | let collapseToPattern;
|
469 | for (var _iterator10 = patterns, _isArray10 = Array.isArray(_iterator10), _i10 = 0, _iterator10 = _isArray10 ? _iterator10 : _iterator10[Symbol.iterator]();;) {
|
470 | var _ref11;
|
471 |
|
472 | if (_isArray10) {
|
473 | if (_i10 >= _iterator10.length) break;
|
474 | _ref11 = _iterator10[_i10++];
|
475 | } else {
|
476 | _i10 = _iterator10.next();
|
477 | if (_i10.done) break;
|
478 | _ref11 = _i10.value;
|
479 | }
|
480 |
|
481 | const pattern = _ref11;
|
482 |
|
483 | const _manifest = this.patterns[pattern];
|
484 | if (_manifest.version === version) {
|
485 | collapseToReference = _manifest._reference;
|
486 | collapseToManifest = _manifest;
|
487 | collapseToPattern = pattern;
|
488 | break;
|
489 | }
|
490 | }
|
491 |
|
492 | invariant(collapseToReference && collapseToManifest && collapseToPattern, `Couldn't find package manifest for ${human}`);
|
493 |
|
494 | for (var _iterator11 = patterns, _isArray11 = Array.isArray(_iterator11), _i11 = 0, _iterator11 = _isArray11 ? _iterator11 : _iterator11[Symbol.iterator]();;) {
|
495 | var _ref12;
|
496 |
|
497 | if (_isArray11) {
|
498 | if (_i11 >= _iterator11.length) break;
|
499 | _ref12 = _iterator11[_i11++];
|
500 | } else {
|
501 | _i11 = _iterator11.next();
|
502 | if (_i11.done) break;
|
503 | _ref12 = _i11.value;
|
504 | }
|
505 |
|
506 | const pattern = _ref12;
|
507 |
|
508 |
|
509 | if (pattern === collapseToPattern) {
|
510 | continue;
|
511 | }
|
512 |
|
513 |
|
514 | const ref = this.getStrictResolvedPattern(pattern)._reference;
|
515 | invariant(ref, 'expected package reference');
|
516 | const refPatterns = ref.patterns.slice();
|
517 | ref.prune();
|
518 |
|
519 |
|
520 | for (var _iterator12 = refPatterns, _isArray12 = Array.isArray(_iterator12), _i12 = 0, _iterator12 = _isArray12 ? _iterator12 : _iterator12[Symbol.iterator]();;) {
|
521 | var _ref13;
|
522 |
|
523 | if (_isArray12) {
|
524 | if (_i12 >= _iterator12.length) break;
|
525 | _ref13 = _iterator12[_i12++];
|
526 | } else {
|
527 | _i12 = _iterator12.next();
|
528 | if (_i12.done) break;
|
529 | _ref13 = _i12.value;
|
530 | }
|
531 |
|
532 | const pattern = _ref13;
|
533 |
|
534 | collapseToReference.addPattern(pattern, collapseToManifest);
|
535 | }
|
536 | }
|
537 |
|
538 | return collapseToPattern;
|
539 | }
|
540 |
|
541 | |
542 |
|
543 |
|
544 |
|
545 | addPattern(pattern, info) {
|
546 | this.patterns[pattern] = info;
|
547 |
|
548 | const byName = this.patternsByPackage[info.name] = this.patternsByPackage[info.name] || [];
|
549 | if (byName.indexOf(pattern) === -1) {
|
550 | byName.push(pattern);
|
551 | }
|
552 | }
|
553 |
|
554 | |
555 |
|
556 |
|
557 |
|
558 | removePattern(pattern) {
|
559 | const pkg = this.patterns[pattern];
|
560 | if (!pkg) {
|
561 | return;
|
562 | }
|
563 |
|
564 | const byName = this.patternsByPackage[pkg.name];
|
565 | if (!byName) {
|
566 | return;
|
567 | }
|
568 |
|
569 | byName.splice(byName.indexOf(pattern), 1);
|
570 | delete this.patterns[pattern];
|
571 | }
|
572 |
|
573 | |
574 |
|
575 |
|
576 |
|
577 | getResolvedPattern(pattern) {
|
578 | return this.patterns[pattern];
|
579 | }
|
580 |
|
581 | |
582 |
|
583 |
|
584 |
|
585 | getStrictResolvedPattern(pattern) {
|
586 | const manifest = this.getResolvedPattern(pattern);
|
587 | invariant(manifest, 'expected manifest');
|
588 | return manifest;
|
589 | }
|
590 |
|
591 | |
592 |
|
593 |
|
594 |
|
595 | getExactVersionMatch(name, version, manifest) {
|
596 | const patterns = this.patternsByPackage[name];
|
597 | if (!patterns) {
|
598 | return null;
|
599 | }
|
600 |
|
601 | for (var _iterator13 = patterns, _isArray13 = Array.isArray(_iterator13), _i13 = 0, _iterator13 = _isArray13 ? _iterator13 : _iterator13[Symbol.iterator]();;) {
|
602 | var _ref14;
|
603 |
|
604 | if (_isArray13) {
|
605 | if (_i13 >= _iterator13.length) break;
|
606 | _ref14 = _iterator13[_i13++];
|
607 | } else {
|
608 | _i13 = _iterator13.next();
|
609 | if (_i13.done) break;
|
610 | _ref14 = _i13.value;
|
611 | }
|
612 |
|
613 | const pattern = _ref14;
|
614 |
|
615 | const info = this.getStrictResolvedPattern(pattern);
|
616 | if (info.version === version) {
|
617 | return info;
|
618 | }
|
619 | }
|
620 |
|
621 | if (manifest && (0, (_index || _load_index()).getExoticResolver)(version)) {
|
622 | return this.exoticRangeMatch(patterns.map(this.getStrictResolvedPattern.bind(this)), manifest);
|
623 | }
|
624 |
|
625 | return null;
|
626 | }
|
627 |
|
628 | |
629 |
|
630 |
|
631 |
|
632 | getHighestRangeVersionMatch(name, range, manifest) {
|
633 | const patterns = this.patternsByPackage[name];
|
634 |
|
635 | if (!patterns) {
|
636 | return null;
|
637 | }
|
638 |
|
639 | const versionNumbers = [];
|
640 | const resolvedPatterns = patterns.map(pattern => {
|
641 | const info = this.getStrictResolvedPattern(pattern);
|
642 | versionNumbers.push(info.version);
|
643 |
|
644 | return info;
|
645 | });
|
646 |
|
647 | const maxValidRange = semver.maxSatisfying(versionNumbers, range);
|
648 |
|
649 | if (!maxValidRange) {
|
650 | return manifest && (0, (_index || _load_index()).getExoticResolver)(range) ? this.exoticRangeMatch(resolvedPatterns, manifest) : null;
|
651 | }
|
652 |
|
653 | const indexOfmaxValidRange = versionNumbers.indexOf(maxValidRange);
|
654 | const maxValidRangeManifest = resolvedPatterns[indexOfmaxValidRange];
|
655 |
|
656 | return maxValidRangeManifest;
|
657 | }
|
658 |
|
659 | |
660 |
|
661 |
|
662 |
|
663 | exoticRangeMatch(resolvedPkgs, manifest) {
|
664 | const remote = manifest._remote;
|
665 | if (!(remote && remote.reference && remote.type === 'copy')) {
|
666 | return null;
|
667 | }
|
668 |
|
669 | const matchedPkg = resolvedPkgs.find(({ _remote: pkgRemote }) => pkgRemote && pkgRemote.reference === remote.reference && pkgRemote.type === 'copy');
|
670 |
|
671 | if (matchedPkg) {
|
672 | manifest._remote = matchedPkg._remote;
|
673 | }
|
674 |
|
675 | return matchedPkg;
|
676 | }
|
677 |
|
678 | |
679 |
|
680 |
|
681 | isLockfileEntryOutdated(version, range, hasVersion) {
|
682 | return !!(semver.validRange(range) && semver.valid(version) && !(0, (_index || _load_index()).getExoticResolver)(range) && hasVersion && !semver.satisfies(version, range));
|
683 | }
|
684 |
|
685 | |
686 |
|
687 |
|
688 |
|
689 | find(initialReq) {
|
690 | var _this = this;
|
691 |
|
692 | return (0, (_asyncToGenerator2 || _load_asyncToGenerator()).default)(function* () {
|
693 | const req = _this.resolveToResolution(initialReq);
|
694 |
|
695 |
|
696 | if (!req) {
|
697 | return;
|
698 | }
|
699 |
|
700 | const request = new (_packageRequest || _load_packageRequest()).default(req, _this);
|
701 | const fetchKey = `${req.registry}:${req.pattern}:${String(req.optional)}`;
|
702 | const initialFetch = !_this.fetchingPatterns.has(fetchKey);
|
703 | let fresh = false;
|
704 |
|
705 | if (_this.activity) {
|
706 | _this.activity.tick(req.pattern);
|
707 | }
|
708 |
|
709 | if (initialFetch) {
|
710 | _this.fetchingPatterns.add(fetchKey);
|
711 |
|
712 | const lockfileEntry = _this.lockfile.getLocked(req.pattern);
|
713 |
|
714 | if (lockfileEntry) {
|
715 | var _normalizePattern = (0, (_normalizePattern2 || _load_normalizePattern()).normalizePattern)(req.pattern);
|
716 |
|
717 | const range = _normalizePattern.range,
|
718 | hasVersion = _normalizePattern.hasVersion;
|
719 |
|
720 |
|
721 | if (_this.isLockfileEntryOutdated(lockfileEntry.version, range, hasVersion)) {
|
722 | _this.reporter.warn(_this.reporter.lang('incorrectLockfileEntry', req.pattern));
|
723 | _this.removePattern(req.pattern);
|
724 | _this.lockfile.removePattern(req.pattern);
|
725 | fresh = true;
|
726 | }
|
727 | } else {
|
728 | fresh = true;
|
729 | }
|
730 |
|
731 | request.init();
|
732 | }
|
733 |
|
734 | yield request.find({ fresh, frozen: _this.frozen });
|
735 | })();
|
736 | }
|
737 |
|
738 | |
739 |
|
740 |
|
741 |
|
742 | init(deps, { isFlat, isFrozen, workspaceLayout } = {
|
743 | isFlat: false,
|
744 | isFrozen: false,
|
745 | workspaceLayout: undefined
|
746 | }) {
|
747 | var _this2 = this;
|
748 |
|
749 | return (0, (_asyncToGenerator2 || _load_asyncToGenerator()).default)(function* () {
|
750 | _this2.flat = Boolean(isFlat);
|
751 | _this2.frozen = Boolean(isFrozen);
|
752 | _this2.workspaceLayout = workspaceLayout;
|
753 | const activity = _this2.activity = _this2.reporter.activity();
|
754 |
|
755 | for (var _iterator14 = deps, _isArray14 = Array.isArray(_iterator14), _i14 = 0, _iterator14 = _isArray14 ? _iterator14 : _iterator14[Symbol.iterator]();;) {
|
756 | var _ref15;
|
757 |
|
758 | if (_isArray14) {
|
759 | if (_i14 >= _iterator14.length) break;
|
760 | _ref15 = _iterator14[_i14++];
|
761 | } else {
|
762 | _i14 = _iterator14.next();
|
763 | if (_i14.done) break;
|
764 | _ref15 = _i14.value;
|
765 | }
|
766 |
|
767 | const req = _ref15;
|
768 |
|
769 | yield _this2.find(req);
|
770 | }
|
771 |
|
772 |
|
773 |
|
774 | _this2.resolvePackagesWithExistingVersions();
|
775 |
|
776 | for (var _iterator15 = _this2.resolutionMap.delayQueue, _isArray15 = Array.isArray(_iterator15), _i15 = 0, _iterator15 = _isArray15 ? _iterator15 : _iterator15[Symbol.iterator]();;) {
|
777 | var _ref16;
|
778 |
|
779 | if (_isArray15) {
|
780 | if (_i15 >= _iterator15.length) break;
|
781 | _ref16 = _iterator15[_i15++];
|
782 | } else {
|
783 | _i15 = _iterator15.next();
|
784 | if (_i15.done) break;
|
785 | _ref16 = _i15.value;
|
786 | }
|
787 |
|
788 | const req = _ref16;
|
789 |
|
790 | _this2.resolveToResolution(req);
|
791 | }
|
792 |
|
793 | if (isFlat) {
|
794 | for (var _iterator16 = deps, _isArray16 = Array.isArray(_iterator16), _i16 = 0, _iterator16 = _isArray16 ? _iterator16 : _iterator16[Symbol.iterator]();;) {
|
795 | var _ref17;
|
796 |
|
797 | if (_isArray16) {
|
798 | if (_i16 >= _iterator16.length) break;
|
799 | _ref17 = _iterator16[_i16++];
|
800 | } else {
|
801 | _i16 = _iterator16.next();
|
802 | if (_i16.done) break;
|
803 | _ref17 = _i16.value;
|
804 | }
|
805 |
|
806 | const dep = _ref17;
|
807 |
|
808 | const name = (0, (_normalizePattern2 || _load_normalizePattern()).normalizePattern)(dep.pattern).name;
|
809 | _this2.optimizeResolutions(name);
|
810 | }
|
811 | }
|
812 |
|
813 | activity.end();
|
814 | _this2.activity = null;
|
815 | })();
|
816 | }
|
817 |
|
818 |
|
819 | optimizeResolutions(name) {
|
820 | const patterns = this.dedupePatterns(this.patternsByPackage[name] || []);
|
821 |
|
822 |
|
823 |
|
824 | const collapsablePatterns = patterns.filter(pattern => {
|
825 | const remote = this.patterns[pattern]._remote;
|
826 | return !this.lockfile.getLocked(pattern) && (!remote || remote.type !== 'workspace');
|
827 | });
|
828 | if (collapsablePatterns.length < 2) {
|
829 | return;
|
830 | }
|
831 |
|
832 |
|
833 | const availableVersions = this.getAllInfoForPatterns(collapsablePatterns).map(manifest => manifest.version);
|
834 | availableVersions.sort(semver.rcompare);
|
835 |
|
836 | const ranges = collapsablePatterns.map(pattern => (0, (_normalizePattern2 || _load_normalizePattern()).normalizePattern)(pattern).range);
|
837 |
|
838 |
|
839 |
|
840 | for (var _iterator17 = availableVersions, _isArray17 = Array.isArray(_iterator17), _i17 = 0, _iterator17 = _isArray17 ? _iterator17 : _iterator17[Symbol.iterator]();;) {
|
841 | var _ref18;
|
842 |
|
843 | if (_isArray17) {
|
844 | if (_i17 >= _iterator17.length) break;
|
845 | _ref18 = _iterator17[_i17++];
|
846 | } else {
|
847 | _i17 = _iterator17.next();
|
848 | if (_i17.done) break;
|
849 | _ref18 = _i17.value;
|
850 | }
|
851 |
|
852 | const version = _ref18;
|
853 |
|
854 | if (ranges.every(range => semver.satisfies(version, range))) {
|
855 | this.collapsePackageVersions(name, version, collapsablePatterns);
|
856 | return;
|
857 | }
|
858 | }
|
859 | }
|
860 |
|
861 | |
862 |
|
863 |
|
864 |
|
865 |
|
866 |
|
867 | reportPackageWithExistingVersion(req, info) {
|
868 | this.delayedResolveQueue.push({ req, info });
|
869 | }
|
870 |
|
871 | |
872 |
|
873 |
|
874 |
|
875 |
|
876 | resolvePackagesWithExistingVersions() {
|
877 | for (var _iterator18 = this.delayedResolveQueue, _isArray18 = Array.isArray(_iterator18), _i18 = 0, _iterator18 = _isArray18 ? _iterator18 : _iterator18[Symbol.iterator]();;) {
|
878 | var _ref20;
|
879 |
|
880 | if (_isArray18) {
|
881 | if (_i18 >= _iterator18.length) break;
|
882 | _ref20 = _iterator18[_i18++];
|
883 | } else {
|
884 | _i18 = _iterator18.next();
|
885 | if (_i18.done) break;
|
886 | _ref20 = _i18.value;
|
887 | }
|
888 |
|
889 | const _ref19 = _ref20;
|
890 | const req = _ref19.req,
|
891 | info = _ref19.info;
|
892 |
|
893 | req.resolveToExistingVersion(info);
|
894 | }
|
895 | }
|
896 |
|
897 | resolveToResolution(req) {
|
898 | const parentNames = req.parentNames,
|
899 | pattern = req.pattern;
|
900 |
|
901 |
|
902 | if (!parentNames || this.flat) {
|
903 | return req;
|
904 | }
|
905 |
|
906 | const resolution = this.resolutionMap.find(pattern, parentNames);
|
907 |
|
908 | if (resolution) {
|
909 | const resolutionManifest = this.getResolvedPattern(resolution);
|
910 |
|
911 | if (resolutionManifest) {
|
912 | invariant(resolutionManifest._reference, 'resolutions should have a resolved reference');
|
913 | resolutionManifest._reference.patterns.push(pattern);
|
914 | this.addPattern(pattern, resolutionManifest);
|
915 | const lockManifest = this.lockfile.getLocked(pattern);
|
916 | if ((0, (_resolutionMap2 || _load_resolutionMap2()).shouldUpdateLockfile)(lockManifest, resolutionManifest._reference)) {
|
917 | this.lockfile.removePattern(pattern);
|
918 | }
|
919 | } else {
|
920 | this.resolutionMap.addToDelayQueue(req);
|
921 | }
|
922 | return null;
|
923 | }
|
924 |
|
925 | return req;
|
926 | }
|
927 | }
|
928 | exports.default = PackageResolver; |
\ | No newline at end of file |