source control 1.1

Tomas

2022-05-19 957a1f10a06fdbb76f1a0ba94fe44126c613fee3

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
/*
    MIT License http://www.opensource.org/licenses/mit-license.php
    Author Tobias Koppers @sokra
*/
"use strict";
 
const asyncLib = require("neo-async");
 
class CachePlugin {
    constructor(cache) {
        this.cache = cache || {};
        this.FS_ACCURACY = 2000;
    }
 
    apply(compiler) {
        if (Array.isArray(compiler.compilers)) {
            compiler.compilers.forEach((c, idx) => {
                new CachePlugin((this.cache[idx] = this.cache[idx] || {})).apply(c);
            });
        } else {
            const registerCacheToCompiler = (compiler, cache) => {
                compiler.hooks.thisCompilation.tap("CachePlugin", compilation => {
                    compilation.cache = cache;
                    compilation.hooks.childCompiler.tap(
                        "CachePlugin",
                        (childCompiler, compilerName, compilerIndex) => {
                            let childCache;
                            if (!cache.children) {
                                cache.children = {};
                            }
                            if (!cache.children[compilerName]) {
                                cache.children[compilerName] = [];
                            }
                            if (cache.children[compilerName][compilerIndex]) {
                                childCache = cache.children[compilerName][compilerIndex];
                            } else {
                                cache.children[compilerName].push((childCache = {}));
                            }
                            registerCacheToCompiler(childCompiler, childCache);
                        }
                    );
                });
            };
            registerCacheToCompiler(compiler, this.cache);
            compiler.hooks.watchRun.tap("CachePlugin", () => {
                this.watching = true;
            });
            compiler.hooks.run.tapAsync("CachePlugin", (compiler, callback) => {
                if (!compiler._lastCompilationFileDependencies) {
                    return callback();
                }
                const fs = compiler.inputFileSystem;
                const fileTs = (compiler.fileTimestamps = new Map());
                asyncLib.forEach(
                    compiler._lastCompilationFileDependencies,
                    (file, callback) => {
                        fs.stat(file, (err, stat) => {
                            if (err) {
                                if (err.code === "ENOENT") return callback();
                                return callback(err);
                            }
 
                            if (stat.mtime) this.applyMtime(+stat.mtime);
 
                            fileTs.set(file, +stat.mtime || Infinity);
 
                            callback();
                        });
                    },
                    err => {
                        if (err) return callback(err);
 
                        for (const [file, ts] of fileTs) {
                            fileTs.set(file, ts + this.FS_ACCURACY);
                        }
 
                        callback();
                    }
                );
            });
            compiler.hooks.afterCompile.tap("CachePlugin", compilation => {
                compilation.compiler._lastCompilationFileDependencies =
                    compilation.fileDependencies;
                compilation.compiler._lastCompilationContextDependencies =
                    compilation.contextDependencies;
            });
        }
    }
 
    /* istanbul ignore next */
    applyMtime(mtime) {
        if (this.FS_ACCURACY > 1 && mtime % 2 !== 0) this.FS_ACCURACY = 1;
        else if (this.FS_ACCURACY > 10 && mtime % 20 !== 0) this.FS_ACCURACY = 10;
        else if (this.FS_ACCURACY > 100 && mtime % 200 !== 0)
            this.FS_ACCURACY = 100;
        else if (this.FS_ACCURACY > 1000 && mtime % 2000 !== 0)
            this.FS_ACCURACY = 1000;
    }
}
module.exports = CachePlugin;