diff options
| author | Florian Dold <florian.dold@gmail.com> | 2017-05-03 15:35:00 +0200 |
|---|---|---|
| committer | Florian Dold <florian.dold@gmail.com> | 2017-05-03 15:35:00 +0200 |
| commit | de98e0b232509d5f40c135d540a70e415272ff85 (patch) | |
| tree | a79222a5b58484ab3b80d18efcaaa7ccc4769b33 /node_modules/watchpack | |
| parent | e0c9d480a73fa629c1e4a47d3e721f1d2d345406 (diff) | |
| download | wallet-core-de98e0b232509d5f40c135d540a70e415272ff85.tar.xz | |
node_modules
Diffstat (limited to 'node_modules/watchpack')
| -rw-r--r-- | node_modules/watchpack/LICENSE | 20 | ||||
| -rw-r--r-- | node_modules/watchpack/README.md | 72 | ||||
| -rw-r--r-- | node_modules/watchpack/lib/DirectoryWatcher.js | 342 | ||||
| -rw-r--r-- | node_modules/watchpack/lib/watcherManager.js | 33 | ||||
| -rw-r--r-- | node_modules/watchpack/lib/watchpack.js | 143 | ||||
| -rw-r--r-- | node_modules/watchpack/package.json | 44 |
6 files changed, 654 insertions, 0 deletions
diff --git a/node_modules/watchpack/LICENSE b/node_modules/watchpack/LICENSE new file mode 100644 index 000000000..818e30f71 --- /dev/null +++ b/node_modules/watchpack/LICENSE @@ -0,0 +1,20 @@ +Copyright JS Foundation and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/node_modules/watchpack/README.md b/node_modules/watchpack/README.md new file mode 100644 index 000000000..6ff7d9249 --- /dev/null +++ b/node_modules/watchpack/README.md @@ -0,0 +1,72 @@ +# watchpack
+
+Wrapper library for directory and file watching.
+
+[](https://travis-ci.org/webpack/watchpack) [](https://ci.appveyor.com/project/sokra/watchpack/branch/master) [![Test coverage][coveralls-image]][coveralls-url]
+
+## Concept
+
+watchpack high level API don't map directly to watchers. Instead a three level architecture ensures that for each directory only a single watcher exists.
+
+* The high level API requests `DirectoryWatchers` from a `WatcherManager`, which ensures that only a single `DirectoryWatcher` per directory is created.
+* A user-faced `Watcher` can be obtained from a `DirectoryWatcher` and provides a filtered view on the `DirectoryWatcher`.
+* Reference-counting is used on the `DirectoryWatcher` and `Watcher` to decide when to close them.
+* The real watchers (currently chokidar) are created by the `DirectoryWatcher`.
+* Files are never watched directly. This should keep the watcher count low.
+* Watching can be started in the past. This way watching can start after file reading.
+* Symlinks are not followed, instead the symlink is watched.
+
+## API
+
+``` javascript
+var Watchpack = require("watchpack");
+
+var wp = new Watchpack({
+ // options:
+ aggregateTimeout: 1000
+ // fire "aggregated" event when after a change for 1000ms no additonal change occured
+ // aggregated defaults to undefined, which doesn't fire an "aggregated" event
+
+ poll: true
+ // poll: true - use polling with the default interval
+ // poll: 10000 - use polling with an interval of 10s
+ // poll defaults to undefined, which prefer native watching methods
+ // Note: enable polling when watching on a network path
+
+ ignored: /node_modules/,
+ // anymatch-compatible definition of files/paths to be ignored
+ // see https://github.com/paulmillr/chokidar#path-filtering
+});
+
+// Watchpack.prototype.watch(string[] files, string[] directories, [number startTime])
+wp.watch(listOfFiles, listOfDirectories, Date.now() - 10000);
+// starts watching these files and directories
+// calling this again will override the files and directories
+
+wp.on("change", function(filePath, mtime) {
+ // filePath: the changed file
+ // mtime: last modified time for the changed file
+});
+
+wp.on("aggregated", function(changes) {
+ // changes: an array of all changed files
+});
+
+// Watchpack.prototype.pause()
+wp.pause();
+// stops emitting events, but keeps watchers open
+// next "watch" call can reuse the watchers
+
+// Watchpack.prototype.close()
+wp.close();
+// stops emitting events and closes all watchers
+
+// Watchpack.prototype.getTimes()
+var fileTimes = wp.getTimes();
+// returns an object with all know change times for files
+// this include timestamps from files not directly watched
+// key: absolute path, value: timestamp as number
+```
+
+[coveralls-url]: https://coveralls.io/r/webpack/watchpack/
+[coveralls-image]: https://img.shields.io/coveralls/webpack/watchpack.svg
diff --git a/node_modules/watchpack/lib/DirectoryWatcher.js b/node_modules/watchpack/lib/DirectoryWatcher.js new file mode 100644 index 000000000..908ff2397 --- /dev/null +++ b/node_modules/watchpack/lib/DirectoryWatcher.js @@ -0,0 +1,342 @@ +/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+var EventEmitter = require("events").EventEmitter;
+var async = require("async");
+var chokidar = require("chokidar");
+var fs = require("graceful-fs");
+var path = require("path");
+
+var watcherManager = require("./watcherManager");
+
+var FS_ACCURACY = 10000;
+
+
+function withoutCase(str) {
+ return str.toLowerCase();
+}
+
+
+function Watcher(directoryWatcher, filePath, startTime) {
+ EventEmitter.call(this);
+ this.directoryWatcher = directoryWatcher;
+ this.path = filePath;
+ this.startTime = startTime && +startTime;
+ this.data = 0;
+}
+
+Watcher.prototype = Object.create(EventEmitter.prototype);
+Watcher.prototype.constructor = Watcher;
+
+Watcher.prototype.checkStartTime = function checkStartTime(mtime, initial) {
+ if(typeof this.startTime !== "number") return !initial;
+ var startTime = this.startTime;
+ return startTime <= mtime;
+};
+
+Watcher.prototype.close = function close() {
+ this.emit("closed");
+};
+
+
+function DirectoryWatcher(directoryPath, options) {
+ EventEmitter.call(this);
+ this.options = options;
+ this.path = directoryPath;
+ this.files = Object.create(null);
+ this.directories = Object.create(null);
+ this.watcher = chokidar.watch(directoryPath, {
+ ignoreInitial: true,
+ persistent: true,
+ followSymlinks: false,
+ depth: 0,
+ atomic: false,
+ alwaysStat: true,
+ ignorePermissionErrors: true,
+ ignored: options.ignored,
+ usePolling: options.poll ? true : undefined,
+ interval: typeof options.poll === "number" ? options.poll : undefined
+ });
+ this.watcher.on("add", this.onFileAdded.bind(this));
+ this.watcher.on("addDir", this.onDirectoryAdded.bind(this));
+ this.watcher.on("change", this.onChange.bind(this));
+ this.watcher.on("unlink", this.onFileUnlinked.bind(this));
+ this.watcher.on("unlinkDir", this.onDirectoryUnlinked.bind(this));
+ this.watcher.on("error", this.onWatcherError.bind(this));
+ this.initialScan = true;
+ this.nestedWatching = false;
+ this.initialScanRemoved = [];
+ this.doInitialScan();
+ this.watchers = Object.create(null);
+ this.refs = 0;
+}
+module.exports = DirectoryWatcher;
+
+DirectoryWatcher.prototype = Object.create(EventEmitter.prototype);
+DirectoryWatcher.prototype.constructor = DirectoryWatcher;
+
+DirectoryWatcher.prototype.setFileTime = function setFileTime(filePath, mtime, initial, type) {
+ var now = Date.now();
+ var old = this.files[filePath];
+
+ this.files[filePath] = [initial ? Math.min(now, mtime) : now, mtime];
+
+ // we add the fs accurency to reach the maximum possible mtime
+ if(mtime)
+ mtime = mtime + FS_ACCURACY;
+
+ if(!old) {
+ if(mtime) {
+ if(this.watchers[withoutCase(filePath)]) {
+ this.watchers[withoutCase(filePath)].forEach(function(w) {
+ if(!initial || w.checkStartTime(mtime, initial)) {
+ w.emit("change", mtime, initial ? "initial" : type);
+ }
+ });
+ }
+ }
+ } else if(!initial && mtime && type !== "add") {
+ if(this.watchers[withoutCase(filePath)]) {
+ this.watchers[withoutCase(filePath)].forEach(function(w) {
+ w.emit("change", mtime, type);
+ });
+ }
+ } else if(!initial && !mtime) {
+ if(this.watchers[withoutCase(filePath)]) {
+ this.watchers[withoutCase(filePath)].forEach(function(w) {
+ w.emit("remove", type);
+ });
+ }
+ }
+ if(this.watchers[withoutCase(this.path)]) {
+ this.watchers[withoutCase(this.path)].forEach(function(w) {
+ if(!initial || w.checkStartTime(mtime, initial)) {
+ w.emit("change", filePath, mtime, initial ? "initial" : type);
+ }
+ });
+ }
+};
+
+DirectoryWatcher.prototype.setDirectory = function setDirectory(directoryPath, exist, initial, type) {
+ var old = this.directories[directoryPath];
+ if(!old) {
+ if(exist) {
+ if(this.nestedWatching) {
+ this.createNestedWatcher(directoryPath);
+ } else {
+ this.directories[directoryPath] = true;
+ }
+ }
+ } else {
+ if(!exist) {
+ if(this.nestedWatching)
+ this.directories[directoryPath].close();
+ delete this.directories[directoryPath];
+ if(!initial && this.watchers[withoutCase(this.path)]) {
+ this.watchers[withoutCase(this.path)].forEach(function(w) {
+ w.emit("change", directoryPath, w.data, initial ? "initial" : type);
+ });
+ }
+ }
+ }
+};
+
+DirectoryWatcher.prototype.createNestedWatcher = function(directoryPath) {
+ this.directories[directoryPath] = watcherManager.watchDirectory(directoryPath, this.options, 1);
+ this.directories[directoryPath].on("change", function(filePath, mtime, type) {
+ if(this.watchers[withoutCase(this.path)]) {
+ this.watchers[withoutCase(this.path)].forEach(function(w) {
+ if(w.checkStartTime(mtime, false)) {
+ w.emit("change", filePath, mtime, type);
+ }
+ });
+ }
+ }.bind(this));
+};
+
+DirectoryWatcher.prototype.setNestedWatching = function(flag) {
+ if(this.nestedWatching !== !!flag) {
+ this.nestedWatching = !!flag;
+ if(this.nestedWatching) {
+ Object.keys(this.directories).forEach(function(directory) {
+ this.createNestedWatcher(directory);
+ }, this);
+ } else {
+ Object.keys(this.directories).forEach(function(directory) {
+ this.directories[directory].close();
+ this.directories[directory] = true;
+ }, this);
+ }
+ }
+};
+
+DirectoryWatcher.prototype.watch = function watch(filePath, startTime) {
+ this.watchers[withoutCase(filePath)] = this.watchers[withoutCase(filePath)] || [];
+ this.refs++;
+ var watcher = new Watcher(this, filePath, startTime);
+ watcher.on("closed", function() {
+ var idx = this.watchers[withoutCase(filePath)].indexOf(watcher);
+ this.watchers[withoutCase(filePath)].splice(idx, 1);
+ if(this.watchers[withoutCase(filePath)].length === 0) {
+ delete this.watchers[withoutCase(filePath)];
+ if(this.path === filePath)
+ this.setNestedWatching(false);
+ }
+ if(--this.refs <= 0)
+ this.close();
+ }.bind(this));
+ this.watchers[withoutCase(filePath)].push(watcher);
+ var data;
+ if(filePath === this.path) {
+ this.setNestedWatching(true);
+ data = false;
+ Object.keys(this.files).forEach(function(file) {
+ var d = this.files[file];
+ if(!data)
+ data = d;
+ else
+ data = [Math.max(data[0], d[0]), Math.max(data[1], d[1])];
+ }, this);
+ } else {
+ data = this.files[filePath];
+ }
+ process.nextTick(function() {
+ if(data) {
+ var ts = data[0] === data[1] ? data[0] + FS_ACCURACY : data[0];
+ if(ts >= startTime)
+ watcher.emit("change", data[1]);
+ } else if(this.initialScan && this.initialScanRemoved.indexOf(filePath) >= 0) {
+ watcher.emit("remove");
+ }
+ }.bind(this));
+ return watcher;
+};
+
+DirectoryWatcher.prototype.onFileAdded = function onFileAdded(filePath, stat) {
+ if(filePath.indexOf(this.path) !== 0) return;
+ if(/[\\\/]/.test(filePath.substr(this.path.length + 1))) return;
+
+ this.setFileTime(filePath, +stat.mtime, false, "add");
+};
+
+DirectoryWatcher.prototype.onDirectoryAdded = function onDirectoryAdded(directoryPath /*, stat */) {
+ if(directoryPath.indexOf(this.path) !== 0) return;
+ if(/[\\\/]/.test(directoryPath.substr(this.path.length + 1))) return;
+ this.setDirectory(directoryPath, true, false, "add");
+};
+
+DirectoryWatcher.prototype.onChange = function onChange(filePath, stat) {
+ if(filePath.indexOf(this.path) !== 0) return;
+ if(/[\\\/]/.test(filePath.substr(this.path.length + 1))) return;
+ var mtime = +stat.mtime;
+ ensureFsAccuracy(mtime);
+ this.setFileTime(filePath, mtime, false, "change");
+};
+
+DirectoryWatcher.prototype.onFileUnlinked = function onFileUnlinked(filePath) {
+ if(filePath.indexOf(this.path) !== 0) return;
+ if(/[\\\/]/.test(filePath.substr(this.path.length + 1))) return;
+ this.setFileTime(filePath, null, false, "unlink");
+ if(this.initialScan) {
+ this.initialScanRemoved.push(filePath);
+ }
+};
+
+DirectoryWatcher.prototype.onDirectoryUnlinked = function onDirectoryUnlinked(directoryPath) {
+ if(directoryPath.indexOf(this.path) !== 0) return;
+ if(/[\\\/]/.test(directoryPath.substr(this.path.length + 1))) return;
+ this.setDirectory(directoryPath, false, false, "unlink");
+ if(this.initialScan) {
+ this.initialScanRemoved.push(directoryPath);
+ }
+};
+
+DirectoryWatcher.prototype.onWatcherError = function onWatcherError(/* err */) {
+};
+
+DirectoryWatcher.prototype.doInitialScan = function doInitialScan() {
+ fs.readdir(this.path, function(err, items) {
+ if(err) {
+ this.initialScan = false;
+ return;
+ }
+ async.forEach(items, function(item, callback) {
+ var itemPath = path.join(this.path, item);
+ fs.stat(itemPath, function(err2, stat) {
+ if(!this.initialScan) return;
+ if(err2) {
+ callback();
+ return;
+ }
+ if(stat.isFile()) {
+ if(!this.files[itemPath])
+ this.setFileTime(itemPath, +stat.mtime, true);
+ } else if(stat.isDirectory()) {
+ if(!this.directories[itemPath])
+ this.setDirectory(itemPath, true, true);
+ }
+ callback();
+ }.bind(this));
+ }.bind(this), function() {
+ this.initialScan = false;
+ this.initialScanRemoved = null;
+ }.bind(this));
+ }.bind(this));
+};
+
+DirectoryWatcher.prototype.getTimes = function() {
+ var obj = Object.create(null);
+ var selfTime = 0;
+ Object.keys(this.files).forEach(function(file) {
+ var data = this.files[file];
+ var time;
+ if(data[1]) {
+ time = Math.max(data[0], data[1] + FS_ACCURACY);
+ } else {
+ time = data[0];
+ }
+ obj[file] = time;
+ if(time > selfTime)
+ selfTime = time;
+ }, this);
+ if(this.nestedWatching) {
+ Object.keys(this.directories).forEach(function(dir) {
+ var w = this.directories[dir];
+ var times = w.directoryWatcher.getTimes();
+ Object.keys(times).forEach(function(file) {
+ var time = times[file];
+ obj[file] = time;
+ if(time > selfTime)
+ selfTime = time;
+ });
+ }, this);
+ obj[this.path] = selfTime;
+ }
+ return obj;
+};
+
+DirectoryWatcher.prototype.close = function() {
+ this.initialScan = false;
+ this.watcher.close();
+ if(this.nestedWatching) {
+ Object.keys(this.directories).forEach(function(dir) {
+ this.directories[dir].close();
+ }, this);
+ }
+ this.emit("closed");
+};
+
+function ensureFsAccuracy(mtime) {
+ if(!mtime) return;
+ if(FS_ACCURACY > 1 && mtime % 1 !== 0)
+ FS_ACCURACY = 1;
+ else if(FS_ACCURACY > 10 && mtime % 10 !== 0)
+ FS_ACCURACY = 10;
+ else if(FS_ACCURACY > 100 && mtime % 100 !== 0)
+ FS_ACCURACY = 100;
+ else if(FS_ACCURACY > 1000 && mtime % 1000 !== 0)
+ FS_ACCURACY = 1000;
+ else if(FS_ACCURACY > 2000 && mtime % 2000 !== 0)
+ FS_ACCURACY = 2000;
+}
diff --git a/node_modules/watchpack/lib/watcherManager.js b/node_modules/watchpack/lib/watcherManager.js new file mode 100644 index 000000000..ea7b5ecd4 --- /dev/null +++ b/node_modules/watchpack/lib/watcherManager.js @@ -0,0 +1,33 @@ +/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+var path = require("path");
+
+function WatcherManager() {
+ this.directoryWatchers = {};
+}
+
+WatcherManager.prototype.getDirectoryWatcher = function(directory, options) {
+ var DirectoryWatcher = require("./DirectoryWatcher");
+ options = options || {};
+ var key = directory + " " + JSON.stringify(options);
+ if(!this.directoryWatchers[key]) {
+ this.directoryWatchers[key] = new DirectoryWatcher(directory, options);
+ this.directoryWatchers[key].on("closed", function() {
+ delete this.directoryWatchers[key];
+ }.bind(this));
+ }
+ return this.directoryWatchers[key];
+};
+
+WatcherManager.prototype.watchFile = function watchFile(p, options, startTime) {
+ var directory = path.dirname(p);
+ return this.getDirectoryWatcher(directory, options).watch(p, startTime);
+};
+
+WatcherManager.prototype.watchDirectory = function watchDirectory(directory, options, startTime) {
+ return this.getDirectoryWatcher(directory, options).watch(directory, startTime);
+};
+
+module.exports = new WatcherManager();
diff --git a/node_modules/watchpack/lib/watchpack.js b/node_modules/watchpack/lib/watchpack.js new file mode 100644 index 000000000..3fcd93654 --- /dev/null +++ b/node_modules/watchpack/lib/watchpack.js @@ -0,0 +1,143 @@ +/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+var watcherManager = require("./watcherManager");
+var EventEmitter = require("events").EventEmitter;
+
+function Watchpack(options) {
+ EventEmitter.call(this);
+ if(!options) options = {};
+ if(!options.aggregateTimeout) options.aggregateTimeout = 200;
+ this.options = options;
+ this.watcherOptions = {
+ ignored: options.ignored,
+ poll: options.poll
+ };
+ this.fileWatchers = [];
+ this.dirWatchers = [];
+ this.mtimes = Object.create(null);
+ this.paused = false;
+ this.aggregatedChanges = [];
+ this.aggregatedRemovals = [];
+ this.aggregateTimeout = 0;
+ this._onTimeout = this._onTimeout.bind(this);
+}
+
+module.exports = Watchpack;
+
+Watchpack.prototype = Object.create(EventEmitter.prototype);
+
+Watchpack.prototype.watch = function watch(files, directories, startTime) {
+ this.paused = false;
+ var oldFileWatchers = this.fileWatchers;
+ var oldDirWatchers = this.dirWatchers;
+ this.fileWatchers = files.map(function(file) {
+ return this._fileWatcher(file, watcherManager.watchFile(file, this.watcherOptions, startTime));
+ }, this);
+ this.dirWatchers = directories.map(function(dir) {
+ return this._dirWatcher(dir, watcherManager.watchDirectory(dir, this.watcherOptions, startTime));
+ }, this);
+ oldFileWatchers.forEach(function(w) {
+ w.close();
+ }, this);
+ oldDirWatchers.forEach(function(w) {
+ w.close();
+ }, this);
+};
+
+Watchpack.prototype.close = function resume() {
+ this.paused = true;
+ if(this.aggregateTimeout)
+ clearTimeout(this.aggregateTimeout);
+ this.fileWatchers.forEach(function(w) {
+ w.close();
+ }, this);
+ this.dirWatchers.forEach(function(w) {
+ w.close();
+ }, this);
+ this.fileWatchers.length = 0;
+ this.dirWatchers.length = 0;
+};
+
+Watchpack.prototype.pause = function pause() {
+ this.paused = true;
+ if(this.aggregateTimeout)
+ clearTimeout(this.aggregateTimeout);
+};
+
+function addWatchersToArray(watchers, array) {
+ watchers.forEach(function(w) {
+ if(array.indexOf(w.directoryWatcher) < 0) {
+ array.push(w.directoryWatcher);
+ addWatchersToArray(Object.keys(w.directoryWatcher.directories).reduce(function(a, dir) {
+ if(w.directoryWatcher.directories[dir] !== true)
+ a.push(w.directoryWatcher.directories[dir]);
+ return a;
+ }, []), array);
+ }
+ });
+}
+
+Watchpack.prototype.getTimes = function() {
+ var directoryWatchers = [];
+ addWatchersToArray(this.fileWatchers.concat(this.dirWatchers), directoryWatchers);
+ var obj = Object.create(null);
+ directoryWatchers.forEach(function(w) {
+ var times = w.getTimes();
+ Object.keys(times).forEach(function(file) {
+ obj[file] = times[file];
+ });
+ });
+ return obj;
+};
+
+Watchpack.prototype._fileWatcher = function _fileWatcher(file, watcher) {
+ watcher.on("change", function(mtime, type) {
+ this._onChange(file, mtime, file, type);
+ }.bind(this));
+ watcher.on("remove", function(type) {
+ this._onRemove(file, file, type);
+ }.bind(this));
+ return watcher;
+};
+
+Watchpack.prototype._dirWatcher = function _dirWatcher(item, watcher) {
+ watcher.on("change", function(file, mtime, type) {
+ this._onChange(item, mtime, file, type);
+ }.bind(this));
+ return watcher;
+};
+
+Watchpack.prototype._onChange = function _onChange(item, mtime, file) {
+ file = file || item;
+ this.mtimes[file] = mtime;
+ if(this.paused) return;
+ this.emit("change", file, mtime);
+ if(this.aggregateTimeout)
+ clearTimeout(this.aggregateTimeout);
+ if(this.aggregatedChanges.indexOf(item) < 0)
+ this.aggregatedChanges.push(item);
+ this.aggregateTimeout = setTimeout(this._onTimeout, this.options.aggregateTimeout);
+};
+
+Watchpack.prototype._onRemove = function _onRemove(item, file) {
+ file = file || item;
+ delete this.mtimes[item];
+ if(this.paused) return;
+ this.emit("remove", item);
+ if(this.aggregateTimeout)
+ clearTimeout(this.aggregateTimeout);
+ if(this.aggregatedRemovals.indexOf(item) < 0)
+ this.aggregatedRemovals.push(item);
+ this.aggregateTimeout = setTimeout(this._onTimeout, this.options.aggregateTimeout);
+};
+
+Watchpack.prototype._onTimeout = function _onTimeout() {
+ this.aggregateTimeout = 0;
+ var changes = this.aggregatedChanges;
+ var removals = this.aggregatedRemovals;
+ this.aggregatedChanges = [];
+ this.aggregatedRemovals = [];
+ this.emit("aggregated", changes, removals);
+};
diff --git a/node_modules/watchpack/package.json b/node_modules/watchpack/package.json new file mode 100644 index 000000000..b2017ff7e --- /dev/null +++ b/node_modules/watchpack/package.json @@ -0,0 +1,44 @@ +{ + "name": "watchpack", + "version": "1.3.1", + "description": "", + "main": "./lib/watchpack.js", + "directories": { + "test": "test" + }, + "files": [ + "lib/" + ], + "scripts": { + "pretest": "npm run lint", + "test": "mocha", + "travis": "npm run cover -- --report lcovonly", + "lint": "eslint lib", + "precover": "npm run lint", + "cover": "istanbul cover node_modules/mocha/bin/_mocha" + }, + "repository": { + "type": "git", + "url": "https://github.com/webpack/watchpack.git" + }, + "author": "Tobias Koppers @sokra", + "license": "MIT", + "bugs": { + "url": "https://github.com/webpack/watchpack/issues" + }, + "homepage": "https://github.com/webpack/watchpack", + "devDependencies": { + "codecov.io": "^0.1.6", + "coveralls": "^2.11.2", + "eslint": "^2.9.0", + "istanbul": "^0.4.3", + "mocha": "^2.1.0", + "rimraf": "~2.5.0", + "should": "^8.3.1" + }, + "dependencies": { + "async": "^2.1.2", + "chokidar": "^1.4.3", + "graceful-fs": "^4.1.2" + } +} |