TODO#139894 [ footer -最下方說明與保經代合作 ] 文案修改

HelenHuang

2022-06-09 9bdb95c9e34cef640534e5e5a1e2225a80442000

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
101
102
103
104
105
106
107
108
109
/*
    MIT License http://www.opensource.org/licenses/mit-license.php
    Author Tobias Koppers @sokra
*/
"use strict";
 
const Watchpack = require("watchpack");
const objectToMap = require("../util/objectToMap");
 
class NodeWatchFileSystem {
    constructor(inputFileSystem) {
        this.inputFileSystem = inputFileSystem;
        this.watcherOptions = {
            aggregateTimeout: 0
        };
        this.watcher = new Watchpack(this.watcherOptions);
    }
 
    watch(files, dirs, missing, startTime, options, callback, callbackUndelayed) {
        if (!Array.isArray(files)) {
            throw new Error("Invalid arguments: 'files'");
        }
        if (!Array.isArray(dirs)) {
            throw new Error("Invalid arguments: 'dirs'");
        }
        if (!Array.isArray(missing)) {
            throw new Error("Invalid arguments: 'missing'");
        }
        if (typeof callback !== "function") {
            throw new Error("Invalid arguments: 'callback'");
        }
        if (typeof startTime !== "number" && startTime) {
            throw new Error("Invalid arguments: 'startTime'");
        }
        if (typeof options !== "object") {
            throw new Error("Invalid arguments: 'options'");
        }
        if (typeof callbackUndelayed !== "function" && callbackUndelayed) {
            throw new Error("Invalid arguments: 'callbackUndelayed'");
        }
        const oldWatcher = this.watcher;
        this.watcher = new Watchpack(options);
 
        if (callbackUndelayed) {
            this.watcher.once("change", callbackUndelayed);
        }
        const cachedFiles = files;
        const cachedDirs = dirs;
        this.watcher.once("aggregated", (changes, removals) => {
            changes = changes.concat(removals);
            if (this.inputFileSystem && this.inputFileSystem.purge) {
                this.inputFileSystem.purge(changes);
            }
            const times = objectToMap(this.watcher.getTimes());
            files = new Set(files);
            dirs = new Set(dirs);
            missing = new Set(missing);
            removals = new Set(removals.filter(file => files.has(file)));
            callback(
                null,
                changes.filter(file => files.has(file)).sort(),
                changes.filter(file => dirs.has(file)).sort(),
                changes.filter(file => missing.has(file)).sort(),
                times,
                times,
                removals
            );
        });
 
        this.watcher.watch(
            cachedFiles.concat(missing),
            cachedDirs.concat(missing),
            startTime
        );
 
        if (oldWatcher) {
            oldWatcher.close();
        }
        return {
            close: () => {
                if (this.watcher) {
                    this.watcher.close();
                    this.watcher = null;
                }
            },
            pause: () => {
                if (this.watcher) {
                    this.watcher.pause();
                }
            },
            getFileTimestamps: () => {
                if (this.watcher) {
                    return objectToMap(this.watcher.getTimes());
                } else {
                    return new Map();
                }
            },
            getContextTimestamps: () => {
                if (this.watcher) {
                    return objectToMap(this.watcher.getTimes());
                } else {
                    return new Map();
                }
            }
        };
    }
}
 
module.exports = NodeWatchFileSystem;