@eriche/webpack 4.47.0

package/lib/dependencies/HarmonyImportDependency.js

@@ -0,0 +1,109 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const DependencyReference = require("./DependencyReference");
+const ModuleDependency = require("./ModuleDependency");
+const Template = require("../Template");
+
+class HarmonyImportDependency extends ModuleDependency {
+	constructor(request, originModule, sourceOrder, parserScope) {
+		super(request);
+		this.redirectedModule = undefined;
+		this.originModule = originModule;
+		this.sourceOrder = sourceOrder;
+		this.parserScope = parserScope;
+	}
+
+	get _module() {
+		return this.redirectedModule || this.module;
+	}
+
+	getReference() {
+		if (!this._module) return null;
+		return new DependencyReference(
+			this._module,
+			false,
+			this.weak,
+			this.sourceOrder
+		);
+	}
+
+	getImportVar() {
+		let importVarMap = this.parserScope.importVarMap;
+		if (!importVarMap) this.parserScope.importVarMap = importVarMap = new Map();
+		let importVar = importVarMap.get(this._module);
+		if (importVar) return importVar;
+		importVar = `${Template.toIdentifier(
+			`${this.userRequest}`
+		)}__WEBPACK_IMPORTED_MODULE_${importVarMap.size}__`;
+		importVarMap.set(this._module, importVar);
+		return importVar;
+	}
+
+	getImportStatement(update, runtime) {
+		return runtime.importStatement({
+			update,
+			module: this._module,
+			importVar: this.getImportVar(),
+			request: this.request,
+			originModule: this.originModule
+		});
+	}
+
+	updateHash(hash) {
+		super.updateHash(hash);
+		const importedModule = this._module;
+		hash.update(
+			(importedModule &&
+				(!importedModule.buildMeta || importedModule.buildMeta.exportsType)) +
+				""
+		);
+		hash.update((importedModule && importedModule.id) + "");
+	}
+
+	disconnect() {
+		super.disconnect();
+		this.redirectedModule = undefined;
+	}
+}
+
+module.exports = HarmonyImportDependency;
+
+const importEmittedMap = new WeakMap();
+
+HarmonyImportDependency.Template = class HarmonyImportDependencyTemplate {
+	apply(dep, source, runtime) {
+		// no-op
+	}
+
+	getHarmonyInitOrder(dep) {
+		return dep.sourceOrder;
+	}
+
+	static isImportEmitted(dep, source) {
+		let sourceInfo = importEmittedMap.get(source);
+		if (!sourceInfo) return false;
+		const key = dep._module || dep.request;
+		return key && sourceInfo.emittedImports.get(key);
+	}
+
+	harmonyInit(dep, source, runtime, dependencyTemplates) {
+		let sourceInfo = importEmittedMap.get(source);
+		if (!sourceInfo) {
+			importEmittedMap.set(
+				source,
+				(sourceInfo = {
+					emittedImports: new Map()
+				})
+			);
+		}
+		const key = dep._module || dep.request;
+		if (key && sourceInfo.emittedImports.get(key)) return;
+		sourceInfo.emittedImports.set(key, true);
+		const content = dep.getImportStatement(false, runtime);
+		source.insert(-1, content);
+	}
+};

package/lib/dependencies/HarmonyImportDependencyParserPlugin.js

