1 |
|
2 |
|
3 |
|
4 |
|
5 |
|
6 | "use strict";
|
7 |
|
8 | const { SyncBailHook } = require("tapable");
|
9 | const { RawSource, CachedSource, CompatSource } = require("webpack-sources");
|
10 | const Compilation = require("../Compilation");
|
11 | const WebpackError = require("../WebpackError");
|
12 | const { compareSelect, compareStrings } = require("../util/comparators");
|
13 | const createHash = require("../util/createHash");
|
14 |
|
15 |
|
16 |
|
17 |
|
18 |
|
19 | const EMPTY_SET = new Set();
|
20 |
|
21 | const addToList = (itemOrItems, list) => {
|
22 | if (Array.isArray(itemOrItems)) {
|
23 | for (const item of itemOrItems) {
|
24 | list.add(item);
|
25 | }
|
26 | } else if (itemOrItems) {
|
27 | list.add(itemOrItems);
|
28 | }
|
29 | };
|
30 |
|
31 |
|
32 |
|
33 |
|
34 |
|
35 |
|
36 |
|
37 | const mapAndDeduplicateBuffers = (input, fn) => {
|
38 |
|
39 |
|
40 |
|
41 | const result = [];
|
42 | outer: for (const value of input) {
|
43 | const buf = fn(value);
|
44 | for (const other of result) {
|
45 | if (buf.equals(other)) continue outer;
|
46 | }
|
47 | result.push(buf);
|
48 | }
|
49 | return result;
|
50 | };
|
51 |
|
52 |
|
53 |
|
54 |
|
55 |
|
56 |
|
57 | const quoteMeta = str => {
|
58 | return str.replace(/[-[\]\\/{}()*+?.^$|]/g, "\\$&");
|
59 | };
|
60 |
|
61 | const cachedSourceMap = new WeakMap();
|
62 |
|
63 | const toCachedSource = source => {
|
64 | if (source instanceof CachedSource) {
|
65 | return source;
|
66 | }
|
67 | const entry = cachedSourceMap.get(source);
|
68 | if (entry !== undefined) return entry;
|
69 | const newSource = new CachedSource(CompatSource.from(source));
|
70 | cachedSourceMap.set(source, newSource);
|
71 | return newSource;
|
72 | };
|
73 |
|
74 |
|
75 |
|
76 |
|
77 |
|
78 |
|
79 |
|
80 |
|
81 |
|
82 |
|
83 |
|
84 |
|
85 |
|
86 |
|
87 |
|
88 |
|
89 |
|
90 |
|
91 |
|
92 |
|
93 |
|
94 |
|
95 | const compilationHooksMap = new WeakMap();
|
96 |
|
97 | class RealContentHashPlugin {
|
98 | |
99 |
|
100 |
|
101 |
|
102 | static getCompilationHooks(compilation) {
|
103 | if (!(compilation instanceof Compilation)) {
|
104 | throw new TypeError(
|
105 | "The 'compilation' argument must be an instance of Compilation"
|
106 | );
|
107 | }
|
108 | let hooks = compilationHooksMap.get(compilation);
|
109 | if (hooks === undefined) {
|
110 | hooks = {
|
111 | updateHash: new SyncBailHook(["content", "oldHash"])
|
112 | };
|
113 | compilationHooksMap.set(compilation, hooks);
|
114 | }
|
115 | return hooks;
|
116 | }
|
117 |
|
118 | constructor({ hashFunction, hashDigest }) {
|
119 | this._hashFunction = hashFunction;
|
120 | this._hashDigest = hashDigest;
|
121 | }
|
122 |
|
123 | |
124 |
|
125 |
|
126 |
|
127 |
|
128 | apply(compiler) {
|
129 | compiler.hooks.compilation.tap("RealContentHashPlugin", compilation => {
|
130 | const cacheAnalyse = compilation.getCache(
|
131 | "RealContentHashPlugin|analyse"
|
132 | );
|
133 | const cacheGenerate = compilation.getCache(
|
134 | "RealContentHashPlugin|generate"
|
135 | );
|
136 | const hooks = RealContentHashPlugin.getCompilationHooks(compilation);
|
137 | compilation.hooks.processAssets.tapPromise(
|
138 | {
|
139 | name: "RealContentHashPlugin",
|
140 | stage: Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_HASH
|
141 | },
|
142 | async () => {
|
143 | const assets = compilation.getAssets();
|
144 |
|
145 | const assetsWithInfo = [];
|
146 | const hashToAssets = new Map();
|
147 | for (const { source, info, name } of assets) {
|
148 | const cachedSource = toCachedSource(source);
|
149 | const content = cachedSource.source();
|
150 |
|
151 | const hashes = new Set();
|
152 | addToList(info.contenthash, hashes);
|
153 | const data = {
|
154 | name,
|
155 | info,
|
156 | source: cachedSource,
|
157 |
|
158 | newSource: undefined,
|
159 |
|
160 | newSourceWithoutOwn: undefined,
|
161 | content,
|
162 |
|
163 | ownHashes: undefined,
|
164 | contentComputePromise: undefined,
|
165 | contentComputeWithoutOwnPromise: undefined,
|
166 |
|
167 | referencedHashes: undefined,
|
168 | hashes
|
169 | };
|
170 | assetsWithInfo.push(data);
|
171 | for (const hash of hashes) {
|
172 | const list = hashToAssets.get(hash);
|
173 | if (list === undefined) {
|
174 | hashToAssets.set(hash, [data]);
|
175 | } else {
|
176 | list.push(data);
|
177 | }
|
178 | }
|
179 | }
|
180 | if (hashToAssets.size === 0) return;
|
181 | const hashRegExp = new RegExp(
|
182 | Array.from(hashToAssets.keys(), quoteMeta).join("|"),
|
183 | "g"
|
184 | );
|
185 | await Promise.all(
|
186 | assetsWithInfo.map(async asset => {
|
187 | const { name, source, content, hashes } = asset;
|
188 | if (Buffer.isBuffer(content)) {
|
189 | asset.referencedHashes = EMPTY_SET;
|
190 | asset.ownHashes = EMPTY_SET;
|
191 | return;
|
192 | }
|
193 | const etag = cacheAnalyse.mergeEtags(
|
194 | cacheAnalyse.getLazyHashedEtag(source),
|
195 | Array.from(hashes).join("|")
|
196 | );
|
197 | [asset.referencedHashes, asset.ownHashes] =
|
198 | await cacheAnalyse.providePromise(name, etag, () => {
|
199 | const referencedHashes = new Set();
|
200 | let ownHashes = new Set();
|
201 | const inContent = content.match(hashRegExp);
|
202 | if (inContent) {
|
203 | for (const hash of inContent) {
|
204 | if (hashes.has(hash)) {
|
205 | ownHashes.add(hash);
|
206 | continue;
|
207 | }
|
208 | referencedHashes.add(hash);
|
209 | }
|
210 | }
|
211 | return [referencedHashes, ownHashes];
|
212 | });
|
213 | })
|
214 | );
|
215 | const getDependencies = hash => {
|
216 | const assets = hashToAssets.get(hash);
|
217 | if (!assets) {
|
218 | const referencingAssets = assetsWithInfo.filter(asset =>
|
219 | asset.referencedHashes.has(hash)
|
220 | );
|
221 | const err = new WebpackError(`RealContentHashPlugin
|
222 | Some kind of unexpected caching problem occurred.
|
223 | An asset was cached with a reference to another asset (${hash}) that's not in the compilation anymore.
|
224 | Either the asset was incorrectly cached, or the referenced asset should also be restored from cache.
|
225 | Referenced by:
|
226 | ${referencingAssets
|
227 | .map(a => {
|
228 | const match = new RegExp(`.{0,20}${quoteMeta(hash)}.{0,20}`).exec(
|
229 | a.content
|
230 | );
|
231 | return ` - ${a.name}: ...${match ? match[0] : "???"}...`;
|
232 | })
|
233 | .join("\n")}`);
|
234 | compilation.errors.push(err);
|
235 | return undefined;
|
236 | }
|
237 | const hashes = new Set();
|
238 | for (const { referencedHashes, ownHashes } of assets) {
|
239 | if (!ownHashes.has(hash)) {
|
240 | for (const hash of ownHashes) {
|
241 | hashes.add(hash);
|
242 | }
|
243 | }
|
244 | for (const hash of referencedHashes) {
|
245 | hashes.add(hash);
|
246 | }
|
247 | }
|
248 | return hashes;
|
249 | };
|
250 | const hashInfo = hash => {
|
251 | const assets = hashToAssets.get(hash);
|
252 | return `${hash} (${Array.from(assets, a => a.name)})`;
|
253 | };
|
254 | const hashesInOrder = new Set();
|
255 | for (const hash of hashToAssets.keys()) {
|
256 | const add = (hash, stack) => {
|
257 | const deps = getDependencies(hash);
|
258 | if (!deps) return;
|
259 | stack.add(hash);
|
260 | for (const dep of deps) {
|
261 | if (hashesInOrder.has(dep)) continue;
|
262 | if (stack.has(dep)) {
|
263 | throw new Error(
|
264 | `Circular hash dependency ${Array.from(
|
265 | stack,
|
266 | hashInfo
|
267 | ).join(" -> ")} -> ${hashInfo(dep)}`
|
268 | );
|
269 | }
|
270 | add(dep, stack);
|
271 | }
|
272 | hashesInOrder.add(hash);
|
273 | stack.delete(hash);
|
274 | };
|
275 | if (hashesInOrder.has(hash)) continue;
|
276 | add(hash, new Set());
|
277 | }
|
278 | const hashToNewHash = new Map();
|
279 | const getEtag = asset =>
|
280 | cacheGenerate.mergeEtags(
|
281 | cacheGenerate.getLazyHashedEtag(asset.source),
|
282 | Array.from(asset.referencedHashes, hash =>
|
283 | hashToNewHash.get(hash)
|
284 | ).join("|")
|
285 | );
|
286 | const computeNewContent = asset => {
|
287 | if (asset.contentComputePromise) return asset.contentComputePromise;
|
288 | return (asset.contentComputePromise = (async () => {
|
289 | if (
|
290 | asset.ownHashes.size > 0 ||
|
291 | Array.from(asset.referencedHashes).some(
|
292 | hash => hashToNewHash.get(hash) !== hash
|
293 | )
|
294 | ) {
|
295 | const identifier = asset.name;
|
296 | const etag = getEtag(asset);
|
297 | asset.newSource = await cacheGenerate.providePromise(
|
298 | identifier,
|
299 | etag,
|
300 | () => {
|
301 | const newContent = asset.content.replace(hashRegExp, hash =>
|
302 | hashToNewHash.get(hash)
|
303 | );
|
304 | return new RawSource(newContent);
|
305 | }
|
306 | );
|
307 | }
|
308 | })());
|
309 | };
|
310 | const computeNewContentWithoutOwn = asset => {
|
311 | if (asset.contentComputeWithoutOwnPromise)
|
312 | return asset.contentComputeWithoutOwnPromise;
|
313 | return (asset.contentComputeWithoutOwnPromise = (async () => {
|
314 | if (
|
315 | asset.ownHashes.size > 0 ||
|
316 | Array.from(asset.referencedHashes).some(
|
317 | hash => hashToNewHash.get(hash) !== hash
|
318 | )
|
319 | ) {
|
320 | const identifier = asset.name + "|without-own";
|
321 | const etag = getEtag(asset);
|
322 | asset.newSourceWithoutOwn = await cacheGenerate.providePromise(
|
323 | identifier,
|
324 | etag,
|
325 | () => {
|
326 | const newContent = asset.content.replace(
|
327 | hashRegExp,
|
328 | hash => {
|
329 | if (asset.ownHashes.has(hash)) {
|
330 | return "";
|
331 | }
|
332 | return hashToNewHash.get(hash);
|
333 | }
|
334 | );
|
335 | return new RawSource(newContent);
|
336 | }
|
337 | );
|
338 | }
|
339 | })());
|
340 | };
|
341 | const comparator = compareSelect(a => a.name, compareStrings);
|
342 | for (const oldHash of hashesInOrder) {
|
343 | const assets = hashToAssets.get(oldHash);
|
344 | assets.sort(comparator);
|
345 | const hash = createHash(this._hashFunction);
|
346 | await Promise.all(
|
347 | assets.map(asset =>
|
348 | asset.ownHashes.has(oldHash)
|
349 | ? computeNewContentWithoutOwn(asset)
|
350 | : computeNewContent(asset)
|
351 | )
|
352 | );
|
353 | const assetsContent = mapAndDeduplicateBuffers(assets, asset => {
|
354 | if (asset.ownHashes.has(oldHash)) {
|
355 | return asset.newSourceWithoutOwn
|
356 | ? asset.newSourceWithoutOwn.buffer()
|
357 | : asset.source.buffer();
|
358 | } else {
|
359 | return asset.newSource
|
360 | ? asset.newSource.buffer()
|
361 | : asset.source.buffer();
|
362 | }
|
363 | });
|
364 | let newHash = hooks.updateHash.call(assetsContent, oldHash);
|
365 | if (!newHash) {
|
366 | for (const content of assetsContent) {
|
367 | hash.update(content);
|
368 | }
|
369 | const digest = hash.digest(this._hashDigest);
|
370 | newHash = (digest.slice(0, oldHash.length));
|
371 | }
|
372 | hashToNewHash.set(oldHash, newHash);
|
373 | }
|
374 | await Promise.all(
|
375 | assetsWithInfo.map(async asset => {
|
376 | await computeNewContent(asset);
|
377 | const newName = asset.name.replace(hashRegExp, hash =>
|
378 | hashToNewHash.get(hash)
|
379 | );
|
380 |
|
381 | const infoUpdate = {};
|
382 | const hash = asset.info.contenthash;
|
383 | infoUpdate.contenthash = Array.isArray(hash)
|
384 | ? hash.map(hash => hashToNewHash.get(hash))
|
385 | : hashToNewHash.get(hash);
|
386 |
|
387 | if (asset.newSource !== undefined) {
|
388 | compilation.updateAsset(
|
389 | asset.name,
|
390 | asset.newSource,
|
391 | infoUpdate
|
392 | );
|
393 | } else {
|
394 | compilation.updateAsset(asset.name, asset.source, infoUpdate);
|
395 | }
|
396 |
|
397 | if (asset.name !== newName) {
|
398 | compilation.renameAsset(asset.name, newName);
|
399 | }
|
400 | })
|
401 | );
|
402 | }
|
403 | );
|
404 | });
|
405 | }
|
406 | }
|
407 |
|
408 | module.exports = RealContentHashPlugin;
|