1 | "use strict";
|
2 |
|
3 | var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
|
4 |
|
5 | var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
|
6 |
|
7 | const Parser = require('./Parser');
|
8 |
|
9 | const path = require('path');
|
10 |
|
11 | const _require = require('@parcel/utils'),
|
12 | errorUtils = _require.errorUtils;
|
13 |
|
14 |
|
15 |
|
16 |
|
17 |
|
18 | class Pipeline {
|
19 | constructor(options) {
|
20 | this.options = options;
|
21 | this.parser = new Parser(options);
|
22 | }
|
23 |
|
24 | process(path, isWarmUp) {
|
25 | var _this = this;
|
26 |
|
27 | return (0, _asyncToGenerator2.default)(function* () {
|
28 | let options = _this.options;
|
29 |
|
30 | if (isWarmUp) {
|
31 | options = Object.assign({
|
32 | isWarmUp
|
33 | }, options);
|
34 | }
|
35 |
|
36 | let asset = _this.parser.getAsset(path, options);
|
37 |
|
38 | let error = null;
|
39 | let generatedMap = {};
|
40 |
|
41 | try {
|
42 | let generated = yield _this.processAsset(asset);
|
43 | var _iteratorNormalCompletion = true;
|
44 | var _didIteratorError = false;
|
45 | var _iteratorError = undefined;
|
46 |
|
47 | try {
|
48 | for (var _iterator = generated[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
|
49 | let rendition = _step.value;
|
50 | generatedMap[rendition.type] = rendition.value;
|
51 | }
|
52 | } catch (err) {
|
53 | _didIteratorError = true;
|
54 | _iteratorError = err;
|
55 | } finally {
|
56 | try {
|
57 | if (!_iteratorNormalCompletion && _iterator.return != null) {
|
58 | _iterator.return();
|
59 | }
|
60 | } finally {
|
61 | if (_didIteratorError) {
|
62 | throw _iteratorError;
|
63 | }
|
64 | }
|
65 | }
|
66 | } catch (err) {
|
67 | error = errorUtils.errorToJson(err);
|
68 | error.fileName = path;
|
69 | }
|
70 |
|
71 | return {
|
72 | id: asset.id,
|
73 | dependencies: Array.from(asset.dependencies.values()),
|
74 | generated: generatedMap,
|
75 | sourceMaps: asset.sourceMaps,
|
76 | error: error,
|
77 | hash: asset.hash,
|
78 | cacheData: asset.cacheData
|
79 | };
|
80 | })();
|
81 | }
|
82 |
|
83 | processAsset(asset) {
|
84 | var _this2 = this;
|
85 |
|
86 | return (0, _asyncToGenerator2.default)(function* () {
|
87 | try {
|
88 | yield asset.process();
|
89 | } catch (err) {
|
90 | throw asset.generateErrorMessage(err);
|
91 | }
|
92 |
|
93 | let inputType = path.extname(asset.name).slice(1);
|
94 | let generated = [];
|
95 | var _iteratorNormalCompletion2 = true;
|
96 | var _didIteratorError2 = false;
|
97 | var _iteratorError2 = undefined;
|
98 |
|
99 | try {
|
100 | for (var _iterator2 = _this2.iterateRenditions(asset)[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
|
101 | let rendition = _step2.value;
|
102 | let type = rendition.type,
|
103 | value = rendition.value;
|
104 |
|
105 | if (typeof value !== 'string' || rendition.final) {
|
106 | generated.push(rendition);
|
107 | continue;
|
108 | }
|
109 |
|
110 |
|
111 |
|
112 | let AssetType = _this2.parser.findParser(asset.name.slice(0, -inputType.length) + type, true);
|
113 |
|
114 | if (!(asset instanceof AssetType)) {
|
115 | let opts = Object.assign({}, asset.options, {
|
116 | rendition
|
117 | });
|
118 | let subAsset = new AssetType(asset.name, opts);
|
119 | subAsset.id = asset.id;
|
120 | subAsset.contents = value;
|
121 | subAsset.dependencies = asset.dependencies;
|
122 | subAsset.cacheData = Object.assign(asset.cacheData, subAsset.cacheData);
|
123 | let processed = yield _this2.processAsset(subAsset);
|
124 |
|
125 | if (rendition.meta) {
|
126 | var _iteratorNormalCompletion4 = true;
|
127 | var _didIteratorError4 = false;
|
128 | var _iteratorError4 = undefined;
|
129 |
|
130 | try {
|
131 | for (var _iterator4 = processed[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
|
132 | let res = _step4.value;
|
133 | res.meta = rendition.meta;
|
134 | res.isMain = res.type === subAsset.type;
|
135 | }
|
136 | } catch (err) {
|
137 | _didIteratorError4 = true;
|
138 | _iteratorError4 = err;
|
139 | } finally {
|
140 | try {
|
141 | if (!_iteratorNormalCompletion4 && _iterator4.return != null) {
|
142 | _iterator4.return();
|
143 | }
|
144 | } finally {
|
145 | if (_didIteratorError4) {
|
146 | throw _iteratorError4;
|
147 | }
|
148 | }
|
149 | }
|
150 | }
|
151 |
|
152 | generated = generated.concat(processed);
|
153 | } else {
|
154 | generated.push(rendition);
|
155 | }
|
156 | }
|
157 |
|
158 | } catch (err) {
|
159 | _didIteratorError2 = true;
|
160 | _iteratorError2 = err;
|
161 | } finally {
|
162 | try {
|
163 | if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
|
164 | _iterator2.return();
|
165 | }
|
166 | } finally {
|
167 | if (_didIteratorError2) {
|
168 | throw _iteratorError2;
|
169 | }
|
170 | }
|
171 | }
|
172 |
|
173 | try {
|
174 | generated = yield asset.postProcess(generated);
|
175 | } catch (err) {
|
176 | throw asset.generateErrorMessage(err);
|
177 | }
|
178 |
|
179 | let hasMap = false;
|
180 | let sourceMaps = {};
|
181 | var _iteratorNormalCompletion3 = true;
|
182 | var _didIteratorError3 = false;
|
183 | var _iteratorError3 = undefined;
|
184 |
|
185 | try {
|
186 | for (var _iterator3 = generated[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
|
187 | let rendition = _step3.value;
|
188 |
|
189 | if (rendition.map && rendition.type == asset.type) {
|
190 | sourceMaps[rendition.type] = rendition.map;
|
191 | hasMap = true;
|
192 | }
|
193 | }
|
194 | } catch (err) {
|
195 | _didIteratorError3 = true;
|
196 | _iteratorError3 = err;
|
197 | } finally {
|
198 | try {
|
199 | if (!_iteratorNormalCompletion3 && _iterator3.return != null) {
|
200 | _iterator3.return();
|
201 | }
|
202 | } finally {
|
203 | if (_didIteratorError3) {
|
204 | throw _iteratorError3;
|
205 | }
|
206 | }
|
207 | }
|
208 |
|
209 | if (hasMap) {
|
210 | asset.sourceMaps = sourceMaps;
|
211 | }
|
212 |
|
213 | asset.generated = generated;
|
214 | asset.hash = yield asset.generateHash();
|
215 | return generated;
|
216 | })();
|
217 | }
|
218 |
|
219 | *iterateRenditions(asset) {
|
220 | if (Array.isArray(asset.generated)) {
|
221 | return yield* asset.generated;
|
222 | }
|
223 |
|
224 | if (typeof asset.generated === 'string') {
|
225 | return yield {
|
226 | type: asset.type,
|
227 | value: asset.generated
|
228 | };
|
229 | }
|
230 |
|
231 |
|
232 |
|
233 | for (let type in asset.generated) {
|
234 | yield {
|
235 | type,
|
236 | value: asset.generated[type],
|
237 |
|
238 | final: !(type === 'js' && this.options.scopeHoist)
|
239 | };
|
240 | }
|
241 | }
|
242 |
|
243 | }
|
244 |
|
245 | module.exports = Pipeline; |
\ | No newline at end of file |