0.2.0 - Mid migration

web/node_modules/webpack/lib/performance/AssetsOverSizeLimitWarning.js

@@ -0,0 +1,30 @@
+/*
+	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) {
+		const assetLists = assetsOverSizeLimit
+			.map(
+				asset =>
+					`\n  ${asset.name} (${SizeFormatHelpers.formatSize(asset.size)})`
+			)
+			.join("");
+
+		super(`asset size limit: The following asset(s) exceed the recommended size limit (${SizeFormatHelpers.formatSize(
+			assetLimit
+		)}).
+This can impact web performance.
+Assets: ${assetLists}`);
+
+		this.name = "AssetsOverSizeLimitWarning";
+		this.assets = assetsOverSizeLimit;
+
+		Error.captureStackTrace(this, this.constructor);
+	}
+};

web/node_modules/webpack/lib/performance/EntrypointsOverSizeLimitWarning.js

@@ -0,0 +1,30 @@
+/*
+	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) {
+		const entrypointList = entrypoints
+			.map(
+				entrypoint =>
+					`\n  ${entrypoint.name} (${SizeFormatHelpers.formatSize(
+						entrypoint.size
+					)})\n${entrypoint.files.map(asset => `      ${asset}`).join("\n")}`
+			)
+			.join("");
+		super(`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`);
+
+		this.name = "EntrypointsOverSizeLimitWarning";
+		this.entrypoints = entrypoints;
+
+		Error.captureStackTrace(this, this.constructor);
+	}
+};

web/node_modules/webpack/lib/performance/NoAsyncChunksWarning.js

@@ -0,0 +1,21 @@
+/*
+	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(
+			"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/"
+		);
+
+		this.name = "NoAsyncChunksWarning";
+
+		Error.captureStackTrace(this, this.constructor);
+	}
+};

web/node_modules/webpack/lib/performance/SizeLimitsPlugin.js

@@ -0,0 +1,125 @@
+/*
+	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");
+
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Entrypoint")} Entrypoint */
+
+module.exports = class SizeLimitsPlugin {
+	constructor(options) {
+		this.hints = options.hints;
+		this.maxAssetSize = options.maxAssetSize;
+		this.maxEntrypointSize = options.maxEntrypointSize;
+		this.assetFilter = options.assetFilter;
+	}
+
+	/**
+	 * @param {Compiler} compiler webpack compiler
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		const entrypointSizeLimit = this.maxEntrypointSize;
+		const assetSizeLimit = this.maxAssetSize;
+		const hints = this.hints;
+		const assetFilter =
+			this.assetFilter || ((name, source, info) => !info.development);
+
+		compiler.hooks.afterEmit.tap("SizeLimitsPlugin", compilation => {
+			const warnings = [];
+
+			/**
+			 * @param {Entrypoint} entrypoint an entrypoint
+			 * @returns {number} the size of the entrypoint
+			 */
+			const getEntrypointSize = entrypoint =>
+				entrypoint.getFiles().reduce((currentSize, file) => {
+					const asset = compilation.getAsset(file);
+					if (
+						asset &&
+						assetFilter(asset.name, asset.source, asset.info) &&
+						asset.source
+					) {
+						return currentSize + (asset.info.size || asset.source.size());
+					}
+
+					return currentSize;
+				}, 0);
+
+			const assetsOverSizeLimit = [];
+			for (const { name, source, info } of compilation.getAssets()) {
+				if (!assetFilter(name, source, info) || !source) {
+					continue;
+				}
+
+				const size = info.size || source.size();
+				if (size > assetSizeLimit) {
+					assetsOverSizeLimit.push({
+						name,
+						size
+					});
+					/** @type {any} */ (source).isOverSizeLimit = true;
+				}
+			}
+
+			const fileFilter = name => {
+				const asset = compilation.getAsset(name);
+				return asset && assetFilter(asset.name, asset.source, asset.info);
+			};
+
+			const entrypointsOverLimit = [];
+			for (const [name, entry] of compilation.entrypoints) {
+				const size = getEntrypointSize(entry);
+
+				if (size > entrypointSizeLimit) {
+					entrypointsOverLimit.push({
+						name: name,
+						size: size,
+						files: entry.getFiles().filter(fileFilter)
+					});
+					/** @type {any} */ (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.canBeInitial()).length >
+						0;
+
+					if (!hasAsyncChunks) {
+						warnings.push(new NoAsyncChunksWarning());
+					}
+
+					if (hints === "error") {
+						compilation.errors.push(...warnings);
+					} else {
+						compilation.warnings.push(...warnings);
+					}
+				}
+			}
+		});
+	}
+};