@@ -0,0 +1,222 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const { SyncBailHook } = require("tapable");
+const HarmonyImportSideEffectDependency = require("./HarmonyImportSideEffectDependency");
+const HarmonyImportSpecifierDependency = require("./HarmonyImportSpecifierDependency");
+const HarmonyAcceptImportDependency = require("./HarmonyAcceptImportDependency");
+const HarmonyAcceptDependency = require("./HarmonyAcceptDependency");
+const ConstDependency = require("./ConstDependency");
+
+module.exports = class HarmonyImportDependencyParserPlugin {
+	constructor(moduleOptions) {
+		this.strictExportPresence = moduleOptions.strictExportPresence;
+		this.strictThisContextOnImports = moduleOptions.strictThisContextOnImports;
+	}
+
+	apply(parser) {
+		parser.hooks.import.tap(
+			"HarmonyImportDependencyParserPlugin",
+			(statement, source) => {
+				parser.state.lastHarmonyImportOrder =
+					(parser.state.lastHarmonyImportOrder || 0) + 1;
+				const clearDep = new ConstDependency("", statement.range);
+				clearDep.loc = statement.loc;
+				parser.state.module.addDependency(clearDep);
+				const sideEffectDep = new HarmonyImportSideEffectDependency(
+					source,
+					parser.state.module,
+					parser.state.lastHarmonyImportOrder,
+					parser.state.harmonyParserScope
+				);
+				sideEffectDep.loc = statement.loc;
+				parser.state.module.addDependency(sideEffectDep);
+				return true;
+			}
+		);
+		parser.hooks.importSpecifier.tap(
+			"HarmonyImportDependencyParserPlugin",
+			(statement, source, id, name) => {
+				parser.scope.definitions.delete(name);
+				parser.scope.renames.set(name, "imported var");
+				if (!parser.state.harmonySpecifier) {
+					parser.state.harmonySpecifier = new Map();
+				}
+				parser.state.harmonySpecifier.set(name, {
+					source,
+					id,
+					sourceOrder: parser.state.lastHarmonyImportOrder
+				});
+				return true;
+			}
+		);
+		parser.hooks.expression
+			.for("imported var")
+			.tap("HarmonyImportDependencyParserPlugin", expr => {
+				const name = expr.name;
+				const settings = parser.state.harmonySpecifier.get(name);
+				const dep = new HarmonyImportSpecifierDependency(
+					settings.source,
+					parser.state.module,
+					settings.sourceOrder,
+					parser.state.harmonyParserScope,
+					settings.id,
+					name,
+					expr.range,
+					this.strictExportPresence
+				);
+				dep.shorthand = parser.scope.inShorthand;
+				dep.directImport = true;
+				dep.loc = expr.loc;
+				parser.state.module.addDependency(dep);
+				return true;
+			});
+		parser.hooks.expressionAnyMember
+			.for("imported var")
+			.tap("HarmonyImportDependencyParserPlugin", expr => {
+				const name = expr.object.name;
+				const settings = parser.state.harmonySpecifier.get(name);
+				if (settings.id !== null) return false;
+				const dep = new HarmonyImportSpecifierDependency(
+					settings.source,
+					parser.state.module,
+					settings.sourceOrder,
+					parser.state.harmonyParserScope,
+					expr.property.name || expr.property.value,
+					name,
+					expr.range,
+					this.strictExportPresence
+				);
+				dep.shorthand = parser.scope.inShorthand;
+				dep.directImport = false;
+				dep.loc = expr.loc;
+				parser.state.module.addDependency(dep);
+				return true;
+			});
+		if (this.strictThisContextOnImports) {
+			// only in case when we strictly follow the spec we need a special case here
+			parser.hooks.callAnyMember
+				.for("imported var")
+				.tap("HarmonyImportDependencyParserPlugin", expr => {
+					if (expr.callee.type !== "MemberExpression") return;
+					if (expr.callee.object.type !== "Identifier") return;
+					const name = expr.callee.object.name;
+					const settings = parser.state.harmonySpecifier.get(name);
+					if (settings.id !== null) return false;
+					const dep = new HarmonyImportSpecifierDependency(
+						settings.source,
+						parser.state.module,
+						settings.sourceOrder,
+						parser.state.harmonyParserScope,
+						expr.callee.property.name || expr.callee.property.value,
+						name,
+						expr.callee.range,
+						this.strictExportPresence
+					);
+					dep.shorthand = parser.scope.inShorthand;
+					dep.directImport = false;
+					dep.namespaceObjectAsContext = true;
+					dep.loc = expr.callee.loc;
+					parser.state.module.addDependency(dep);
+					if (expr.arguments) parser.walkExpressions(expr.arguments);
+					return true;
+				});
+		}
+		parser.hooks.call
+			.for("imported var")
+			.tap("HarmonyImportDependencyParserPlugin", expr => {
+				const args = expr.arguments;
+				const fullExpr = expr;
+				expr = expr.callee;
+				if (expr.type !== "Identifier") return;
+				const name = expr.name;
+				const settings = parser.state.harmonySpecifier.get(name);
+				const dep = new HarmonyImportSpecifierDependency(
+					settings.source,
+					parser.state.module,
+					settings.sourceOrder,
+					parser.state.harmonyParserScope,
+					settings.id,
+					name,
+					expr.range,
+					this.strictExportPresence
+				);
+				dep.directImport = true;
+				dep.callArgs = args;
+				dep.call = fullExpr;
+				dep.loc = expr.loc;
+				parser.state.module.addDependency(dep);
+				if (args) parser.walkExpressions(args);
+				return true;
+			});
+		// TODO webpack 5: refactor this, no custom hooks
+		if (!parser.hooks.hotAcceptCallback) {
+			parser.hooks.hotAcceptCallback = new SyncBailHook([
+				"expression",
+				"requests"
+			]);
+		}
+		if (!parser.hooks.hotAcceptWithoutCallback) {
+			parser.hooks.hotAcceptWithoutCallback = new SyncBailHook([
+				"expression",
+				"requests"
+			]);
+		}
+		parser.hooks.hotAcceptCallback.tap(
+			"HarmonyImportDependencyParserPlugin",
+			(expr, requests) => {
+				const harmonyParserScope = parser.state.harmonyParserScope;
+				if (!harmonyParserScope) {
+					// This is not a harmony module, skip it
+					return;
+				}
+				const dependencies = requests.map(request => {
+					const dep = new HarmonyAcceptImportDependency(
+						request,
+						parser.state.module,
+						harmonyParserScope
+					);
+					dep.loc = expr.loc;
+					parser.state.module.addDependency(dep);
+					return dep;
+				});
+				if (dependencies.length > 0) {
+					const dep = new HarmonyAcceptDependency(
+						expr.range,
+						dependencies,
+						true
+					);
+					dep.loc = expr.loc;
+					parser.state.module.addDependency(dep);
+				}
+			}
+		);
+		parser.hooks.hotAcceptWithoutCallback.tap(
+			"HarmonyImportDependencyParserPlugin",
+			(expr, requests) => {
+				const dependencies = requests.map(request => {
+					const dep = new HarmonyAcceptImportDependency(
+						request,
+						parser.state.module,
+						parser.state.harmonyParserScope
+					);
+					dep.loc = expr.loc;
+					parser.state.module.addDependency(dep);
+					return dep;
+				});
+				if (dependencies.length > 0) {
+					const dep = new HarmonyAcceptDependency(
+						expr.range,
+						dependencies,
+						false
+					);
+					dep.loc = expr.loc;
+					parser.state.module.addDependency(dep);
+				}
+			}
+		);
+	}
+};

