@eriche/webpack 4.47.0

package/lib/ModuleFilenameHelpers.js

@@ -0,0 +1,179 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const createHash = require("./util/createHash");
+
+const ModuleFilenameHelpers = exports;
+
+ModuleFilenameHelpers.ALL_LOADERS_RESOURCE = "[all-loaders][resource]";
+ModuleFilenameHelpers.REGEXP_ALL_LOADERS_RESOURCE = /\[all-?loaders\]\[resource\]/gi;
+ModuleFilenameHelpers.LOADERS_RESOURCE = "[loaders][resource]";
+ModuleFilenameHelpers.REGEXP_LOADERS_RESOURCE = /\[loaders\]\[resource\]/gi;
+ModuleFilenameHelpers.RESOURCE = "[resource]";
+ModuleFilenameHelpers.REGEXP_RESOURCE = /\[resource\]/gi;
+ModuleFilenameHelpers.ABSOLUTE_RESOURCE_PATH = "[absolute-resource-path]";
+ModuleFilenameHelpers.REGEXP_ABSOLUTE_RESOURCE_PATH = /\[abs(olute)?-?resource-?path\]/gi;
+ModuleFilenameHelpers.RESOURCE_PATH = "[resource-path]";
+ModuleFilenameHelpers.REGEXP_RESOURCE_PATH = /\[resource-?path\]/gi;
+ModuleFilenameHelpers.ALL_LOADERS = "[all-loaders]";
+ModuleFilenameHelpers.REGEXP_ALL_LOADERS = /\[all-?loaders\]/gi;
+ModuleFilenameHelpers.LOADERS = "[loaders]";
+ModuleFilenameHelpers.REGEXP_LOADERS = /\[loaders\]/gi;
+ModuleFilenameHelpers.QUERY = "[query]";
+ModuleFilenameHelpers.REGEXP_QUERY = /\[query\]/gi;
+ModuleFilenameHelpers.ID = "[id]";
+ModuleFilenameHelpers.REGEXP_ID = /\[id\]/gi;
+ModuleFilenameHelpers.HASH = "[hash]";
+ModuleFilenameHelpers.REGEXP_HASH = /\[hash\]/gi;
+ModuleFilenameHelpers.NAMESPACE = "[namespace]";
+ModuleFilenameHelpers.REGEXP_NAMESPACE = /\[namespace\]/gi;
+
+const getAfter = (str, token) => {
+	const idx = str.indexOf(token);
+	return idx < 0 ? "" : str.substr(idx);
+};
+
+const getBefore = (str, token) => {
+	const idx = str.lastIndexOf(token);
+	return idx < 0 ? "" : str.substr(0, idx);
+};
+
+const getHash = str => {
+	const hash = createHash("md4");
+	hash.update(str);
+	const digest = /** @type {string} */ (hash.digest("hex"));
+	return digest.substr(0, 4);
+};
+
+const asRegExp = test => {
+	if (typeof test === "string") {
+		test = new RegExp("^" + test.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&"));
+	}
+	return test;
+};
+
+ModuleFilenameHelpers.createFilename = (module, options, requestShortener) => {
+	const opts = Object.assign(
+		{
+			namespace: "",
+			moduleFilenameTemplate: ""
+		},
+		typeof options === "object"
+			? options
+			: {
+					moduleFilenameTemplate: options
+			  }
+	);
+
+	let absoluteResourcePath;
+	let hash;
+	let identifier;
+	let moduleId;
+	let shortIdentifier;
+	if (module === undefined) module = "";
+	if (typeof module === "string") {
+		shortIdentifier = requestShortener.shorten(module);
+		identifier = shortIdentifier;
+		moduleId = "";
+		absoluteResourcePath = module.split("!").pop();
+		hash = getHash(identifier);
+	} else {
+		shortIdentifier = module.readableIdentifier(requestShortener);
+		identifier = requestShortener.shorten(module.identifier());
+		moduleId = module.id;
+		absoluteResourcePath = module
+			.identifier()
+			.split("!")
+			.pop();
+		hash = getHash(identifier);
+	}
+	const resource = shortIdentifier.split("!").pop();
+	const loaders = getBefore(shortIdentifier, "!");
+	const allLoaders = getBefore(identifier, "!");
+	const query = getAfter(resource, "?");
+	const resourcePath = resource.substr(0, resource.length - query.length);
+	if (typeof opts.moduleFilenameTemplate === "function") {
+		return opts.moduleFilenameTemplate({
+			identifier: identifier,
+			shortIdentifier: shortIdentifier,
+			resource: resource,
+			resourcePath: resourcePath,
+			absoluteResourcePath: absoluteResourcePath,
+			allLoaders: allLoaders,
+			query: query,
+			moduleId: moduleId,
+			hash: hash,
+			namespace: opts.namespace
+		});
+	}
+	return opts.moduleFilenameTemplate
+		.replace(ModuleFilenameHelpers.REGEXP_ALL_LOADERS_RESOURCE, identifier)
+		.replace(ModuleFilenameHelpers.REGEXP_LOADERS_RESOURCE, shortIdentifier)
+		.replace(ModuleFilenameHelpers.REGEXP_RESOURCE, resource)
+		.replace(ModuleFilenameHelpers.REGEXP_RESOURCE_PATH, resourcePath)
+		.replace(
+			ModuleFilenameHelpers.REGEXP_ABSOLUTE_RESOURCE_PATH,
+			absoluteResourcePath
+		)
+		.replace(ModuleFilenameHelpers.REGEXP_ALL_LOADERS, allLoaders)
+		.replace(ModuleFilenameHelpers.REGEXP_LOADERS, loaders)
+		.replace(ModuleFilenameHelpers.REGEXP_QUERY, query)
+		.replace(ModuleFilenameHelpers.REGEXP_ID, moduleId)
+		.replace(ModuleFilenameHelpers.REGEXP_HASH, hash)
+		.replace(ModuleFilenameHelpers.REGEXP_NAMESPACE, opts.namespace);
+};
+
+ModuleFilenameHelpers.replaceDuplicates = (array, fn, comparator) => {
+	const countMap = Object.create(null);
+	const posMap = Object.create(null);
+	array.forEach((item, idx) => {
+		countMap[item] = countMap[item] || [];
+		countMap[item].push(idx);
+		posMap[item] = 0;
+	});
+	if (comparator) {
+		Object.keys(countMap).forEach(item => {
+			countMap[item].sort(comparator);
+		});
+	}
+	return array.map((item, i) => {
+		if (countMap[item].length > 1) {
+			if (comparator && countMap[item][0] === i) return item;
+			return fn(item, i, posMap[item]++);
+		} else {
+			return item;
+		}
+	});
+};
+
+ModuleFilenameHelpers.matchPart = (str, test) => {
+	if (!test) return true;
+	test = asRegExp(test);
+	if (Array.isArray(test)) {
+		return test.map(asRegExp).some(regExp => regExp.test(str));
+	} else {
+		return test.test(str);
+	}
+};
+
+ModuleFilenameHelpers.matchObject = (obj, str) => {
+	if (obj.test) {
+		if (!ModuleFilenameHelpers.matchPart(str, obj.test)) {
+			return false;
+		}
+	}
+	if (obj.include) {
+		if (!ModuleFilenameHelpers.matchPart(str, obj.include)) {
+			return false;
+		}
+	}
+	if (obj.exclude) {
+		if (ModuleFilenameHelpers.matchPart(str, obj.exclude)) {
+			return false;
+		}
+	}
+	return true;
+};

package/lib/ModuleNotFoundError.js

@@ -0,0 +1,23 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const WebpackError = require("./WebpackError");
+
+class ModuleNotFoundError extends WebpackError {
+	constructor(module, err) {
+		super("Module not found: " + err);
+
+		this.name = "ModuleNotFoundError";
+		this.details = err.details;
+		this.missing = err.missing;
+		this.module = module;
+		this.error = err;
+
+		Error.captureStackTrace(this, this.constructor);
+	}
+}
+
+module.exports = ModuleNotFoundError;

package/lib/ModuleParseError.js

@@ -0,0 +1,67 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const WebpackError = require("./WebpackError");
+
+/** @typedef {import("./Module")} Module */
+
+class ModuleParseError extends WebpackError {
+	/**
+	 * @param {Module} module the errored module
+	 * @param {string} source source code
+	 * @param {Error&any} err the parse error
+	 * @param {string[]} loaders the loaders used
+	 */
+	constructor(module, source, err, loaders) {
+		let message = "Module parse failed: " + err.message;
+		let loc = undefined;
+		if (loaders.length >= 1) {
+			message += `\nFile was processed with these loaders:${loaders
+				.map(loader => `\n * ${loader}`)
+				.join("")}`;
+			message +=
+				"\nYou may need an additional loader to handle the result of these loaders.";
+		} else {
+			message +=
+				"\nYou may need an appropriate loader to handle this file type, currently no loaders are configured to process this file. See https://webpack.js.org/concepts#loaders";
+		}
+		if (
+			err.loc &&
+			typeof err.loc === "object" &&
+			typeof err.loc.line === "number"
+		) {
+			var lineNumber = err.loc.line;
+			if (/[\0\u0001\u0002\u0003\u0004\u0005\u0006\u0007]/.test(source)) {
+				// binary file
+				message += "\n(Source code omitted for this binary file)";
+			} else {
+				const sourceLines = source.split(/\r?\n/);
+				const start = Math.max(0, lineNumber - 3);
+				const linesBefore = sourceLines.slice(start, lineNumber - 1);
+				const theLine = sourceLines[lineNumber - 1];
+				const linesAfter = sourceLines.slice(lineNumber, lineNumber + 2);
+				message +=
+					linesBefore.map(l => `\n| ${l}`).join("") +
+					`\n> ${theLine}` +
+					linesAfter.map(l => `\n| ${l}`).join("");
+			}
+			loc = err.loc;
+		} else {
+			message += "\n" + err.stack;
+		}
+
+		super(message);
+
+		this.name = "ModuleParseError";
+		this.module = module;
+		this.loc = loc;
+		this.error = err;
+
+		Error.captureStackTrace(this, this.constructor);
+	}
+}
+
+module.exports = ModuleParseError;

package/lib/ModuleReason.js

@@ -0,0 +1,48 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+/** @typedef {import("./Module")} Module */
+/** @typedef {import("./Dependency")} Dependency */
+
+class ModuleReason {
+	/**
+	 * @param {Module} module the referencing module
+	 * @param {Dependency} dependency the referencing dependency
+	 * @param {string=} explanation some extra detail
+	 */
+	constructor(module, dependency, explanation) {
+		this.module = module;
+		this.dependency = dependency;
+		this.explanation = explanation;
+		this._chunks = null;
+	}
+
+	hasChunk(chunk) {
+		if (this._chunks) {
+			if (this._chunks.has(chunk)) return true;
+		} else if (this.module && this.module._chunks.has(chunk)) return true;
+		return false;
+	}
+
+	rewriteChunks(oldChunk, newChunks) {
+		if (!this._chunks) {
+			if (this.module) {
+				if (!this.module._chunks.has(oldChunk)) return;
+				this._chunks = new Set(this.module._chunks);
+			} else {
+				this._chunks = new Set();
+			}
+		}
+		if (this._chunks.has(oldChunk)) {
+			this._chunks.delete(oldChunk);
+			for (let i = 0; i < newChunks.length; i++) {
+				this._chunks.add(newChunks[i]);
+			}
+		}
+	}
+}
+
+module.exports = ModuleReason;

package/lib/ModuleTemplate.js

@@ -0,0 +1,93 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const { Tapable, SyncWaterfallHook, SyncHook } = require("tapable");
+
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("./Module")} Module */
+
+module.exports = class ModuleTemplate extends Tapable {
+	constructor(runtimeTemplate, type) {
+		super();
+		this.runtimeTemplate = runtimeTemplate;
+		this.type = type;
+		this.hooks = {
+			content: new SyncWaterfallHook([
+				"source",
+				"module",
+				"options",
+				"dependencyTemplates"
+			]),
+			module: new SyncWaterfallHook([
+				"source",
+				"module",
+				"options",
+				"dependencyTemplates"
+			]),
+			render: new SyncWaterfallHook([
+				"source",
+				"module",
+				"options",
+				"dependencyTemplates"
+			]),
+			package: new SyncWaterfallHook([
+				"source",
+				"module",
+				"options",
+				"dependencyTemplates"
+			]),
+			hash: new SyncHook(["hash"])
+		};
+	}
+
+	/**
+	 * @param {Module} module the module
+	 * @param {TODO} dependencyTemplates templates for dependencies
+	 * @param {TODO} options render options
+	 * @returns {Source} the source
+	 */
+	render(module, dependencyTemplates, options) {
+		try {
+			const moduleSource = module.source(
+				dependencyTemplates,
+				this.runtimeTemplate,
+				this.type
+			);
+			const moduleSourcePostContent = this.hooks.content.call(
+				moduleSource,
+				module,
+				options,
+				dependencyTemplates
+			);
+			const moduleSourcePostModule = this.hooks.module.call(
+				moduleSourcePostContent,
+				module,
+				options,
+				dependencyTemplates
+			);
+			const moduleSourcePostRender = this.hooks.render.call(
+				moduleSourcePostModule,
+				module,
+				options,
+				dependencyTemplates
+			);
+			return this.hooks.package.call(
+				moduleSourcePostRender,
+				module,
+				options,
+				dependencyTemplates
+			);
+		} catch (e) {
+			e.message = `${module.identifier()}\n${e.message}`;
+			throw e;
+		}
+	}
+
+	updateHash(hash) {
+		hash.update("1");
+		this.hooks.hash.call(hash);
+	}
+};

package/lib/ModuleWarning.js

@@ -0,0 +1,36 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const WebpackError = require("./WebpackError");
+const { cleanUp } = require("./ErrorHelpers");
+
+class ModuleWarning extends WebpackError {
+	constructor(module, warning, { from = null } = {}) {
+		let message = "Module Warning";
+		if (from) {
+			message += ` (from ${from}):\n`;
+		} else {
+			message += ": ";
+		}
+		if (warning && typeof warning === "object" && warning.message) {
+			message += warning.message;
+		} else if (warning) {
+			message += warning;
+		}
+		super(message);
+		this.name = "ModuleWarning";
+		this.module = module;
+		this.warning = warning;
+		this.details =
+			warning && typeof warning === "object" && warning.stack
+				? cleanUp(warning.stack, this.message)
+				: undefined;
+
+		Error.captureStackTrace(this, this.constructor);
+	}
+}
+
+module.exports = ModuleWarning;