webpack 3.8.0 → 3.8.1

package/lib/optimize/LimitChunkCountPlugin.js

@@ -1,59 +1,59 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-"use strict";
-
-class LimitChunkCountPlugin {
-	constructor(options) {
-		if(options !== undefined && typeof options !== "object" || Array.isArray(options)) {
-			throw new Error("Argument should be an options object.\nFor more info on options, see https://webpack.js.org/plugins/");
-		}
-		this.options = options || {};
-	}
-	apply(compiler) {
-		const options = this.options;
-		compiler.plugin("compilation", (compilation) => {
-			compilation.plugin("optimize-chunks-advanced", (chunks) => {
-				const maxChunks = options.maxChunks;
-				if(!maxChunks) return;
-				if(maxChunks < 1) return;
-				if(chunks.length <= maxChunks) return;
-
-				if(chunks.length > maxChunks) {
-					const sortedExtendedPairCombinations = chunks.reduce((combinations, a, idx) => {
-						// create combination pairs
-						for(let i = 0; i < idx; i++) {
-							const b = chunks[i];
-							combinations.push([b, a]);
-						}
-						return combinations;
-					}, []).map((pair) => {
-						// extend combination pairs with size and integrated size
-						const a = pair[0].size(options);
-						const b = pair[1].size(options);
-						const ab = pair[0].integratedSize(pair[1], options);
-						return [a + b - ab, ab, pair[0], pair[1], a, b];
-					}).filter((extendedPair) => {
-						// filter pairs that do not have an integratedSize
-						// meaning they can NOT be integrated!
-						return extendedPair[1] !== false;
-					}).sort((a, b) => { // sadly javascript does an inplace sort here
-						// sort them by size
-						const diff = b[0] - a[0];
-						if(diff !== 0) return diff;
-						return a[1] - b[1];
-					});
-
-					const pair = sortedExtendedPairCombinations[0];
-
-					if(pair && pair[2].integrate(pair[3], "limit")) {
-						chunks.splice(chunks.indexOf(pair[3]), 1);
-						return true;
-					}
-				}
-			});
-		});
-	}
-}
-module.exports = LimitChunkCountPlugin;
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+class LimitChunkCountPlugin {
+	constructor(options) {
+		if(options !== undefined && typeof options !== "object" || Array.isArray(options)) {
+			throw new Error("Argument should be an options object.\nFor more info on options, see https://webpack.js.org/plugins/");
+		}
+		this.options = options || {};
+	}
+	apply(compiler) {
+		const options = this.options;
+		compiler.plugin("compilation", (compilation) => {
+			compilation.plugin("optimize-chunks-advanced", (chunks) => {
+				const maxChunks = options.maxChunks;
+				if(!maxChunks) return;
+				if(maxChunks < 1) return;
+				if(chunks.length <= maxChunks) return;
+
+				if(chunks.length > maxChunks) {
+					const sortedExtendedPairCombinations = chunks.reduce((combinations, a, idx) => {
+						// create combination pairs
+						for(let i = 0; i < idx; i++) {
+							const b = chunks[i];
+							combinations.push([b, a]);
+						}
+						return combinations;
+					}, []).map((pair) => {
+						// extend combination pairs with size and integrated size
+						const a = pair[0].size(options);
+						const b = pair[1].size(options);
+						const ab = pair[0].integratedSize(pair[1], options);
+						return [a + b - ab, ab, pair[0], pair[1], a, b];
+					}).filter((extendedPair) => {
+						// filter pairs that do not have an integratedSize
+						// meaning they can NOT be integrated!
+						return extendedPair[1] !== false;
+					}).sort((a, b) => { // sadly javascript does an inplace sort here
+						// sort them by size
+						const diff = b[0] - a[0];
+						if(diff !== 0) return diff;
+						return a[1] - b[1];
+					});
+
+					const pair = sortedExtendedPairCombinations[0];
+
+					if(pair && pair[2].integrate(pair[3], "limit")) {
+						chunks.splice(chunks.indexOf(pair[3]), 1);
+						return true;
+					}
+				}
+			});
+		});
+	}
+}
+module.exports = LimitChunkCountPlugin;

