root
/
webpack
mirror of https://github.com/webpack/webpack.git
1
0
Fork 0
Code Issues Actions Packages Projects Releases Wiki Activity

Replace NormalModuleFactory#plugin() calls

This commit is contained in:
Florent Cailhol 2017-12-14 10:22:27 +01:00
parent f737b26260
commit 08ddad2e10
24 changed files with 122 additions and 66 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
lib/APIPlugin.js
View File

@ -39,12 +39,16 @@ class APIPlugin {
compilation.dependencyFactories.set(ConstDependency, new NullFactory());
compilation.dependencyTemplates.set(ConstDependency, new ConstDependency.Template());
normalModuleFactory.plugin(["parser javascript/auto", "parser javascript/dynamic", "parser javascript/esm"], parser => {
const handler = parser => {
Object.keys(REPLACEMENTS).forEach(key => {
parser.plugin(`expression ${key}`, NO_WEBPACK_REQUIRE[key] ? ParserHelpers.toConstantDependency(REPLACEMENTS[key]) : ParserHelpers.toConstantDependencyWithWebpackRequire(REPLACEMENTS[key]));
parser.plugin(`evaluate typeof ${key}`, ParserHelpers.evaluateToString(REPLACEMENT_TYPES[key]));
});
});
};
normalModuleFactory.hooks.parser.for("javascript/auto").tap("APIPlugin", handler);
normalModuleFactory.hooks.parser.for("javascript/dynamic").tap("APIPlugin", handler);
normalModuleFactory.hooks.parser.for("javascript/esm").tap("APIPlugin", handler);
});
}
}

2
lib/CompatibilityPlugin.js
View File

@ -17,7 +17,7 @@ class CompatibilityPlugin {
compilation.dependencyFactories.set(ConstDependency, new NullFactory());
compilation.dependencyTemplates.set(ConstDependency, new ConstDependency.Template());
normalModuleFactory.plugin("parser javascript/auto", (parser, parserOptions) => {
normalModuleFactory.hooks.parser.for("javascript/auto").tap("CompatibilityPlugin", (parser, parserOptions) => {
if(typeof parserOptions.browserify !== "undefined" && !parserOptions.browserify)
return;

8
lib/ConstPlugin.js
View File

@ -20,7 +20,7 @@ class ConstPlugin {
compilation.dependencyFactories.set(ConstDependency, new NullFactory());
compilation.dependencyTemplates.set(ConstDependency, new ConstDependency.Template());
normalModuleFactory.plugin(["parser javascript/auto", "parser javascript/dynamic", "parser javascript/esm"], parser => {
const handler = parser => {
parser.plugin("statement if", statement => {
const param = parser.evaluateExpression(statement.test);
const bool = param.asBool();
@ -54,7 +54,11 @@ class ConstPlugin {
parser.state.current.addVariable("__resourceQuery", JSON.stringify(getQuery(parser.state.module.resource)));
return true;
});
});
};
normalModuleFactory.hooks.parser.for("javascript/auto").tap("ConstPlugin", handler);
normalModuleFactory.hooks.parser.for("javascript/dynamic").tap("ConstPlugin", handler);
normalModuleFactory.hooks.parser.for("javascript/esm").tap("ConstPlugin", handler);
});
}
}

8
lib/DefinePlugin.js
View File

@ -38,7 +38,7 @@ class DefinePlugin {
compilation.dependencyFactories.set(ConstDependency, new NullFactory());
compilation.dependencyTemplates.set(ConstDependency, new ConstDependency.Template());
normalModuleFactory.plugin(["parser javascript/auto", "parser javascript/dynamic", "parser javascript/esm"], (parser) => {
const handler = (parser) => {
const walkDefinitions = (definitions, prefix) => {
Object.keys(definitions).forEach((key) => {
const code = definitions[key];
@ -120,7 +120,11 @@ class DefinePlugin {
};
walkDefinitions(definitions, "");
});
};
normalModuleFactory.hooks.parser.for("javascript/auto").tap("DefinePlugin", handler);
normalModuleFactory.hooks.parser.for("javascript/dynamic").tap("DefinePlugin", handler);
normalModuleFactory.hooks.parser.for("javascript/esm").tap("DefinePlugin", handler);
});
}
}

12
lib/ExtendedAPIPlugin.js
View File

@ -27,7 +27,7 @@ class ExtendedAPIPlugin {
compilation.dependencyTemplates.set(ConstDependency, new ConstDependency.Template());
const mainTemplate = compilation.mainTemplate;
mainTemplate.plugin("require-extensions", (source, chunk, hash) => {
mainTemplate.hooks.requireExtensions.tap("ExtendedAPIPlugin", (source, chunk, hash) => {
const buf = [source];
buf.push("");
buf.push("// __webpack_hash__");
@ -37,14 +37,18 @@ class ExtendedAPIPlugin {
buf.push(`${mainTemplate.requireFn}.cn = ${JSON.stringify(chunk.name)};`);
return Template.asString(buf);
});
mainTemplate.plugin("global-hash", () => true);
mainTemplate.hooks.globalHash.tap("ExtendedAPIPlugin", () => true);
normalModuleFactory.plugin(["parser javascript/auto", "parser javascript/dynamic", "parser javascript/esm"], (parser, parserOptions) => {
const handler = (parser, parserOptions) => {
Object.keys(REPLACEMENTS).forEach(key => {
parser.plugin(`expression ${key}`, ParserHelpers.toConstantDependencyWithWebpackRequire(REPLACEMENTS[key]));
parser.plugin(`evaluate typeof ${key}`, ParserHelpers.evaluateToString(REPLACEMENT_TYPES[key]));
});
});
};
normalModuleFactory.hooks.parser.for("javascript/auto").tap("ExtendedAPIPlugin", handler);
normalModuleFactory.hooks.parser.for("javascript/dynamic").tap("ExtendedAPIPlugin", handler);
normalModuleFactory.hooks.parser.for("javascript/esm").tap("ExtendedAPIPlugin", handler);
});
}
}

9
lib/HotModuleReplacementPlugin.js
View File

@ -192,8 +192,7 @@ module.exports = class HotModuleReplacementPlugin {
]);
});
// TODO add HMR support for javascript/esm
normalModuleFactory.plugin(["parser javascript/auto", "parser javascript/dynamic"], (parser, parserOptions) => {
const handler = (parser, parserOptions) => {
parser.plugin("expression __webpack_hash__", ParserHelpers.toConstantDependencyWithWebpackRequire("__webpack_require__.h()"));
parser.plugin("evaluate typeof __webpack_hash__", ParserHelpers.evaluateToString("string"));
parser.plugin("evaluate Identifier module.hot", expr => {
@ -252,7 +251,11 @@ module.exports = class HotModuleReplacementPlugin {
}
});
parser.plugin("expression module.hot", ParserHelpers.skipTraversal);
});
};
// TODO add HMR support for javascript/esm
normalModuleFactory.hooks.parser.for("javascript/auto").tap("HotModuleReplacementPlugin", handler);
normalModuleFactory.hooks.parser.for("javascript/dynamic").tap("HotModuleReplacementPlugin", handler);
});
}

