WebpackOptionsApply.js
No OneTemporary
Actions

Subscribers

None

File Metadata

Created: Sat, Feb 15, 16:33

WebpackOptionsApply.js
View Options

	/*
	MIT License http://www.opensource.org/licenses/mit-license.php
	Author Tobias Koppers @sokra
	*/

	"use strict";

	const OptionsApply = require("./OptionsApply");

	const AssetModulesPlugin = require("./asset/AssetModulesPlugin");
	const JavascriptModulesPlugin = require("./javascript/JavascriptModulesPlugin");
	const JsonModulesPlugin = require("./json/JsonModulesPlugin");

	const ChunkPrefetchPreloadPlugin = require("./prefetch/ChunkPrefetchPreloadPlugin");

	const EntryOptionPlugin = require("./EntryOptionPlugin");
	const RecordIdsPlugin = require("./RecordIdsPlugin");

	const RuntimePlugin = require("./RuntimePlugin");

	const APIPlugin = require("./APIPlugin");
	const CompatibilityPlugin = require("./CompatibilityPlugin");
	const ConstPlugin = require("./ConstPlugin");
	const ExportsInfoApiPlugin = require("./ExportsInfoApiPlugin");

	const TemplatedPathPlugin = require("./TemplatedPathPlugin");
	const UseStrictPlugin = require("./UseStrictPlugin");
	const WarnCaseSensitiveModulesPlugin = require("./WarnCaseSensitiveModulesPlugin");

	const DataUriPlugin = require("./schemes/DataUriPlugin");
	const FileUriPlugin = require("./schemes/FileUriPlugin");

	const ResolverCachePlugin = require("./cache/ResolverCachePlugin");

	const CommonJsPlugin = require("./dependencies/CommonJsPlugin");
	const HarmonyModulesPlugin = require("./dependencies/HarmonyModulesPlugin");
	const ImportMetaPlugin = require("./dependencies/ImportMetaPlugin");
	const ImportPlugin = require("./dependencies/ImportPlugin");
	const LoaderPlugin = require("./dependencies/LoaderPlugin");
	const RequireContextPlugin = require("./dependencies/RequireContextPlugin");
	const RequireEnsurePlugin = require("./dependencies/RequireEnsurePlugin");
	const RequireIncludePlugin = require("./dependencies/RequireIncludePlugin");
	const SystemPlugin = require("./dependencies/SystemPlugin");
	const URLPlugin = require("./dependencies/URLPlugin");

	const InferAsyncModulesPlugin = require("./async-modules/InferAsyncModulesPlugin");

	const FlagUsingEvalPlugin = require("./FlagUsingEvalPlugin");
	const DefaultStatsFactoryPlugin = require("./stats/DefaultStatsFactoryPlugin");
	const DefaultStatsPresetPlugin = require("./stats/DefaultStatsPresetPlugin");
	const DefaultStatsPrinterPlugin = require("./stats/DefaultStatsPrinterPlugin");

	const { cleverMerge } = require("./util/cleverMerge");

	/** @typedef {import("../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
	/** @typedef {import("./Compiler")} Compiler */

	class WebpackOptionsApply extends OptionsApply {
	constructor() {
	super();
	}

	/**
	* @param {WebpackOptions} options options object
	* @param {Compiler} compiler compiler object
	* @returns {WebpackOptions} options object
	*/
	process(options, compiler) {
	compiler.outputPath = options.output.path;
	compiler.recordsInputPath = options.recordsInputPath \|\| null;
	compiler.recordsOutputPath = options.recordsOutputPath \|\| null;
	compiler.name = options.name;

	if (options.externalsPresets.node) {
	const NodeTargetPlugin = require("./node/NodeTargetPlugin");
	new NodeTargetPlugin().apply(compiler);
	}
	if (options.externalsPresets.electronMain) {
	//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
	const ElectronTargetPlugin = require("./electron/ElectronTargetPlugin");
	new ElectronTargetPlugin("main").apply(compiler);
	}
	if (options.externalsPresets.electronPreload) {
	//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
	const ElectronTargetPlugin = require("./electron/ElectronTargetPlugin");
	new ElectronTargetPlugin("preload").apply(compiler);
	}
	if (options.externalsPresets.electronRenderer) {
	//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
	const ElectronTargetPlugin = require("./electron/ElectronTargetPlugin");
	new ElectronTargetPlugin("renderer").apply(compiler);
	}
	if (
	options.externalsPresets.electron &&
	!options.externalsPresets.electronMain &&
	!options.externalsPresets.electronPreload &&
	!options.externalsPresets.electronRenderer
	) {
	//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
	const ElectronTargetPlugin = require("./electron/ElectronTargetPlugin");
	new ElectronTargetPlugin().apply(compiler);
	}
	if (options.externalsPresets.nwjs) {
	//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
	const ExternalsPlugin = require("./ExternalsPlugin");
	new ExternalsPlugin("commonjs", "nw.gui").apply(compiler);
	}
	if (options.externalsPresets.webAsync) {
	//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
	const ExternalsPlugin = require("./ExternalsPlugin");
	new ExternalsPlugin("import", /^(https?:\/\/\|std:)/).apply(compiler);
	} else if (options.externalsPresets.web) {
	//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
	const ExternalsPlugin = require("./ExternalsPlugin");
	new ExternalsPlugin("module", /^(https?:\/\/\|std:)/).apply(compiler);
	}

	new ChunkPrefetchPreloadPlugin().apply(compiler);

	if (typeof options.output.chunkFormat === "string") {
	switch (options.output.chunkFormat) {
	case "array-push": {
	const ArrayPushCallbackChunkFormatPlugin = require("./javascript/ArrayPushCallbackChunkFormatPlugin");
	new ArrayPushCallbackChunkFormatPlugin().apply(compiler);
	break;
	}
	case "commonjs": {
	const CommonJsChunkFormatPlugin = require("./javascript/CommonJsChunkFormatPlugin");
	new CommonJsChunkFormatPlugin().apply(compiler);
	break;
	}
	case "module":
	throw new Error(
	"EcmaScript Module Chunk Format is not implemented yet"
	);
	default:
	throw new Error(
	"Unsupported chunk format '" + options.output.chunkFormat + "'."
	);
	}
	}

	if (options.output.enabledChunkLoadingTypes.length > 0) {
	for (const type of options.output.enabledChunkLoadingTypes) {
	const EnableChunkLoadingPlugin = require("./javascript/EnableChunkLoadingPlugin");
	new EnableChunkLoadingPlugin(type).apply(compiler);
	}
	}

	if (options.output.enabledWasmLoadingTypes.length > 0) {
	for (const type of options.output.enabledWasmLoadingTypes) {
	const EnableWasmLoadingPlugin = require("./wasm/EnableWasmLoadingPlugin");
	new EnableWasmLoadingPlugin(type).apply(compiler);
	}
	}

	if (options.output.enabledLibraryTypes.length > 0) {
	for (const type of options.output.enabledLibraryTypes) {
	const EnableLibraryPlugin = require("./library/EnableLibraryPlugin");
	new EnableLibraryPlugin(type).apply(compiler);
	}
	}

	if (options.externals) {
	//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
	const ExternalsPlugin = require("./ExternalsPlugin");
	new ExternalsPlugin(options.externalsType, options.externals).apply(
	compiler
	);
	}

	if (options.output.pathinfo) {
	const ModuleInfoHeaderPlugin = require("./ModuleInfoHeaderPlugin");
	new ModuleInfoHeaderPlugin(options.output.pathinfo !== true).apply(
	compiler
	);
	}

	if (options.devtool) {
	if (options.devtool.includes("source-map")) {
	const hidden = options.devtool.includes("hidden");
	const inline = options.devtool.includes("inline");
	const evalWrapped = options.devtool.includes("eval");
	const cheap = options.devtool.includes("cheap");
	const moduleMaps = options.devtool.includes("module");
	const noSources = options.devtool.includes("nosources");
	const Plugin = evalWrapped
	? require("./EvalSourceMapDevToolPlugin")
	: require("./SourceMapDevToolPlugin");
	new Plugin({
	filename: inline ? null : options.output.sourceMapFilename,
	moduleFilenameTemplate: options.output.devtoolModuleFilenameTemplate,
	fallbackModuleFilenameTemplate:
	options.output.devtoolFallbackModuleFilenameTemplate,
	append: hidden ? false : undefined,
	module: moduleMaps ? true : cheap ? false : true,
	columns: cheap ? false : true,
	noSources: noSources,
	namespace: options.output.devtoolNamespace
	}).apply(compiler);
	} else if (options.devtool.includes("eval")) {
	const EvalDevToolModulePlugin = require("./EvalDevToolModulePlugin");
	new EvalDevToolModulePlugin({
	moduleFilenameTemplate: options.output.devtoolModuleFilenameTemplate,
	namespace: options.output.devtoolNamespace
	}).apply(compiler);
	}
	}

	new JavascriptModulesPlugin().apply(compiler);
	new JsonModulesPlugin().apply(compiler);
	new AssetModulesPlugin().apply(compiler);

	if (!options.experiments.outputModule) {
	if (options.output.module) {
	throw new Error(
	"'output.module: true' is only allowed when 'experiments.outputModule' is enabled"
	);
	}
	if (options.output.enabledLibraryTypes.includes("module")) {
	throw new Error(
	"library type \"module\" is only allowed when 'experiments.outputModule' is enabled"
	);
	}
	if (options.externalsType === "module") {
	throw new Error(
	"'externalsType: \"module\"' is only allowed when 'experiments.outputModule' is enabled"
	);
	}
	}

	if (options.experiments.syncWebAssembly) {
	const WebAssemblyModulesPlugin = require("./wasm-sync/WebAssemblyModulesPlugin");
	new WebAssemblyModulesPlugin({
	mangleImports: options.optimization.mangleWasmImports
	}).apply(compiler);
	}

	if (options.experiments.asyncWebAssembly) {
	const AsyncWebAssemblyModulesPlugin = require("./wasm-async/AsyncWebAssemblyModulesPlugin");
	new AsyncWebAssemblyModulesPlugin({
	mangleImports: options.optimization.mangleWasmImports
	}).apply(compiler);
	}

	new EntryOptionPlugin().apply(compiler);
	compiler.hooks.entryOption.call(options.context, options.entry);

	new RuntimePlugin().apply(compiler);

	new InferAsyncModulesPlugin().apply(compiler);

	new DataUriPlugin().apply(compiler);
	new FileUriPlugin().apply(compiler);

	new CompatibilityPlugin().apply(compiler);
	new HarmonyModulesPlugin({
	module: options.module,
	topLevelAwait: options.experiments.topLevelAwait
	}).apply(compiler);
	if (options.amd !== false) {
	const AMDPlugin = require("./dependencies/AMDPlugin");
	const RequireJsStuffPlugin = require("./RequireJsStuffPlugin");
	new AMDPlugin(options.module, options.amd \|\| {}).apply(compiler);
	new RequireJsStuffPlugin().apply(compiler);
	}
	new CommonJsPlugin(options.module).apply(compiler);
	new LoaderPlugin().apply(compiler);
	if (options.node !== false) {
	const NodeStuffPlugin = require("./NodeStuffPlugin");
	new NodeStuffPlugin(options.node).apply(compiler);
	}
	new APIPlugin().apply(compiler);
	new ExportsInfoApiPlugin().apply(compiler);
	new ConstPlugin().apply(compiler);
	new UseStrictPlugin().apply(compiler);
	new RequireIncludePlugin().apply(compiler);
	new RequireEnsurePlugin().apply(compiler);
	new RequireContextPlugin().apply(compiler);
	new ImportPlugin(options.module).apply(compiler);
	new SystemPlugin(options.module).apply(compiler);
	new ImportMetaPlugin().apply(compiler);
	new URLPlugin().apply(compiler);

	if (options.output.workerChunkLoading) {
	const WorkerPlugin = require("./dependencies/WorkerPlugin");
	new WorkerPlugin(options.output.workerChunkLoading).apply(compiler);
	}

	new DefaultStatsFactoryPlugin().apply(compiler);
	new DefaultStatsPresetPlugin().apply(compiler);
	new DefaultStatsPrinterPlugin().apply(compiler);

	new FlagUsingEvalPlugin().apply(compiler);

	if (typeof options.mode !== "string") {
	const WarnNoModeSetPlugin = require("./WarnNoModeSetPlugin");
	new WarnNoModeSetPlugin().apply(compiler);
	}

	const EnsureChunkConditionsPlugin = require("./optimize/EnsureChunkConditionsPlugin");
	new EnsureChunkConditionsPlugin().apply(compiler);
	if (options.optimization.removeAvailableModules) {
	const RemoveParentModulesPlugin = require("./optimize/RemoveParentModulesPlugin");
	new RemoveParentModulesPlugin().apply(compiler);
	}
	if (options.optimization.removeEmptyChunks) {
	const RemoveEmptyChunksPlugin = require("./optimize/RemoveEmptyChunksPlugin");
	new RemoveEmptyChunksPlugin().apply(compiler);
	}
	if (options.optimization.mergeDuplicateChunks) {
	const MergeDuplicateChunksPlugin = require("./optimize/MergeDuplicateChunksPlugin");
	new MergeDuplicateChunksPlugin().apply(compiler);
	}
	if (options.optimization.flagIncludedChunks) {
	const FlagIncludedChunksPlugin = require("./optimize/FlagIncludedChunksPlugin");
	new FlagIncludedChunksPlugin().apply(compiler);
	}
	if (options.optimization.sideEffects) {
	const SideEffectsFlagPlugin = require("./optimize/SideEffectsFlagPlugin");
	new SideEffectsFlagPlugin(
	options.optimization.sideEffects === true
	).apply(compiler);
	}
	if (options.optimization.providedExports) {
	const FlagDependencyExportsPlugin = require("./FlagDependencyExportsPlugin");
	new FlagDependencyExportsPlugin().apply(compiler);
	}
	if (options.optimization.usedExports) {
	const FlagDependencyUsagePlugin = require("./FlagDependencyUsagePlugin");
	new FlagDependencyUsagePlugin(
	options.optimization.usedExports === "global"
	).apply(compiler);
	}
	if (options.optimization.innerGraph) {
	const InnerGraphPlugin = require("./optimize/InnerGraphPlugin");
	new InnerGraphPlugin().apply(compiler);
	}
	if (options.optimization.mangleExports) {
	const MangleExportsPlugin = require("./optimize/MangleExportsPlugin");
	new MangleExportsPlugin(
	options.optimization.mangleExports !== "size"
	).apply(compiler);
	}
	if (options.optimization.concatenateModules) {
	const ModuleConcatenationPlugin = require("./optimize/ModuleConcatenationPlugin");
	new ModuleConcatenationPlugin().apply(compiler);
	}
	if (options.optimization.splitChunks) {
	const SplitChunksPlugin = require("./optimize/SplitChunksPlugin");
	new SplitChunksPlugin(options.optimization.splitChunks).apply(compiler);
	}
	if (options.optimization.runtimeChunk) {
	const RuntimeChunkPlugin = require("./optimize/RuntimeChunkPlugin");
	new RuntimeChunkPlugin(options.optimization.runtimeChunk).apply(compiler);
	}
	if (!options.optimization.emitOnErrors) {
	const NoEmitOnErrorsPlugin = require("./NoEmitOnErrorsPlugin");
	new NoEmitOnErrorsPlugin().apply(compiler);
	}
	if (options.optimization.realContentHash) {
	const RealContentHashPlugin = require("./optimize/RealContentHashPlugin");
	new RealContentHashPlugin({
	hashFunction: options.output.hashFunction,
	hashDigest: options.output.hashDigest
	}).apply(compiler);
	}
	if (options.optimization.checkWasmTypes) {
	const WasmFinalizeExportsPlugin = require("./wasm-sync/WasmFinalizeExportsPlugin");
	new WasmFinalizeExportsPlugin().apply(compiler);
	}
	const moduleIds = options.optimization.moduleIds;
	if (moduleIds) {
	switch (moduleIds) {
	case "natural": {
	const NaturalModuleIdsPlugin = require("./ids/NaturalModuleIdsPlugin");
	new NaturalModuleIdsPlugin().apply(compiler);
	break;
	}
	case "named": {
	const NamedModuleIdsPlugin = require("./ids/NamedModuleIdsPlugin");
	new NamedModuleIdsPlugin().apply(compiler);
	break;
	}
	case "hashed": {
	const WarnDeprecatedOptionPlugin = require("./WarnDeprecatedOptionPlugin");
	const HashedModuleIdsPlugin = require("./ids/HashedModuleIdsPlugin");
	new WarnDeprecatedOptionPlugin(
	"optimization.moduleIds",
	"hashed",
	"deterministic"
	).apply(compiler);
	new HashedModuleIdsPlugin().apply(compiler);
	break;
	}
	case "deterministic": {
	const DeterministicModuleIdsPlugin = require("./ids/DeterministicModuleIdsPlugin");
	new DeterministicModuleIdsPlugin().apply(compiler);
	break;
	}
	case "size": {
	const OccurrenceModuleIdsPlugin = require("./ids/OccurrenceModuleIdsPlugin");
	new OccurrenceModuleIdsPlugin({
	prioritiseInitial: true
	}).apply(compiler);
	break;
	}
	default:
	throw new Error(
	`webpack bug: moduleIds: ${moduleIds} is not implemented`
	);
	}
	}
	const chunkIds = options.optimization.chunkIds;
	if (chunkIds) {
	switch (chunkIds) {
	case "natural": {
	const NaturalChunkIdsPlugin = require("./ids/NaturalChunkIdsPlugin");
	new NaturalChunkIdsPlugin().apply(compiler);
	break;
	}
	case "named": {
	const NamedChunkIdsPlugin = require("./ids/NamedChunkIdsPlugin");
	new NamedChunkIdsPlugin().apply(compiler);
	break;
	}
	case "deterministic": {
	const DeterministicChunkIdsPlugin = require("./ids/DeterministicChunkIdsPlugin");
	new DeterministicChunkIdsPlugin().apply(compiler);
	break;
	}
	case "size": {
	//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
	const OccurrenceChunkIdsPlugin = require("./ids/OccurrenceChunkIdsPlugin");
	new OccurrenceChunkIdsPlugin({
	prioritiseInitial: true
	}).apply(compiler);
	break;
	}
	case "total-size": {
	//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
	const OccurrenceChunkIdsPlugin = require("./ids/OccurrenceChunkIdsPlugin");
	new OccurrenceChunkIdsPlugin({
	prioritiseInitial: false
	}).apply(compiler);
	break;
	}
	default:
	throw new Error(
	`webpack bug: chunkIds: ${chunkIds} is not implemented`
	);
	}
	}
	if (options.optimization.nodeEnv) {
	const DefinePlugin = require("./DefinePlugin");
	new DefinePlugin({
	"process.env.NODE_ENV": JSON.stringify(options.optimization.nodeEnv)
	}).apply(compiler);
	}
	if (options.optimization.minimize) {
	for (const minimizer of options.optimization.minimizer) {
	if (typeof minimizer === "function") {
	minimizer.call(compiler, compiler);
	} else if (minimizer !== "...") {
	minimizer.apply(compiler);
	}
	}
	}

	if (options.performance) {
	const SizeLimitsPlugin = require("./performance/SizeLimitsPlugin");
	new SizeLimitsPlugin(options.performance).apply(compiler);
	}

	new TemplatedPathPlugin().apply(compiler);

	new RecordIdsPlugin({
	portableIds: options.optimization.portableRecords
	}).apply(compiler);

	new WarnCaseSensitiveModulesPlugin().apply(compiler);

	const AddManagedPathsPlugin = require("./cache/AddManagedPathsPlugin");
	new AddManagedPathsPlugin(
	options.snapshot.managedPaths,
	options.snapshot.immutablePaths
	).apply(compiler);

	if (options.cache && typeof options.cache === "object") {
	const cacheOptions = options.cache;
	switch (cacheOptions.type) {
	case "memory": {
	//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
	const MemoryCachePlugin = require("./cache/MemoryCachePlugin");
	new MemoryCachePlugin().apply(compiler);
	break;
	}
	case "filesystem": {
	const AddBuildDependenciesPlugin = require("./cache/AddBuildDependenciesPlugin");
	for (const key in cacheOptions.buildDependencies) {
	const list = cacheOptions.buildDependencies[key];
	new AddBuildDependenciesPlugin(list).apply(compiler);
	}
	//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
	const MemoryCachePlugin = require("./cache/MemoryCachePlugin");
	new MemoryCachePlugin().apply(compiler);
	switch (cacheOptions.store) {
	case "pack": {
	const IdleFileCachePlugin = require("./cache/IdleFileCachePlugin");
	const PackFileCacheStrategy = require("./cache/PackFileCacheStrategy");
	new IdleFileCachePlugin(
	new PackFileCacheStrategy({
	compiler,
	fs: compiler.intermediateFileSystem,
	context: options.context,
	cacheLocation: cacheOptions.cacheLocation,
	version: cacheOptions.version,
	logger: compiler.getInfrastructureLogger(
	"webpack.cache.PackFileCacheStrategy"
	),
	snapshot: options.snapshot
	}),
	cacheOptions.idleTimeout,
	cacheOptions.idleTimeoutForInitialStore
	).apply(compiler);
	break;
	}
	default:
	throw new Error("Unhandled value for cache.store");
	}
	break;
	}
	default:
	// @ts-expect-error Property 'type' does not exist on type 'never'. ts(2339)
	throw new Error(`Unknown cache type ${cacheOptions.type}`);
	}
	}
	new ResolverCachePlugin().apply(compiler);

	if (options.ignoreWarnings && options.ignoreWarnings.length > 0) {
	const IgnoreWarningsPlugin = require("./IgnoreWarningsPlugin");
	new IgnoreWarningsPlugin(options.ignoreWarnings).apply(compiler);
	}

	compiler.hooks.afterPlugins.call(compiler);
	if (!compiler.inputFileSystem) {
	throw new Error("No input filesystem provided");
	}
	compiler.resolverFactory.hooks.resolveOptions
	.for("normal")
	.tap("WebpackOptionsApply", resolveOptions => {
	resolveOptions = cleverMerge(options.resolve, resolveOptions);
	resolveOptions.fileSystem = compiler.inputFileSystem;
	return resolveOptions;
	});
	compiler.resolverFactory.hooks.resolveOptions
	.for("context")
	.tap("WebpackOptionsApply", resolveOptions => {
	resolveOptions = cleverMerge(options.resolve, resolveOptions);
	resolveOptions.fileSystem = compiler.inputFileSystem;
	resolveOptions.resolveToContext = true;
	return resolveOptions;
	});
	compiler.resolverFactory.hooks.resolveOptions
	.for("loader")
	.tap("WebpackOptionsApply", resolveOptions => {
	resolveOptions = cleverMerge(options.resolveLoader, resolveOptions);
	resolveOptions.fileSystem = compiler.inputFileSystem;
	return resolveOptions;
	});
	compiler.hooks.afterResolvers.call(compiler);
	return options;
	}
	}

	module.exports = WebpackOptionsApply;

WebpackOptionsApply.jsNo OneTemporaryActions

File Metadata

WebpackOptionsApply.jsView Options

Event Timeline

WebpackOptionsApply.js
No OneTemporary
Actions

WebpackOptionsApply.js
View Options