First commit

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

@@ -0,0 +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);
+	}
+};

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

@@ -0,0 +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);
+	}
+};

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

@@ -0,0 +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);
+	}
+};

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

@@ -0,0 +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();
+		});
+	}
+};