fix: use memorize util instead of lazyRequire

lib/asset/AssetModulesPlugin.js

@@ -5,6 +5,7 @@
 
 "use strict";
 
+const memorize = require("../util/memorize");
 const validateOptions = require("schema-utils");
 const { compareModulesByIdentifier } = require("../util/comparators");
 
@@ -13,21 +14,17 @@ const { compareModulesByIdentifier } = require("../util/comparators");
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Module")} Module */
 
-const lazyRequire = require("../util/lazyRequire")(require);
+const getGeneratorSchema = memorize(() =>
-const generatorSchema = lazyRequire(
+	require("../../schemas/plugins/AssetModulesPluginGenerator.json")
-	"../../schemas/plugins/AssetModulesPluginGenerator.json",
-	false
 );
-const parserSchema = lazyRequire(
+const getParserSchema = memorize(() =>
-	"../../schemas/plugins/AssetModulesPluginParser.json",
+	require("../../schemas/plugins/AssetModulesPluginParser.json")
-	false
+);
+const getAssetGenerator = memorize(() => require("./AssetGenerator"));
+const getAssetParser = memorize(() => require("./AssetParser"));
+const getAssetSourceGenerator = memorize(() =>
+	require("./AssetSourceGenerator")
 );
-/** @type {typeof import('./AssetGenerator')} */
-const AssetGenerator = lazyRequire("./AssetGenerator");
-/** @type {typeof import('./AssetParser')} */
-const AssetParser = lazyRequire("./AssetParser");
-/** @type {typeof import('./AssetSourceGenerator')} */
-const AssetSourceGenerator = lazyRequire("./AssetSourceGenerator");
 
 const type = "asset";
 const plugin = "AssetModulesPlugin";
@@ -44,7 +41,7 @@ class AssetModulesPlugin {
 				normalModuleFactory.hooks.createParser
 					.for("asset")
 					.tap(plugin, parserOptions => {
-						validateOptions(parserSchema, parserOptions, {
+						validateOptions(getParserSchema(), parserOptions, {
 							name: "Asset Modules Plugin",
 							baseDataPath: "parser"
 						});
@@ -57,24 +54,38 @@ class AssetModulesPlugin {
 							};
 						}
 
+						const AssetParser = getAssetParser();
+
 						return new AssetParser(dataUrlCondition);
 					});
 				normalModuleFactory.hooks.createParser
 					.for("asset/inline")
-					.tap(plugin, parserOptions => new AssetParser(true));
+					.tap(plugin, parserOptions => {
+						const AssetParser = getAssetParser();
+
+						return new AssetParser(true);
+					});
 				normalModuleFactory.hooks.createParser
 					.for("asset/resource")
-					.tap(plugin, parserOptions => new AssetParser(false));
+					.tap(plugin, parserOptions => {
+						const AssetParser = getAssetParser();
+
+						return new AssetParser(false);
+					});
 				normalModuleFactory.hooks.createParser
 					.for("asset/source")
-					.tap(plugin, parserOptions => new AssetParser(false));
+					.tap(plugin, parserOptions => {
+						const AssetParser = getAssetParser();
+
+						return new AssetParser(false);
+					});
 
 				for (const type of ["asset", "asset/inline"]) {
 					normalModuleFactory.hooks.createGenerator
 						.for(type)
 						// eslint-disable-next-line no-loop-func
 						.tap(plugin, generatorOptions => {
-							validateOptions(generatorSchema, generatorOptions, {
+							validateOptions(getGeneratorSchema(), generatorOptions, {
 								name: "Asset Modules Plugin",
 								baseDataPath: "generator"
 							});
@@ -88,15 +99,25 @@ class AssetModulesPlugin {
 								};
 							}
 
+							const AssetGenerator = getAssetGenerator();
+
 							return new AssetGenerator(compilation, dataUrl);
 						});
 				}
 				normalModuleFactory.hooks.createGenerator
 					.for("asset/resource")
-					.tap(plugin, () => new AssetGenerator(compilation));
+					.tap(plugin, () => {
+						const AssetGenerator = getAssetGenerator();
+
+						return new AssetGenerator(compilation);
+					});
 				normalModuleFactory.hooks.createGenerator
 					.for("asset/source")
-					.tap(plugin, () => new AssetSourceGenerator());
+					.tap(plugin, () => {
+						const AssetSourceGenerator = getAssetSourceGenerator();
+
+						return new AssetSourceGenerator();
+					});
 
 				compilation.hooks.renderManifest.tap(plugin, (result, options) => {
 					const { chunkGraph } = compilation;

lib/json/JsonModulesPlugin.js

@@ -5,16 +5,15 @@
 
 "use strict";
 
+const memorize = require("../util/memorize");
 const validateOptions = require("schema-utils");
 const JsonGenerator = require("./JsonGenerator");
 const JsonParser = require("./JsonParser");
 
 /** @typedef {import("../Compiler")} Compiler */
 
-const lazyRequire = require("../util/lazyRequire")(require);
+const getParserSchema = memorize(() =>
-const parserSchema = lazyRequire(
+	require("../../schemas/plugins/JsonModulesPluginParser.json")
-	"../../schemas/plugins/JsonModulesPluginParser.json",
-	false
 );
 
 class JsonModulesPlugin {
@@ -30,7 +29,7 @@ class JsonModulesPlugin {
 				normalModuleFactory.hooks.createParser
 					.for("json")
 					.tap("JsonModulesPlugin", parserOptions => {
-						validateOptions(parserSchema, parserOptions, {
+						validateOptions(getParserSchema(), parserOptions, {
 							name: "Json Modules Plugin",
 							baseDataPath: "parser"
 						});

lib/util/lazyRequire.js

@@ -1,47 +0,0 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Ivan Kopeykin @vankop
-*/
-
-"use strict";
-
-/* Fork from https://github.com/sindresorhus/import-lazy */
-
-const lazy = (importedModule, requireFn, moduleId) =>
-	importedModule === undefined ? requireFn(moduleId) : importedModule;
-
-/**
- * @template T
- * @callback LazyRequire
- * @param {string} moduleId path to module
- * @param {boolean} [isFunction] flag for Proxy type,
- * if true returns function, object otherwise.
- * True by default since webpack modules are mostly functions or classes
- * @returns {T} module export
- */
-
-/**
- * @template T
- * @param {Function} requireFn require function relative to parent module
- * @returns {LazyRequire<T>} require function
- */
-module.exports = requireFn => (moduleId, isFunction = true) => {
-	let importedModule;
-
-	const handler = {
-		get: (target, property) => {
-			importedModule = lazy(importedModule, requireFn, moduleId);
-			return Reflect.get(importedModule, property);
-		},
-		apply: (target, thisArgument, argumentsList) => {
-			importedModule = lazy(importedModule, requireFn, moduleId);
-			return Reflect.apply(importedModule, thisArgument, argumentsList);
-		},
-		construct: (target, argumentsList) => {
-			importedModule = lazy(importedModule, requireFn, moduleId);
-			return Reflect.construct(importedModule, argumentsList);
-		}
-	};
-
-	return new Proxy(isFunction ? function() {} : {}, handler);
-};

lib/wasm-async/AsyncWebAssemblyModulesPlugin.js

@@ -6,6 +6,7 @@
 "use strict";
 
 const { SyncWaterfallHook } = require("tapable");
+const memorize = require("../util/memorize");
 const Compilation = require("../Compilation");
 const Generator = require("../Generator");
 const { tryRunOrWebpackError } = require("../HookWebpackError");
@@ -20,15 +21,15 @@ const { compareModulesByIdentifier } = require("../util/comparators");
 /** @typedef {import("../Template").RenderManifestEntry} RenderManifestEntry */
 /** @typedef {import("../Template").RenderManifestOptions} RenderManifestOptions */
 
-const lazyRequire = require("../util/lazyRequire")(require);
+const getAsyncWebAssemblyGenerator = memorize(() =>
-/** @type {typeof import('./AsyncWebAssemblyGenerator')} */
+	require("./AsyncWebAssemblyGenerator")
-const AsyncWebAssemblyGenerator = lazyRequire("./AsyncWebAssemblyGenerator");
+);
-/** @type {typeof import('./AsyncWebAssemblyJavascriptGenerator')} */
+const getAsyncWebAssemblyJavascriptGenerator = memorize(() =>
-const AsyncWebAssemblyJavascriptGenerator = lazyRequire(
+	require("./AsyncWebAssemblyJavascriptGenerator")
-	"./AsyncWebAssemblyJavascriptGenerator"
+);
+const getAsyncWebAssemblyParser = memorize(() =>
+	require("./AsyncWebAssemblyParser")
 );
-/** @type {typeof import('./AsyncWebAssemblyParser')} */
-const AsyncWebAssemblyParser = lazyRequire("./AsyncWebAssemblyParser");
 
 /**
  * @typedef {Object} RenderContext
@@ -95,13 +96,17 @@ class AsyncWebAssemblyModulesPlugin {
 
 				normalModuleFactory.hooks.createParser
 					.for("webassembly/async")
-					.tap(
+					.tap("AsyncWebAssemblyModulesPlugin", () => {
-						"AsyncWebAssemblyModulesPlugin",
+						const AsyncWebAssemblyParser = getAsyncWebAssemblyParser();
-						() => new AsyncWebAssemblyParser()
+
-					);
+						return new AsyncWebAssemblyParser();
+					});
 				normalModuleFactory.hooks.createGenerator
 					.for("webassembly/async")
 					.tap("AsyncWebAssemblyModulesPlugin", () => {
+						const AsyncWebAssemblyJavascriptGenerator = getAsyncWebAssemblyJavascriptGenerator();
+						const AsyncWebAssemblyGenerator = getAsyncWebAssemblyGenerator();
+
 						return Generator.byType({
 							javascript: new AsyncWebAssemblyJavascriptGenerator(
 								compilation.outputOptions.webassemblyModuleFilename

lib/wasm/WebAssemblyModulesPlugin.js

@@ -6,6 +6,7 @@
 "use strict";
 
 const Generator = require("../Generator");
+const memorize = require("../util/memorize");
 const WebAssemblyExportImportedDependency = require("../dependencies/WebAssemblyExportImportedDependency");
 const WebAssemblyImportDependency = require("../dependencies/WebAssemblyImportDependency");
 const { compareModulesByIdentifier } = require("../util/comparators");
@@ -17,16 +18,13 @@ const WebAssemblyInInitialChunkError = require("./WebAssemblyInInitialChunkError
 /** @typedef {import("../ModuleTemplate")} ModuleTemplate */
 /** @typedef {import("../ModuleTemplate").RenderContext} RenderContext */
 
-const lazyRequire = require("../util/lazyRequire")(require);
+const getWebAssemblyGenerator = memorize(() =>
-
+	require("./WebAssemblyGenerator")
-/** @type {typeof import('./WebAssemblyGenerator')} */
-const WebAssemblyGenerator = lazyRequire("./WebAssemblyGenerator");
-/** @type {typeof import('./WebAssemblyJavascriptGenerator')} */
-const WebAssemblyJavascriptGenerator = lazyRequire(
-	"./WebAssemblyJavascriptGenerator"
 );
-/** @type {typeof import('./WebAssemblyParser')} */
+const getWebAssemblyJavascriptGenerator = memorize(() =>
-const WebAssemblyParser = lazyRequire("./WebAssemblyParser");
+	require("./WebAssemblyJavascriptGenerator")
+);
+const getWebAssemblyParser = memorize(() => require("./WebAssemblyParser"));
 
 class WebAssemblyModulesPlugin {
 	constructor(options) {
@@ -53,11 +51,18 @@ class WebAssemblyModulesPlugin {
 
 				normalModuleFactory.hooks.createParser
 					.for("webassembly/sync")
-					.tap("WebAssemblyModulesPlugin", () => new WebAssemblyParser());
+					.tap("WebAssemblyModulesPlugin", () => {
+						const WebAssemblyParser = getWebAssemblyParser();
+
+						return new WebAssemblyParser();
+					});
 
 				normalModuleFactory.hooks.createGenerator
 					.for("webassembly/sync")
 					.tap("WebAssemblyModulesPlugin", () => {
+						const WebAssemblyJavascriptGenerator = getWebAssemblyJavascriptGenerator();
+						const WebAssemblyGenerator = getWebAssemblyGenerator();
+
 						return Generator.byType({
 							javascript: new WebAssemblyJavascriptGenerator(),
 							webassembly: new WebAssemblyGenerator(this.options)