1 | 'use strict';
|
2 |
|
3 | Object.defineProperty(exports, "__esModule", {
|
4 | value: true
|
5 | });
|
6 | exports.fetchOneRemote = undefined;
|
7 |
|
8 | var _asyncToGenerator2;
|
9 |
|
10 | function _load_asyncToGenerator() {
|
11 | return _asyncToGenerator2 = _interopRequireDefault(require('babel-runtime/helpers/asyncToGenerator'));
|
12 | }
|
13 |
|
14 | let fetchCache = (() => {
|
15 | var _ref = (0, (_asyncToGenerator2 || _load_asyncToGenerator()).default)(function* (dest, fetcher, config, remote) {
|
16 |
|
17 | var _ref2 = yield config.readPackageMetadata(dest);
|
18 |
|
19 | const hash = _ref2.hash,
|
20 | pkg = _ref2.package,
|
21 | cacheRemote = _ref2.remote;
|
22 |
|
23 |
|
24 | const cacheIntegrity = cacheRemote.cacheIntegrity || cacheRemote.integrity;
|
25 | const cacheHash = cacheRemote.hash;
|
26 |
|
27 | if (remote.integrity) {
|
28 | if (!cacheIntegrity || !ssri.parse(cacheIntegrity).match(remote.integrity)) {
|
29 | throw new (_errors || _load_errors()).SecurityError(config.reporter.lang('fetchBadIntegrityCache', pkg.name, cacheIntegrity, remote.integrity));
|
30 | }
|
31 | }
|
32 |
|
33 | if (remote.hash) {
|
34 | if (!cacheHash || cacheHash !== remote.hash) {
|
35 | throw new (_errors || _load_errors()).SecurityError(config.reporter.lang('fetchBadHashCache', pkg.name, cacheHash, remote.hash));
|
36 | }
|
37 | }
|
38 |
|
39 | yield fetcher.setupMirrorFromCache();
|
40 | return {
|
41 | package: pkg,
|
42 | hash,
|
43 | dest,
|
44 | cached: true
|
45 | };
|
46 | });
|
47 |
|
48 | return function fetchCache(_x, _x2, _x3, _x4) {
|
49 | return _ref.apply(this, arguments);
|
50 | };
|
51 | })();
|
52 |
|
53 | let fetchOneRemote = exports.fetchOneRemote = (() => {
|
54 | var _ref3 = (0, (_asyncToGenerator2 || _load_asyncToGenerator()).default)(function* (remote, name, version, dest, config) {
|
55 |
|
56 | if (remote.type === 'link') {
|
57 | const mockPkg = { _uid: '', name: '', version: '0.0.0' };
|
58 | return Promise.resolve({ resolved: null, hash: '', dest, package: mockPkg, cached: false });
|
59 | }
|
60 |
|
61 | const Fetcher = (_index || _load_index())[remote.type];
|
62 | if (!Fetcher) {
|
63 | throw new (_errors || _load_errors()).MessageError(config.reporter.lang('unknownFetcherFor', remote.type));
|
64 | }
|
65 |
|
66 | const fetcher = new Fetcher(dest, remote, config);
|
67 | if (yield config.isValidModuleDest(dest)) {
|
68 | return fetchCache(dest, fetcher, config, remote);
|
69 | }
|
70 |
|
71 |
|
72 | yield (_fs || _load_fs()).unlink(dest);
|
73 |
|
74 | try {
|
75 | return yield fetcher.fetch({
|
76 | name,
|
77 | version
|
78 | });
|
79 | } catch (err) {
|
80 | try {
|
81 | yield (_fs || _load_fs()).unlink(dest);
|
82 | } catch (err2) {
|
83 |
|
84 | }
|
85 | throw err;
|
86 | }
|
87 | });
|
88 |
|
89 | return function fetchOneRemote(_x5, _x6, _x7, _x8, _x9) {
|
90 | return _ref3.apply(this, arguments);
|
91 | };
|
92 | })();
|
93 |
|
94 | let maybeFetchOne = (() => {
|
95 | var _ref4 = (0, (_asyncToGenerator2 || _load_asyncToGenerator()).default)(function* (ref, config) {
|
96 | try {
|
97 | return yield fetchOne(ref, config);
|
98 | } catch (err) {
|
99 | if (ref.optional) {
|
100 | config.reporter.error(err.message);
|
101 | return null;
|
102 | } else {
|
103 | throw err;
|
104 | }
|
105 | }
|
106 | });
|
107 |
|
108 | return function maybeFetchOne(_x10, _x11) {
|
109 | return _ref4.apply(this, arguments);
|
110 | };
|
111 | })();
|
112 |
|
113 | exports.fetch = fetch;
|
114 |
|
115 | var _errors;
|
116 |
|
117 | function _load_errors() {
|
118 | return _errors = require('./errors.js');
|
119 | }
|
120 |
|
121 | var _index;
|
122 |
|
123 | function _load_index() {
|
124 | return _index = _interopRequireWildcard(require('./fetchers/index.js'));
|
125 | }
|
126 |
|
127 | var _fs;
|
128 |
|
129 | function _load_fs() {
|
130 | return _fs = _interopRequireWildcard(require('./util/fs.js'));
|
131 | }
|
132 |
|
133 | var _promise;
|
134 |
|
135 | function _load_promise() {
|
136 | return _promise = _interopRequireWildcard(require('./util/promise.js'));
|
137 | }
|
138 |
|
139 | function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
|
140 |
|
141 | function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
142 |
|
143 | const ssri = require('ssri');
|
144 |
|
145 | function fetchOne(ref, config) {
|
146 | const dest = config.generateModuleCachePath(ref);
|
147 |
|
148 | return fetchOneRemote(ref.remote, ref.name, ref.version, dest, config);
|
149 | }
|
150 |
|
151 | function fetch(pkgs, config) {
|
152 | const pkgsPerDest = new Map();
|
153 | pkgs = pkgs.filter(pkg => {
|
154 | const ref = pkg._reference;
|
155 | if (!ref) {
|
156 | return false;
|
157 | }
|
158 | const dest = config.generateModuleCachePath(ref);
|
159 | const otherPkg = pkgsPerDest.get(dest);
|
160 | if (otherPkg) {
|
161 | config.reporter.warn(config.reporter.lang('multiplePackagesCantUnpackInSameDestination', ref.patterns, dest, otherPkg.patterns));
|
162 | return false;
|
163 | }
|
164 | pkgsPerDest.set(dest, ref);
|
165 | return true;
|
166 | });
|
167 | const tick = config.reporter.progress(pkgs.length);
|
168 |
|
169 | return (_promise || _load_promise()).queue(pkgs, (() => {
|
170 | var _ref5 = (0, (_asyncToGenerator2 || _load_asyncToGenerator()).default)(function* (pkg) {
|
171 | const ref = pkg._reference;
|
172 | if (!ref) {
|
173 | return pkg;
|
174 | }
|
175 |
|
176 | const res = yield maybeFetchOne(ref, config);
|
177 | let newPkg;
|
178 |
|
179 | if (res) {
|
180 | newPkg = res.package;
|
181 |
|
182 |
|
183 |
|
184 | if (ref.remote.hash) {
|
185 |
|
186 | if (ref.remote.hash !== res.hash && config.updateChecksums) {
|
187 | const oldHash = ref.remote.hash;
|
188 | if (ref.remote.resolved) {
|
189 | ref.remote.resolved = ref.remote.resolved.replace(oldHash, res.hash);
|
190 | }
|
191 | ref.config.cache = Object.keys(ref.config.cache).reduce(function (cache, entry) {
|
192 | const entryWithNewHash = entry.replace(oldHash, res.hash);
|
193 | cache[entryWithNewHash] = ref.config.cache[entry];
|
194 | return cache;
|
195 | }, {});
|
196 | }
|
197 | ref.remote.hash = res.hash || ref.remote.hash;
|
198 | }
|
199 | }
|
200 |
|
201 | if (tick) {
|
202 | tick();
|
203 | }
|
204 |
|
205 | if (newPkg) {
|
206 | newPkg._reference = ref;
|
207 | newPkg._remote = ref.remote;
|
208 | newPkg.name = pkg.name;
|
209 | newPkg.fresh = pkg.fresh;
|
210 | return newPkg;
|
211 | }
|
212 |
|
213 | return pkg;
|
214 | });
|
215 |
|
216 | return function (_x12) {
|
217 | return _ref5.apply(this, arguments);
|
218 | };
|
219 | })(), config.networkConcurrency);
|
220 | } |
\ | No newline at end of file |