package/lib/dependencies/HarmonyImportSideEffectDependency.js

@@ -0,0 +1,31 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+const HarmonyImportDependency = require("./HarmonyImportDependency");
+
+class HarmonyImportSideEffectDependency extends HarmonyImportDependency {
+	constructor(request, originModule, sourceOrder, parserScope) {
+		super(request, originModule, sourceOrder, parserScope);
+	}
+
+	getReference() {
+		if (this._module && this._module.factoryMeta.sideEffectFree) return null;
+
+		return super.getReference();
+	}
+
+	get type() {
+		return "harmony side effect evaluation";
+	}
+}
+
+HarmonyImportSideEffectDependency.Template = class HarmonyImportSideEffectDependencyTemplate extends HarmonyImportDependency.Template {
+	getHarmonyInitOrder(dep) {
+		if (dep._module && dep._module.factoryMeta.sideEffectFree) return NaN;
+		return super.getHarmonyInitOrder(dep);
+	}
+};
+
+module.exports = HarmonyImportSideEffectDependency;

package/lib/dependencies/HarmonyImportSpecifierDependency.js

@@ -0,0 +1,163 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const DependencyReference = require("./DependencyReference");
+const HarmonyImportDependency = require("./HarmonyImportDependency");
+const HarmonyLinkingError = require("../HarmonyLinkingError");
+
+class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
+	constructor(
+		request,
+		originModule,
+		sourceOrder,
+		parserScope,
+		id,
+		name,
+		range,
+		strictExportPresence
+	) {
+		super(request, originModule, sourceOrder, parserScope);
+		this.id = id === null ? null : `${id}`;
+		this.redirectedId = undefined;
+		this.name = name;
+		this.range = range;
+		this.strictExportPresence = strictExportPresence;
+		this.namespaceObjectAsContext = false;
+		this.callArgs = undefined;
+		this.call = undefined;
+		this.directImport = undefined;
+		this.shorthand = undefined;
+	}
+
+	get type() {
+		return "harmony import specifier";
+	}
+
+	get _id() {
+		return this.redirectedId || this.id;
+	}
+
+	getReference() {
+		if (!this._module) return null;
+		return new DependencyReference(
+			this._module,
+			this._id && !this.namespaceObjectAsContext ? [this._id] : true,
+			false,
+			this.sourceOrder
+		);
+	}
+
+	getWarnings() {
+		if (
+			this.strictExportPresence ||
+			this.originModule.buildMeta.strictHarmonyModule
+		) {
+			return [];
+		}
+		return this._getErrors();
+	}
+
+	getErrors() {
+		if (
+			this.strictExportPresence ||
+			this.originModule.buildMeta.strictHarmonyModule
+		) {
+			return this._getErrors();
+		}
+		return [];
+	}
+
+	_getErrors() {
+		const importedModule = this._module;
+		if (!importedModule) {
+			return;
+		}
+
+		if (!importedModule.buildMeta || !importedModule.buildMeta.exportsType) {
+			// It's not an harmony module
+			if (
+				this.originModule.buildMeta.strictHarmonyModule &&
+				this._id &&
+				this._id !== "default"
+			) {
+				// In strict harmony modules we only support the default export
+				return [
+					new HarmonyLinkingError(
+						`Can't import the named export '${this._id}' from non EcmaScript module (only default export is available)`
+					)
+				];
+			}
+			return;
+		}
+
+		if (!this._id) {
+			return;
+		}
+
+		if (importedModule.isProvided(this._id) !== false) {
+			// It's provided or we are not sure
+			return;
+		}
+
+		// We are sure that it's not provided
+		const idIsNotNameMessage =
+			this._id !== this.name ? ` (imported as '${this.name}')` : "";
+		const errorMessage = `"export '${this._id}'${idIsNotNameMessage} was not found in '${this.userRequest}'`;
+		return [new HarmonyLinkingError(errorMessage)];
+	}
+
+	// implement this method to allow the occurrence order plugin to count correctly
+	getNumberOfIdOccurrences() {
+		return 0;
+	}
+
+	updateHash(hash) {
+		super.updateHash(hash);
+		const importedModule = this._module;
+		hash.update((importedModule && this._id) + "");
+		hash.update(
+			(importedModule && this._id && importedModule.isUsed(this._id)) + ""
+		);
+		hash.update(
+			(importedModule &&
+				(!importedModule.buildMeta || importedModule.buildMeta.exportsType)) +
+				""
+		);
+		hash.update(
+			(importedModule &&
+				importedModule.used + JSON.stringify(importedModule.usedExports)) + ""
+		);
+	}
+
+	disconnect() {
+		super.disconnect();
+		this.redirectedId = undefined;
+	}
+}
+
+HarmonyImportSpecifierDependency.Template = class HarmonyImportSpecifierDependencyTemplate extends HarmonyImportDependency.Template {
+	apply(dep, source, runtime) {
+		super.apply(dep, source, runtime);
+		const content = this.getContent(dep, runtime);
+		source.replace(dep.range[0], dep.range[1] - 1, content);
+	}
+
+	getContent(dep, runtime) {
+		const exportExpr = runtime.exportFromImport({
+			module: dep._module,
+			request: dep.request,
+			exportName: dep._id,
+			originModule: dep.originModule,
+			asiSafe: dep.shorthand,
+			isCall: dep.call,
+			callContext: !dep.directImport,
+			importVar: dep.getImportVar()
+		});
+		return dep.shorthand ? `${dep.name}: ${exportExpr}` : exportExpr;
+	}
+};
+
+module.exports = HarmonyImportSpecifierDependency;