8
lib/JavascriptModulesPlugin.js
View File

@ -11,9 +11,13 @@ class JavascriptModulesPlugin {
compiler.hooks.compilation.tap("JavascriptModulesPlugin", (compilation, {
normalModuleFactory
}) => {
normalModuleFactory.plugin(["create-parser javascript/auto", "create-parser javascript/dynamic", "create-parser javascript/esm"], () => {
const createParser = () => {
return new Parser();
});
};
normalModuleFactory.hooks.createParser.for("javascript/auto").tap("JavascriptModulesPlugin", createParser);
normalModuleFactory.hooks.createParser.for("javascript/dynamic").tap("JavascriptModulesPlugin", createParser);
normalModuleFactory.hooks.createParser.for("javascript/esm").tap("JavascriptModulesPlugin", createParser);
});
}
}

4
lib/JsonModulesPlugin.js
View File

@ -12,10 +12,10 @@ class JsonModulesPlugin {
compiler.hooks.compilation.tap("JsonModulesPlugin", (compilation, {
normalModuleFactory
}) => {
normalModuleFactory.plugin("create-parser json", () => {
normalModuleFactory.hooks.createParser.for("json").tap("JsonModulesPlugin", () => {
return new JsonParser();
});
compilation.moduleTemplates.javascript.plugin("content", (moduleSource, module) => {
compilation.moduleTemplates.javascript.hooks.content.tap("JsonModulesPlugin", (moduleSource, module) => {
if(module.type && module.type.startsWith("json")) {
const source = new ConcatSource();
source.add(`${module.moduleArgument}.exports = `);

8
lib/NodeStuffPlugin.js
View File

@ -23,8 +23,7 @@ class NodeStuffPlugin {
compilation.dependencyFactories.set(ConstDependency, new NullFactory());
compilation.dependencyTemplates.set(ConstDependency, new ConstDependency.Template());
normalModuleFactory.plugin(["parser javascript/auto", "parser javascript/dynamic"], (parser, parserOptions) => {
const handler = (parser, parserOptions) => {
if(parserOptions.node === false)
return;
@ -92,7 +91,10 @@ class NodeStuffPlugin {
}
return ParserHelpers.addParsedVariableToModule(parser, "module", `require(${JSON.stringify(moduleJsPath)})(module)`);
});
});
};
normalModuleFactory.hooks.parser.for("javascript/auto").tap("NodeStuffPlugin", handler);
normalModuleFactory.hooks.parser.for("javascript/dynamic").tap("NodeStuffPlugin", handler);
});
}
}

11
lib/ProvidePlugin.js
View File

@ -21,17 +21,17 @@ class ProvidePlugin {
}) => {
compilation.dependencyFactories.set(ConstDependency, new NullFactory());
compilation.dependencyTemplates.set(ConstDependency, new ConstDependency.Template());
normalModuleFactory.plugin(["parser javascript/auto", "parser javascript/dynamic", "parser javascript/esm"], (parser, parserOptions) => {
const handler = (parser, parserOptions) => {
Object.keys(definitions).forEach(name => {
var request = [].concat(definitions[name]);
var splittedName = name.split(".");
if(splittedName.length > 0) {
splittedName.slice(1).forEach((_, i) => {
const name = splittedName.slice(0, i + 1).join(".");
parser.plugin(`can-rename ${name}`, ParserHelpers.approve);
parser.hooks.canRename.for(name).tap("ProvidePlugin", ParserHelpers.approve);
});
}
parser.plugin(`expression ${name}`, expr => {
parser.hooks.expression.for(name).tap("ProvidePlugin", expr => {
let nameIdentifier = name;
const scopedName = name.indexOf(".") >= 0;
let expression = `require(${JSON.stringify(request[0])})`;
@ -50,7 +50,10 @@ class ProvidePlugin {
return true;
});
});
});
};
normalModuleFactory.hooks.parser.for("javascript/auto").tap("ProvidePlugin", handler);
normalModuleFactory.hooks.parser.for("javascript/dynamic").tap("ProvidePlugin", handler);
normalModuleFactory.hooks.parser.for("javascript/esm").tap("ProvidePlugin", handler);
});
}
}

7
lib/RequireJsStuffPlugin.js
View File

@ -16,8 +16,7 @@ module.exports = class RequireJsStuffPlugin {
}) => {
compilation.dependencyFactories.set(ConstDependency, new NullFactory());
compilation.dependencyTemplates.set(ConstDependency, new ConstDependency.Template());
normalModuleFactory.plugin(["parser javascript/auto", "parser javascript/dynamic"], (parser, parserOptions) => {
const handler = (parser, parserOptions) => {
if(typeof parserOptions.requireJs !== "undefined" && !parserOptions.requireJs)
return;
@ -26,7 +25,9 @@ module.exports = class RequireJsStuffPlugin {
parser.plugin("expression require.version", ParserHelpers.toConstantDependency(JSON.stringify("0.0.0")));
parser.plugin("expression requirejs.onError", ParserHelpers.toConstantDependencyWithWebpackRequire("__webpack_require__.oe"));
});
};
normalModuleFactory.hooks.parser.for("javascript/auto").tap("RequireJsStuffPlugin", handler);
normalModuleFactory.hooks.parser.for("javascript/dynamic").tap("RequireJsStuffPlugin", handler);
});
}

8
lib/UseStrictPlugin.js
View File

@ -11,7 +11,7 @@ class UseStrictPlugin {
compiler.hooks.compilation.tap("UseStrictPlugin", (compilation, {
normalModuleFactory
}) => {
normalModuleFactory.plugin(["parser javascript/auto", "parser javascript/dynamic", "parser javascript/esm"], (parser) => {
const handler = (parser) => {
const parserInstance = parser;
parser.hooks.program.tap("UseStrictPlugin", (ast) => {
const firstNode = ast.body[0];
@ -28,7 +28,11 @@ class UseStrictPlugin {
parserInstance.state.module.buildInfo.strict = true;
}
});
});
};
normalModuleFactory.hooks.parser.for("javascript/auto").tap("UseStrictPlugin", handler);
normalModuleFactory.hooks.parser.for("javascript/dynamic").tap("UseStrictPlugin", handler);
normalModuleFactory.hooks.parser.for("javascript/esm").tap("UseStrictPlugin", handler);
});
}
}

2
lib/WebAssemblyModulesPlugin.js
View File

@ -11,7 +11,7 @@ class WebAssemblyModulesPlugin {
compiler.hooks.compilation.tap("WebAssemblyModulesPlugin", (compilation, {
normalModuleFactory
}) => {
normalModuleFactory.plugin("create-parser webassembly/experimental", () => {
normalModuleFactory.hooks.createParser.for("webassembly/experimental").tap("WebAssemblyModulesPlugin", () => {
return new WebAssemblyParser();
});
});

6
lib/WebpackOptionsApply.js
View File

@ -339,18 +339,18 @@ class WebpackOptionsApply extends OptionsApply {
compiler.hooks.afterPlugins.call(compiler);
if(!compiler.inputFileSystem) throw new Error("No input filesystem provided");
compiler.resolverFactory.plugin("resolve-options normal", resolveOptions => {
compiler.resolverFactory.hooks.resolveOptions.for("normal").tap("WebpackOptionsApply", resolveOptions => {
return Object.assign({
fileSystem: compiler.inputFileSystem
}, options.resolve, resolveOptions);
});
compiler.resolverFactory.plugin("resolve-options context", resolveOptions => {
compiler.resolverFactory.hooks.resolveOptions.for("context").tap("WebpackOptionsApply", resolveOptions => {
return Object.assign({
fileSystem: compiler.inputFileSystem,
resolveToContext: true
}, options.resolve, resolveOptions);
});
compiler.resolverFactory.plugin("resolve-options loader", resolveOptions => {
compiler.resolverFactory.hooks.resolveOptions.for("loader").tap("WebpackOptionsApply", resolveOptions => {
return Object.assign({
fileSystem: compiler.inputFileSystem
}, options.resolveLoader, resolveOptions);

10
lib/dependencies/AMDPlugin.js
View File

@ -56,8 +56,7 @@ class AMDPlugin {
compilation.dependencyFactories.set(LocalModuleDependency, new NullFactory());
compilation.dependencyTemplates.set(LocalModuleDependency, new LocalModuleDependency.Template());
normalModuleFactory.plugin(["parser javascript/auto", "parser javascript/dynamic"], (parser, parserOptions) => {
const handler = (parser, parserOptions) => {
if(typeof parserOptions.amd !== "undefined" && !parserOptions.amd)
return;
@ -96,10 +95,13 @@ class AMDPlugin {
});
parser.plugin("typeof require", ParserHelpers.toConstantDependency(JSON.stringify("function")));
parser.plugin("evaluate typeof require", ParserHelpers.evaluateToString("function"));
});
};
normalModuleFactory.hooks.parser.for("javascript/auto").tap("AMDPlugin", handler);
normalModuleFactory.hooks.parser.for("javascript/dynamic").tap("AMDPlugin", handler);
});
compiler.hooks.afterResolvers.tap("AMDPlugin", () => {
compiler.resolverFactory.plugin("resolver normal", resolver => resolver.apply(
compiler.resolverFactory.hooks.resolver.for("normal").tap("AMDPlugin", resolver => resolver.apply(
new AliasPlugin("described-resolve", {
name: "amdefine",
alias: path.join(__dirname, "..", "..", "buildin", "amd-define.js")

8
lib/dependencies/CommonJsPlugin.js
View File

@ -47,8 +47,7 @@ class CommonJsPlugin {
compilation.dependencyFactories.set(RequireHeaderDependency, new NullFactory());
compilation.dependencyTemplates.set(RequireHeaderDependency, new RequireHeaderDependency.Template());
normalModuleFactory.plugin(["parser javascript/auto", "parser javascript/dynamic"], (parser, parserOptions) => {
const handler = (parser, parserOptions) => {
if(typeof parserOptions.commonjs !== "undefined" && !parserOptions.commonjs)
return;
@ -82,7 +81,10 @@ class CommonJsPlugin {
new CommonJsRequireDependencyParserPlugin(options),
new RequireResolveDependencyParserPlugin(options)
);
});
};
normalModuleFactory.hooks.parser.for("javascript/auto").tap("CommonJsPlugin", handler);
normalModuleFactory.hooks.parser.for("javascript/dynamic").tap("CommonJsPlugin", handler);
});
}
}

8
lib/dependencies/HarmonyModulesPlugin.js
View File

@ -59,8 +59,7 @@ class HarmonyModulesPlugin {
compilation.dependencyFactories.set(HarmonyAcceptImportDependency, normalModuleFactory);
compilation.dependencyTemplates.set(HarmonyAcceptImportDependency, new HarmonyAcceptImportDependency.Template());
normalModuleFactory.plugin(["parser javascript/auto", "parser javascript/esm"], (parser, parserOptions) => {
const handler = (parser, parserOptions) => {
if(typeof parserOptions.harmony !== "undefined" && !parserOptions.harmony)
return;
@ -69,7 +68,10 @@ class HarmonyModulesPlugin {
new HarmonyImportDependencyParserPlugin(this.options),
new HarmonyExportDependencyParserPlugin(this.options)
);
});
};
normalModuleFactory.hooks.parser.for("javascript/auto").tap("HarmonyModulesPlugin", handler);
normalModuleFactory.hooks.parser.for("javascript/esm").tap("HarmonyModulesPlugin", handler);
});
}
}

9
lib/dependencies/ImportPlugin.js
View File

@ -33,15 +33,18 @@ class ImportPlugin {
compilation.dependencyFactories.set(ImportContextDependency, contextModuleFactory);
compilation.dependencyTemplates.set(ImportContextDependency, new ImportContextDependency.Template());
normalModuleFactory.plugin(["parser javascript/auto", "parser javascript/dynamic", "parser javascript/esm"], (parser, parserOptions) => {
const handler = (parser, parserOptions) => {
if(typeof parserOptions.import !== "undefined" && !parserOptions.import)
return;
parser.apply(
new ImportParserPlugin(options)
);
});
};
normalModuleFactory.hooks.parser.for("javascript/auto").tap("ImportPlugin", handler);
normalModuleFactory.hooks.parser.for("javascript/dynamic").tap("ImportPlugin", handler);
normalModuleFactory.hooks.parser.for("javascript/esm").tap("ImportPlugin", handler);
});
}
}

8
lib/dependencies/RequireContextPlugin.js
View File

@ -30,13 +30,15 @@ class RequireContextPlugin {
compilation.dependencyFactories.set(ContextElementDependency, normalModuleFactory);
normalModuleFactory.plugin(["parser javascript/auto", "parser javascript/dynamic"], (parser, parserOptions) => {
const handler = (parser, parserOptions) => {
if(typeof parserOptions.requireContext !== "undefined" && !parserOptions.requireContext)
return;
parser.apply(new RequireContextDependencyParserPlugin());
});
};
normalModuleFactory.hooks.parser.for("javascript/auto").tap("RequireContextPlugin", handler);
normalModuleFactory.hooks.parser.for("javascript/dynamic").tap("RequireContextPlugin", handler);
contextModuleFactory.hooks.alternatives.tapAsync("RequireContextPlugin", (items, callback) => {
if(items.length === 0) return callback(null, items);

8
lib/dependencies/RequireEnsurePlugin.js
View File

@ -25,15 +25,17 @@ class RequireEnsurePlugin {
compilation.dependencyFactories.set(RequireEnsureDependency, new NullFactory());
compilation.dependencyTemplates.set(RequireEnsureDependency, new RequireEnsureDependency.Template());
normalModuleFactory.plugin(["parser javascript/auto", "parser javascript/dynamic"], (parser, parserOptions) => {
const handler = (parser, parserOptions) => {
if(typeof parserOptions.requireEnsure !== "undefined" && !parserOptions.requireEnsure)
return;
parser.apply(new RequireEnsureDependenciesBlockParserPlugin());
parser.plugin("evaluate typeof require.ensure", ParserHelpers.evaluateToString("function"));
parser.plugin("typeof require.ensure", ParserHelpers.toConstantDependency(JSON.stringify("function")));
});
};
normalModuleFactory.hooks.parser.for("javascript/auto").tap("RequireEnsurePlugin", handler);
normalModuleFactory.hooks.parser.for("javascript/dynamic").tap("RequireEnsurePlugin", handler);
});
}
}

9
lib/dependencies/RequireIncludePlugin.js
View File

@ -10,7 +10,6 @@ const RequireIncludeDependencyParserPlugin = require("./RequireIncludeDependency
const ParserHelpers = require("../ParserHelpers");
class RequireIncludePlugin {
apply(compiler) {
compiler.hooks.compilation.tap("RequireIncludePlugin", (compilation, {
normalModuleFactory
@ -18,15 +17,17 @@ class RequireIncludePlugin {
compilation.dependencyFactories.set(RequireIncludeDependency, normalModuleFactory);
compilation.dependencyTemplates.set(RequireIncludeDependency, new RequireIncludeDependency.Template());
normalModuleFactory.plugin(["parser javascript/auto", "parser javascript/dynamic"], (parser, parserOptions) => {
const handler = (parser, parserOptions) => {
if(typeof parserOptions.requireInclude !== "undefined" && !parserOptions.requireInclude)
return;
parser.apply(new RequireIncludeDependencyParserPlugin());
parser.plugin("evaluate typeof require.include", ParserHelpers.evaluateToString("function"));
parser.plugin("typeof require.include", ParserHelpers.toConstantDependency(JSON.stringify("function")));
});
};
normalModuleFactory.hooks.parser.for("javascript/auto").tap("RequireIncludePlugin", handler);
normalModuleFactory.hooks.parser.for("javascript/dynamic").tap("RequireIncludePlugin", handler);
});
}
}

8
lib/dependencies/SystemPlugin.js
View File

@ -14,8 +14,7 @@ class SystemPlugin {
compiler.hooks.compilation.tap("SystemPlugin", (compilation, {
normalModuleFactory
}) => {
normalModuleFactory.plugin(["parser javascript/auto", "parser javascript/dynamic"], (parser, parserOptions) => {
const handler = (parser, parserOptions) => {
if(typeof parserOptions.system !== "undefined" && !parserOptions.system)
return;
@ -39,7 +38,10 @@ class SystemPlugin {
parser.state.module.context, require.resolve("../../buildin/system.js"));
return ParserHelpers.addParsedVariableToModule(parser, "System", systemPolyfillRequire);
});
});
};
normalModuleFactory.hooks.parser.for("javascript/auto").tap("SystemPlugin", handler);
normalModuleFactory.hooks.parser.for("javascript/dynamic").tap("SystemPlugin", handler);
});
}
}

10
lib/node/NodeSourcePlugin.js
View File

@ -39,8 +39,7 @@ module.exports = class NodeSourcePlugin {
compiler.hooks.compilation.tap("NodeSourcePlugin", (compilation, {
normalModuleFactory
}) => {
normalModuleFactory.plugin(["parser javascript/auto", "parser javascript/dynamic", "parser javascript/esm"], (parser, parserOptions) => {
const handler = (parser, parserOptions) => {
if(parserOptions.node === false)
return;
@ -71,12 +70,15 @@ module.exports = class NodeSourcePlugin {
addExpression(parser, "setImmediate", "timers", setImmediateType, ".setImmediate");
addExpression(parser, "clearImmediate", "timers", setImmediateType, ".clearImmediate");
}
});
};
normalModuleFactory.hooks.parser.for("javascript/auto").tap("NodeSourcePlugin", handler);
normalModuleFactory.hooks.parser.for("javascript/dynamic").tap("NodeSourcePlugin", handler);
normalModuleFactory.hooks.parser.for("javascript/esm").tap("NodeSourcePlugin", handler);
});
compiler.hooks.afterResolvers.tap("NodeSourcePlugin", (compiler) => {
Object.keys(nodeLibsBrowser).forEach((lib) => {
if(options[lib] !== false) {
compiler.resolverFactory.plugin("resolver normal", resolver => resolver.apply(
compiler.resolverFactory.hooks.resolver.for("normal").tap("NodeSourcePlugin", resolver => resolver.apply(
new AliasPlugin("described-resolve", {
name: lib,
onlyModule: true,

9
lib/optimize/ModuleConcatenationPlugin.js
View File

@ -25,11 +25,16 @@ class ModuleConcatenationPlugin {
compiler.hooks.compilation.tap("ModuleConcatenationPlugin", (compilation, {
normalModuleFactory
}) => {
normalModuleFactory.plugin(["parser javascript/auto", "parser javascript/dynamic", "parser javascript/esm"], (parser, parserOptions) => {
const handler = (parser, parserOptions) => {
parser.plugin("call eval", () => {
parser.state.module.buildMeta.hasEval = true;
});
});
};
normalModuleFactory.hooks.parser.for("javascript/auto").tap("ModuleConcatenationPlugin", handler);
normalModuleFactory.hooks.parser.for("javascript/dynamic").tap("ModuleConcatenationPlugin", handler);
normalModuleFactory.hooks.parser.for("javascript/esm").tap("ModuleConcatenationPlugin", handler);
const bailoutReasonMap = new Map();
const setBailoutReason = (module, reason) => {