package/lib/optimize/MinChunkSizePlugin.js

@@ -1,65 +1,65 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-"use strict";
-
-class MinChunkSizePlugin {
-	constructor(options) {
-		if(typeof options !== "object" || Array.isArray(options)) {
-			throw new Error("Argument should be an options object.\nFor more info on options, see https://webpack.js.org/plugins/");
-		}
-		this.options = options;
-	}
-
-	apply(compiler) {
-		const options = this.options;
-		const minChunkSize = options.minChunkSize;
-		compiler.plugin("compilation", (compilation) => {
-			compilation.plugin("optimize-chunks-advanced", (chunks) => {
-				const equalOptions = {
-					chunkOverhead: 1,
-					entryChunkMultiplicator: 1
-				};
-
-				const sortedSizeFilteredExtendedPairCombinations = chunks.reduce((combinations, a, idx) => {
-					// create combination pairs
-					for(let i = 0; i < idx; i++) {
-						const b = chunks[i];
-						combinations.push([b, a]);
-					}
-					return combinations;
-				}, []).filter((pair) => {
-					// check if one of the chunks sizes is smaller than the minChunkSize
-					const p0SmallerThanMinChunkSize = pair[0].size(equalOptions) < minChunkSize;
-					const p1SmallerThanMinChunkSize = pair[1].size(equalOptions) < minChunkSize;
-					return p0SmallerThanMinChunkSize || p1SmallerThanMinChunkSize;
-				}).map((pair) => {
-					// extend combination pairs with size and integrated size
-					const a = pair[0].size(options);
-					const b = pair[1].size(options);
-					const ab = pair[0].integratedSize(pair[1], options);
-					return [a + b - ab, ab, pair[0], pair[1]];
-				}).filter((pair) => {
-					// filter pairs that do not have an integratedSize
-					// meaning they can NOT be integrated!
-					return pair[1] !== false;
-				}).sort((a, b) => { // sadly javascript does an inplace sort here
-					// sort by size
-					const diff = b[0] - a[0];
-					if(diff !== 0) return diff;
-					return a[1] - b[1];
-				});
-
-				if(sortedSizeFilteredExtendedPairCombinations.length === 0) return;
-
-				const pair = sortedSizeFilteredExtendedPairCombinations[0];
-
-				pair[2].integrate(pair[3], "min-size");
-				chunks.splice(chunks.indexOf(pair[3]), 1);
-				return true;
-			});
-		});
-	}
-}
-module.exports = MinChunkSizePlugin;
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+class MinChunkSizePlugin {
+	constructor(options) {
+		if(typeof options !== "object" || Array.isArray(options)) {
+			throw new Error("Argument should be an options object.\nFor more info on options, see https://webpack.js.org/plugins/");
+		}
+		this.options = options;
+	}
+
+	apply(compiler) {
+		const options = this.options;
+		const minChunkSize = options.minChunkSize;
+		compiler.plugin("compilation", (compilation) => {
+			compilation.plugin("optimize-chunks-advanced", (chunks) => {
+				const equalOptions = {
+					chunkOverhead: 1,
+					entryChunkMultiplicator: 1
+				};
+
+				const sortedSizeFilteredExtendedPairCombinations = chunks.reduce((combinations, a, idx) => {
+					// create combination pairs
+					for(let i = 0; i < idx; i++) {
+						const b = chunks[i];
+						combinations.push([b, a]);
+					}
+					return combinations;
+				}, []).filter((pair) => {
+					// check if one of the chunks sizes is smaller than the minChunkSize
+					const p0SmallerThanMinChunkSize = pair[0].size(equalOptions) < minChunkSize;
+					const p1SmallerThanMinChunkSize = pair[1].size(equalOptions) < minChunkSize;
+					return p0SmallerThanMinChunkSize || p1SmallerThanMinChunkSize;
+				}).map((pair) => {
+					// extend combination pairs with size and integrated size
+					const a = pair[0].size(options);
+					const b = pair[1].size(options);
+					const ab = pair[0].integratedSize(pair[1], options);
+					return [a + b - ab, ab, pair[0], pair[1]];
+				}).filter((pair) => {
+					// filter pairs that do not have an integratedSize
+					// meaning they can NOT be integrated!
+					return pair[1] !== false;
+				}).sort((a, b) => { // sadly javascript does an inplace sort here
+					// sort by size
+					const diff = b[0] - a[0];
+					if(diff !== 0) return diff;
+					return a[1] - b[1];
+				});
+
+				if(sortedSizeFilteredExtendedPairCombinations.length === 0) return;
+
+				const pair = sortedSizeFilteredExtendedPairCombinations[0];
+
+				pair[2].integrate(pair[3], "min-size");
+				chunks.splice(chunks.indexOf(pair[3]), 1);
+				return true;
+			});
+		});
+	}
+}
+module.exports = MinChunkSizePlugin;