package/lib/dependencies/HarmonyInitDependency.js

@@ -0,0 +1,60 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const NullDependency = require("./NullDependency");
+
+class HarmonyInitDependency extends NullDependency {
+	constructor(originModule) {
+		super();
+		this.originModule = originModule;
+	}
+
+	get type() {
+		return "harmony init";
+	}
+}
+
+module.exports = HarmonyInitDependency;
+
+HarmonyInitDependency.Template = class HarmonyInitDependencyTemplate {
+	apply(dep, source, runtime, dependencyTemplates) {
+		const module = dep.originModule;
+		const list = [];
+		for (const dependency of module.dependencies) {
+			const template = dependencyTemplates.get(dependency.constructor);
+			if (
+				template &&
+				typeof template.harmonyInit === "function" &&
+				typeof template.getHarmonyInitOrder === "function"
+			) {
+				const order = template.getHarmonyInitOrder(dependency);
+				if (!isNaN(order)) {
+					list.push({
+						order,
+						listOrder: list.length,
+						dependency,
+						template
+					});
+				}
+			}
+		}
+
+		list.sort((a, b) => {
+			const x = a.order - b.order;
+			if (x) return x;
+			return a.listOrder - b.listOrder;
+		});
+
+		for (const item of list) {
+			item.template.harmonyInit(
+				item.dependency,
+				source,
+				runtime,
+				dependencyTemplates
+			);
+		}
+	}
+};