1 |
|
2 |
|
3 |
|
4 |
|
5 |
|
6 | "use strict";
|
7 |
|
8 | const asyncLib = require("neo-async");
|
9 | const { SyncBailHook } = require("tapable");
|
10 | const Compilation = require("../lib/Compilation");
|
11 | const createSchemaValidation = require("./util/create-schema-validation");
|
12 | const { join } = require("./util/fs");
|
13 | const processAsyncTree = require("./util/processAsyncTree");
|
14 |
|
15 |
|
16 |
|
17 |
|
18 |
|
19 |
|
20 |
|
21 |
|
22 |
|
23 |
|
24 |
|
25 |
|
26 |
|
27 |
|
28 |
|
29 |
|
30 | const validate = createSchemaValidation(
|
31 | undefined,
|
32 | () => {
|
33 | const { definitions } = require("../schemas/WebpackOptions.json");
|
34 | return {
|
35 | definitions,
|
36 | oneOf: [{ $ref: "#/definitions/CleanOptions" }]
|
37 | };
|
38 | },
|
39 | {
|
40 | name: "Clean Plugin",
|
41 | baseDataPath: "options"
|
42 | }
|
43 | );
|
44 | const _10sec = 10 * 1000;
|
45 |
|
46 |
|
47 |
|
48 |
|
49 |
|
50 |
|
51 |
|
52 | const mergeAssets = (as1, as2) => {
|
53 | for (const [key, value1] of as2) {
|
54 | const value2 = as1.get(key);
|
55 | if (!value2 || value1 > value2) as1.set(key, value1);
|
56 | }
|
57 | };
|
58 |
|
59 |
|
60 |
|
61 |
|
62 |
|
63 |
|
64 |
|
65 |
|
66 | const getDiffToFs = (fs, outputPath, currentAssets, callback) => {
|
67 | const directories = new Set();
|
68 |
|
69 | for (const [asset] of currentAssets) {
|
70 | directories.add(asset.replace(/(^|\/)[^/]*$/, ""));
|
71 | }
|
72 |
|
73 | for (const directory of directories) {
|
74 | directories.add(directory.replace(/(^|\/)[^/]*$/, ""));
|
75 | }
|
76 | const diff = new Set();
|
77 | asyncLib.forEachLimit(
|
78 | directories,
|
79 | 10,
|
80 | (directory, callback) => {
|
81 | fs.readdir(join(fs, outputPath, directory), (err, entries) => {
|
82 | if (err) {
|
83 | if (err.code === "ENOENT") return callback();
|
84 | if (err.code === "ENOTDIR") {
|
85 | diff.add(directory);
|
86 | return callback();
|
87 | }
|
88 | return callback(err);
|
89 | }
|
90 | for (const entry of entries) {
|
91 | const file = (entry);
|
92 | const filename = directory ? `${directory}/${file}` : file;
|
93 | if (!directories.has(filename) && !currentAssets.has(filename)) {
|
94 | diff.add(filename);
|
95 | }
|
96 | }
|
97 | callback();
|
98 | });
|
99 | },
|
100 | err => {
|
101 | if (err) return callback(err);
|
102 |
|
103 | callback(null, diff);
|
104 | }
|
105 | );
|
106 | };
|
107 |
|
108 |
|
109 |
|
110 |
|
111 |
|
112 |
|
113 | const getDiffToOldAssets = (currentAssets, oldAssets) => {
|
114 | const diff = new Set();
|
115 | const now = Date.now();
|
116 | for (const [asset, ts] of oldAssets) {
|
117 | if (ts >= now) continue;
|
118 | if (!currentAssets.has(asset)) diff.add(asset);
|
119 | }
|
120 | return diff;
|
121 | };
|
122 |
|
123 |
|
124 |
|
125 |
|
126 |
|
127 |
|
128 |
|
129 | const doStat = (fs, filename, callback) => {
|
130 | if ("lstat" in fs) {
|
131 | fs.lstat(filename, callback);
|
132 | } else {
|
133 | fs.stat(filename, callback);
|
134 | }
|
135 | };
|
136 |
|
137 |
|
138 |
|
139 |
|
140 |
|
141 |
|
142 |
|
143 |
|
144 |
|
145 |
|
146 |
|
147 | const applyDiff = (fs, outputPath, dry, logger, diff, isKept, callback) => {
|
148 | const log = msg => {
|
149 | if (dry) {
|
150 | logger.info(msg);
|
151 | } else {
|
152 | logger.log(msg);
|
153 | }
|
154 | };
|
155 |
|
156 |
|
157 | const jobs = Array.from(diff.keys(), filename => ({
|
158 | type: "check",
|
159 | filename,
|
160 | parent: undefined
|
161 | }));
|
162 |
|
163 | const keptAssets = new Map();
|
164 | processAsyncTree(
|
165 | jobs,
|
166 | 10,
|
167 | ({ type, filename, parent }, push, callback) => {
|
168 | const handleError = err => {
|
169 | if (err.code === "ENOENT") {
|
170 | log(`${filename} was removed during cleaning by something else`);
|
171 | handleParent();
|
172 | return callback();
|
173 | }
|
174 | return callback(err);
|
175 | };
|
176 | const handleParent = () => {
|
177 | if (parent && --parent.remaining === 0) push(parent.job);
|
178 | };
|
179 | const path = join(fs, outputPath, filename);
|
180 | switch (type) {
|
181 | case "check":
|
182 | if (isKept(filename)) {
|
183 | keptAssets.set(filename, 0);
|
184 |
|
185 | log(`${filename} will be kept`);
|
186 | return process.nextTick(callback);
|
187 | }
|
188 | doStat(fs, path, (err, stats) => {
|
189 | if (err) return handleError(err);
|
190 | if (!stats.isDirectory()) {
|
191 | push({
|
192 | type: "unlink",
|
193 | filename,
|
194 | parent
|
195 | });
|
196 | return callback();
|
197 | }
|
198 | fs.readdir(path, (err, entries) => {
|
199 | if (err) return handleError(err);
|
200 |
|
201 | const deleteJob = {
|
202 | type: "rmdir",
|
203 | filename,
|
204 | parent
|
205 | };
|
206 | if (entries.length === 0) {
|
207 | push(deleteJob);
|
208 | } else {
|
209 | const parentToken = {
|
210 | remaining: entries.length,
|
211 | job: deleteJob
|
212 | };
|
213 | for (const entry of entries) {
|
214 | const file = (entry);
|
215 | if (file.startsWith(".")) {
|
216 | log(
|
217 | `${filename} will be kept (dot-files will never be removed)`
|
218 | );
|
219 | continue;
|
220 | }
|
221 | push({
|
222 | type: "check",
|
223 | filename: `${filename}/${file}`,
|
224 | parent: parentToken
|
225 | });
|
226 | }
|
227 | }
|
228 | return callback();
|
229 | });
|
230 | });
|
231 | break;
|
232 | case "rmdir":
|
233 | log(`${filename} will be removed`);
|
234 | if (dry) {
|
235 | handleParent();
|
236 | return process.nextTick(callback);
|
237 | }
|
238 | if (!fs.rmdir) {
|
239 | logger.warn(
|
240 | `${filename} can't be removed because output file system doesn't support removing directories (rmdir)`
|
241 | );
|
242 | return process.nextTick(callback);
|
243 | }
|
244 | fs.rmdir(path, err => {
|
245 | if (err) return handleError(err);
|
246 | handleParent();
|
247 | callback();
|
248 | });
|
249 | break;
|
250 | case "unlink":
|
251 | log(`${filename} will be removed`);
|
252 | if (dry) {
|
253 | handleParent();
|
254 | return process.nextTick(callback);
|
255 | }
|
256 | if (!fs.unlink) {
|
257 | logger.warn(
|
258 | `${filename} can't be removed because output file system doesn't support removing files (rmdir)`
|
259 | );
|
260 | return process.nextTick(callback);
|
261 | }
|
262 | fs.unlink(path, err => {
|
263 | if (err) return handleError(err);
|
264 | handleParent();
|
265 | callback();
|
266 | });
|
267 | break;
|
268 | }
|
269 | },
|
270 | err => {
|
271 | if (err) return callback(err);
|
272 | callback(undefined, keptAssets);
|
273 | }
|
274 | );
|
275 | };
|
276 |
|
277 |
|
278 | const compilationHooksMap = new WeakMap();
|
279 |
|
280 | class CleanPlugin {
|
281 | |
282 |
|
283 |
|
284 |
|
285 | static getCompilationHooks(compilation) {
|
286 | if (!(compilation instanceof Compilation)) {
|
287 | throw new TypeError(
|
288 | "The 'compilation' argument must be an instance of Compilation"
|
289 | );
|
290 | }
|
291 | let hooks = compilationHooksMap.get(compilation);
|
292 | if (hooks === undefined) {
|
293 | hooks = {
|
294 |
|
295 | keep: new SyncBailHook(["ignore"])
|
296 | };
|
297 | compilationHooksMap.set(compilation, hooks);
|
298 | }
|
299 | return hooks;
|
300 | }
|
301 |
|
302 |
|
303 | constructor(options = {}) {
|
304 | validate(options);
|
305 | this.options = { dry: false, ...options };
|
306 | }
|
307 |
|
308 | |
309 |
|
310 |
|
311 |
|
312 |
|
313 | apply(compiler) {
|
314 | const { dry, keep } = this.options;
|
315 |
|
316 | const keepFn =
|
317 | typeof keep === "function"
|
318 | ? keep
|
319 | : typeof keep === "string"
|
320 | ? path => path.startsWith(keep)
|
321 | : typeof keep === "object" && keep.test
|
322 | ? path => keep.test(path)
|
323 | : () => false;
|
324 |
|
325 |
|
326 |
|
327 |
|
328 |
|
329 | let oldAssets;
|
330 |
|
331 | compiler.hooks.emit.tapAsync(
|
332 | {
|
333 | name: "CleanPlugin",
|
334 | stage: 100
|
335 | },
|
336 | (compilation, callback) => {
|
337 | const hooks = CleanPlugin.getCompilationHooks(compilation);
|
338 | const logger = compilation.getLogger("webpack.CleanPlugin");
|
339 | const fs = compiler.outputFileSystem;
|
340 |
|
341 | if (!fs.readdir) {
|
342 | return callback(
|
343 | new Error(
|
344 | "CleanPlugin: Output filesystem doesn't support listing directories (readdir)"
|
345 | )
|
346 | );
|
347 | }
|
348 |
|
349 |
|
350 | const currentAssets = new Map();
|
351 | const now = Date.now();
|
352 | for (const asset of Object.keys(compilation.assets)) {
|
353 | if (/^[A-Za-z]:\\|^\/|^\\\\/.test(asset)) continue;
|
354 | let normalizedAsset;
|
355 | let newNormalizedAsset = asset.replace(/\\/g, "/");
|
356 | do {
|
357 | normalizedAsset = newNormalizedAsset;
|
358 | newNormalizedAsset = normalizedAsset.replace(
|
359 | /(^|\/)(?!\.\.)[^/]+\/\.\.\//g,
|
360 | "$1"
|
361 | );
|
362 | } while (newNormalizedAsset !== normalizedAsset);
|
363 | if (normalizedAsset.startsWith("../")) continue;
|
364 | const assetInfo = compilation.assetsInfo.get(asset);
|
365 | if (assetInfo && assetInfo.hotModuleReplacement) {
|
366 | currentAssets.set(normalizedAsset, now + _10sec);
|
367 | } else {
|
368 | currentAssets.set(normalizedAsset, 0);
|
369 | }
|
370 | }
|
371 |
|
372 | const outputPath = compilation.getPath(compiler.outputPath, {});
|
373 |
|
374 | const isKept = path => {
|
375 | const result = hooks.keep.call(path);
|
376 | if (result !== undefined) return result;
|
377 | return keepFn(path);
|
378 | };
|
379 |
|
380 | |
381 |
|
382 |
|
383 |
|
384 | const diffCallback = (err, diff) => {
|
385 | if (err) {
|
386 | oldAssets = undefined;
|
387 | callback(err);
|
388 | return;
|
389 | }
|
390 | applyDiff(
|
391 | fs,
|
392 | outputPath,
|
393 | dry,
|
394 | logger,
|
395 | diff,
|
396 | isKept,
|
397 | (err, keptAssets) => {
|
398 | if (err) {
|
399 | oldAssets = undefined;
|
400 | } else {
|
401 | if (oldAssets) mergeAssets(currentAssets, oldAssets);
|
402 | oldAssets = currentAssets;
|
403 | if (keptAssets) mergeAssets(oldAssets, keptAssets);
|
404 | }
|
405 | callback(err);
|
406 | }
|
407 | );
|
408 | };
|
409 |
|
410 | if (oldAssets) {
|
411 | diffCallback(null, getDiffToOldAssets(currentAssets, oldAssets));
|
412 | } else {
|
413 | getDiffToFs(fs, outputPath, currentAssets, diffCallback);
|
414 | }
|
415 | }
|
416 | );
|
417 | }
|
418 | }
|
419 |
|
420 | module.exports = CleanPlugin;
|