package/lib/optimize/RemoveEmptyChunksPlugin.js

@@ -1,21 +1,21 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-"use strict";
-
-class RemoveEmptyChunksPlugin {
-
-	apply(compiler) {
-		compiler.plugin("compilation", (compilation) => {
-			compilation.plugin(["optimize-chunks-basic", "optimize-extracted-chunks-basic"], (chunks) => {
-				chunks.filter((chunk) => chunk.isEmpty() && !chunk.hasRuntime() && !chunk.hasEntryModule())
-					.forEach((chunk) => {
-						chunk.remove("empty");
-						chunks.splice(chunks.indexOf(chunk), 1);
-					});
-			});
-		});
-	}
-}
-module.exports = RemoveEmptyChunksPlugin;
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+class RemoveEmptyChunksPlugin {
+
+	apply(compiler) {
+		compiler.plugin("compilation", (compilation) => {
+			compilation.plugin(["optimize-chunks-basic", "optimize-extracted-chunks-basic"], (chunks) => {
+				chunks.filter((chunk) => chunk.isEmpty() && !chunk.hasRuntime() && !chunk.hasEntryModule())
+					.forEach((chunk) => {
+						chunk.remove("empty");
+						chunks.splice(chunks.indexOf(chunk), 1);
+					});
+			});
+		});
+	}
+}
+module.exports = RemoveEmptyChunksPlugin;

package/lib/optimize/UglifyJsPlugin.js

@@ -1,9 +1,9 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-"use strict";
-
-const UglifyJsPlugin = require("uglifyjs-webpack-plugin");
-
-module.exports = UglifyJsPlugin;
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const UglifyJsPlugin = require("uglifyjs-webpack-plugin");
+
+module.exports = UglifyJsPlugin;

package/lib/performance/AssetsOverSizeLimitWarning.js

@@ -1,23 +1,23 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Sean Larkin @thelarkinn
-*/
-"use strict";
-
-const WebpackError = require("../WebpackError");
-const SizeFormatHelpers = require("../SizeFormatHelpers");
-
-module.exports = class AssetsOverSizeLimitWarning extends WebpackError {
-	constructor(assetsOverSizeLimit, assetLimit) {
-		super();
-
-		this.name = "AssetsOverSizeLimitWarning";
-		this.assets = assetsOverSizeLimit;
-		const assetLists = this.assets.map(asset => `\n  ${asset.name} (${SizeFormatHelpers.formatSize(asset.size)})`).join("");
-		this.message = `asset size limit: The following asset(s) exceed the recommended size limit (${SizeFormatHelpers.formatSize(assetLimit)}).
-This can impact web performance.
-Assets: ${assetLists}`;
-
-		Error.captureStackTrace(this, this.constructor);
-	}
-};
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Sean Larkin @thelarkinn
+*/
+"use strict";
+
+const WebpackError = require("../WebpackError");
+const SizeFormatHelpers = require("../SizeFormatHelpers");
+
+module.exports = class AssetsOverSizeLimitWarning extends WebpackError {
+	constructor(assetsOverSizeLimit, assetLimit) {
+		super();
+
+		this.name = "AssetsOverSizeLimitWarning";
+		this.assets = assetsOverSizeLimit;
+		const assetLists = this.assets.map(asset => `\n  ${asset.name} (${SizeFormatHelpers.formatSize(asset.size)})`).join("");
+		this.message = `asset size limit: The following asset(s) exceed the recommended size limit (${SizeFormatHelpers.formatSize(assetLimit)}).
+This can impact web performance.
+Assets: ${assetLists}`;
+
+		Error.captureStackTrace(this, this.constructor);
+	}
+};

package/lib/performance/EntrypointsOverSizeLimitWarning.js

@@ -1,28 +1,28 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Sean Larkin @thelarkinn
-*/
-"use strict";
-
-const WebpackError = require("../WebpackError");
-const SizeFormatHelpers = require("../SizeFormatHelpers");
-
-module.exports = class EntrypointsOverSizeLimitWarning extends WebpackError {
-	constructor(entrypoints, entrypointLimit) {
-		super();
-
-		this.name = "EntrypointsOverSizeLimitWarning";
-		this.entrypoints = entrypoints;
-		const entrypointList = this.entrypoints.map(entrypoint => `\n  ${
-			entrypoint.name
-		} (${
-			SizeFormatHelpers.formatSize(entrypoint.size)
-		})\n${
-			entrypoint.files.map(asset => `      ${asset}`).join("\n")
-		}`).join("");
-		this.message = `entrypoint size limit: The following entrypoint(s) combined asset size exceeds the recommended limit (${SizeFormatHelpers.formatSize(entrypointLimit)}). This can impact web performance.
-Entrypoints:${entrypointList}\n`;
-
-		Error.captureStackTrace(this, this.constructor);
-	}
-};
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Sean Larkin @thelarkinn
+*/
+"use strict";
+
+const WebpackError = require("../WebpackError");
+const SizeFormatHelpers = require("../SizeFormatHelpers");
+
+module.exports = class EntrypointsOverSizeLimitWarning extends WebpackError {
+	constructor(entrypoints, entrypointLimit) {
+		super();
+
+		this.name = "EntrypointsOverSizeLimitWarning";
+		this.entrypoints = entrypoints;
+		const entrypointList = this.entrypoints.map(entrypoint => `\n  ${
+			entrypoint.name
+		} (${
+			SizeFormatHelpers.formatSize(entrypoint.size)
+		})\n${
+			entrypoint.files.map(asset => `      ${asset}`).join("\n")
+		}`).join("");
+		this.message = `entrypoint size limit: The following entrypoint(s) combined asset size exceeds the recommended limit (${SizeFormatHelpers.formatSize(entrypointLimit)}). This can impact web performance.
+Entrypoints:${entrypointList}\n`;
+
+		Error.captureStackTrace(this, this.constructor);
+	}
+};

package/lib/performance/NoAsyncChunksWarning.js

@@ -1,20 +1,20 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Sean Larkin @thelarkinn
-*/
-"use strict";
-
-const WebpackError = require("../WebpackError");
-
-module.exports = class NoAsyncChunksWarning extends WebpackError {
-	constructor() {
-		super();
-
-		this.name = "NoAsyncChunksWarning";
-		this.message = "webpack performance recommendations: \n" +
-			"You can limit the size of your bundles by using import() or require.ensure to lazy load some parts of your application.\n" +
-			"For more info visit https://webpack.js.org/guides/code-splitting/";
-
-		Error.captureStackTrace(this, this.constructor);
-	}
-};
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Sean Larkin @thelarkinn
+*/
+"use strict";
+
+const WebpackError = require("../WebpackError");
+
+module.exports = class NoAsyncChunksWarning extends WebpackError {
+	constructor() {
+		super();
+
+		this.name = "NoAsyncChunksWarning";
+		this.message = "webpack performance recommendations: \n" +
+			"You can limit the size of your bundles by using import() or require.ensure to lazy load some parts of your application.\n" +
+			"For more info visit https://webpack.js.org/guides/code-splitting/";
+
+		Error.captureStackTrace(this, this.constructor);
+	}
+};

package/lib/performance/SizeLimitsPlugin.js

@@ -1,102 +1,102 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Sean Larkin @thelarkinn
-*/
-"use strict";
-const EntrypointsOverSizeLimitWarning = require("./EntrypointsOverSizeLimitWarning");
-const AssetsOverSizeLimitWarning = require("./AssetsOverSizeLimitWarning");
-const NoAsyncChunksWarning = require("./NoAsyncChunksWarning");
-
-module.exports = class SizeLimitsPlugin {
-	constructor(options) {
-		this.hints = options.hints;
-		this.maxAssetSize = options.maxAssetSize;
-		this.maxEntrypointSize = options.maxEntrypointSize;
-		this.assetFilter = options.assetFilter;
-	}
-	apply(compiler) {
-		const entrypointSizeLimit = this.maxEntrypointSize;
-		const assetSizeLimit = this.maxAssetSize;
-		const hints = this.hints;
-		const assetFilter = this.assetFilter || (asset => !(/\.map$/.test(asset)));
-
-		compiler.plugin("after-emit", (compilation, callback) => {
-			const warnings = [];
-
-			const getEntrypointSize = entrypoint =>
-				entrypoint.getFiles()
-				.filter(assetFilter)
-				.map(file => compilation.assets[file])
-				.filter(Boolean)
-				.map(asset => asset.size())
-				.reduce((currentSize, nextSize) => currentSize + nextSize, 0);
-
-			const assetsOverSizeLimit = [];
-			Object.keys(compilation.assets)
-				.filter(assetFilter)
-				.forEach(assetName => {
-					const asset = compilation.assets[assetName];
-					const size = asset.size();
-
-					if(size > assetSizeLimit) {
-						assetsOverSizeLimit.push({
-							name: assetName,
-							size: size,
-						});
-						asset.isOverSizeLimit = true;
-					}
-				});
-
-			const entrypointsOverLimit = [];
-			Object.keys(compilation.entrypoints)
-				.forEach(key => {
-					const entry = compilation.entrypoints[key];
-					const size = getEntrypointSize(entry, compilation);
-
-					if(size > entrypointSizeLimit) {
-						entrypointsOverLimit.push({
-							name: key,
-							size: size,
-							files: entry.getFiles().filter(assetFilter)
-						});
-						entry.isOverSizeLimit = true;
-					}
-				});
-
-			if(hints) {
-				// 1. Individual Chunk: Size < 250kb
-				// 2. Collective Initial Chunks [entrypoint] (Each Set?): Size < 250kb
-				// 3. No Async Chunks
-				// if !1, then 2, if !2 return
-				if(assetsOverSizeLimit.length > 0) {
-					warnings.push(
-						new AssetsOverSizeLimitWarning(
-							assetsOverSizeLimit,
-							assetSizeLimit));
-				}
-				if(entrypointsOverLimit.length > 0) {
-					warnings.push(
-						new EntrypointsOverSizeLimitWarning(
-							entrypointsOverLimit,
-							entrypointSizeLimit));
-				}
-
-				if(warnings.length > 0) {
-					const hasAsyncChunks = compilation.chunks.filter(chunk => !chunk.isInitial()).length > 0;
-
-					if(!hasAsyncChunks) {
-						warnings.push(new NoAsyncChunksWarning());
-					}
-
-					if(hints === "error") {
-						Array.prototype.push.apply(compilation.errors, warnings);
-					} else {
-						Array.prototype.push.apply(compilation.warnings, warnings);
-					}
-				}
-			}
-
-			callback();
-		});
-	}
-};
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Sean Larkin @thelarkinn
+*/
+"use strict";
+const EntrypointsOverSizeLimitWarning = require("./EntrypointsOverSizeLimitWarning");
+const AssetsOverSizeLimitWarning = require("./AssetsOverSizeLimitWarning");
+const NoAsyncChunksWarning = require("./NoAsyncChunksWarning");
+
+module.exports = class SizeLimitsPlugin {
+	constructor(options) {
+		this.hints = options.hints;
+		this.maxAssetSize = options.maxAssetSize;
+		this.maxEntrypointSize = options.maxEntrypointSize;
+		this.assetFilter = options.assetFilter;
+	}
+	apply(compiler) {
+		const entrypointSizeLimit = this.maxEntrypointSize;
+		const assetSizeLimit = this.maxAssetSize;
+		const hints = this.hints;
+		const assetFilter = this.assetFilter || (asset => !(/\.map$/.test(asset)));
+
+		compiler.plugin("after-emit", (compilation, callback) => {
+			const warnings = [];
+
+			const getEntrypointSize = entrypoint =>
+				entrypoint.getFiles()
+				.filter(assetFilter)
+				.map(file => compilation.assets[file])
+				.filter(Boolean)
+				.map(asset => asset.size())
+				.reduce((currentSize, nextSize) => currentSize + nextSize, 0);
+
+			const assetsOverSizeLimit = [];
+			Object.keys(compilation.assets)
+				.filter(assetFilter)
+				.forEach(assetName => {
+					const asset = compilation.assets[assetName];
+					const size = asset.size();
+
+					if(size > assetSizeLimit) {
+						assetsOverSizeLimit.push({
+							name: assetName,
+							size: size,
+						});
+						asset.isOverSizeLimit = true;
+					}
+				});
+
+			const entrypointsOverLimit = [];
+			Object.keys(compilation.entrypoints)
+				.forEach(key => {
+					const entry = compilation.entrypoints[key];
+					const size = getEntrypointSize(entry, compilation);
+
+					if(size > entrypointSizeLimit) {
+						entrypointsOverLimit.push({
+							name: key,
+							size: size,
+							files: entry.getFiles().filter(assetFilter)
+						});
+						entry.isOverSizeLimit = true;
+					}
+				});
+
+			if(hints) {
+				// 1. Individual Chunk: Size < 250kb
+				// 2. Collective Initial Chunks [entrypoint] (Each Set?): Size < 250kb
+				// 3. No Async Chunks
+				// if !1, then 2, if !2 return
+				if(assetsOverSizeLimit.length > 0) {
+					warnings.push(
+						new AssetsOverSizeLimitWarning(
+							assetsOverSizeLimit,
+							assetSizeLimit));
+				}
+				if(entrypointsOverLimit.length > 0) {
+					warnings.push(
+						new EntrypointsOverSizeLimitWarning(
+							entrypointsOverLimit,
+							entrypointSizeLimit));
+				}
+
+				if(warnings.length > 0) {
+					const hasAsyncChunks = compilation.chunks.filter(chunk => !chunk.isInitial()).length > 0;
+
+					if(!hasAsyncChunks) {
+						warnings.push(new NoAsyncChunksWarning());
+					}
+
+					if(hints === "error") {
+						Array.prototype.push.apply(compilation.errors, warnings);
+					} else {
+						Array.prototype.push.apply(compilation.warnings, warnings);
+					}
+				}
+			}
+
+			callback();
+		});
+	}
+};