webpack/lib/resolve/IgnorePlugin.js

Packs ECMAScript/CommonJs/AMD modules for the browser. Allows you to split your codebase into multiple bundles, which can be loaded on demand. Supports loaders to preprocess files, i.e. json, jsx, es7, css, less, ... and your custom stuff.

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

"use strict";

const isDependencyKind = require("../graph/isDependencyKind");
const RawModule = require("../module/RawModule");

/** @import Compiler from "../Compiler" */
/** @import { ResolveData } from "../module/NormalModuleFactory" */
/** @import { BeforeContextResolveData } from "../context/ContextModuleFactory" */

/**
 * @inline
 * @tsType import('./IgnorePlugin').CheckResourceFn
 * @typedef {(resource: string, context: string) => boolean} CheckResourceFn
 */

/**
 * @inline
 * @typedef {object} IgnorePluginPatternOptions
 * @property {RegExp=} contextRegExp A RegExp to test the context (directory) against.
 * @property {RegExp} resourceRegExp A RegExp to test the request against.
 */

/**
 * @inline
 * @typedef {object} IgnorePluginCheckOptions
 * @property {CheckResourceFn} checkResource A filter function for resource and context.
 */

/**
 * @schema plugins/IgnorePlugin
 * @typedef {IgnorePluginPatternOptions | IgnorePluginCheckOptions} IgnorePluginOptions
 */

const PLUGIN_NAME = "IgnorePlugin";

class IgnorePlugin {
	/**
	 * Creates an instance of IgnorePlugin.
	 * @param {IgnorePluginOptions} options IgnorePlugin options
	 */
	constructor(options) {
		/** @type {IgnorePluginOptions} */
		this.options = options;
		this.checkIgnore = this.checkIgnore.bind(this);
	}

	/**
	 * Note that if "contextRegExp" is given, both the "resourceRegExp" and "contextRegExp" have to match.
	 * @param {ResolveData | BeforeContextResolveData} resolveData resolve data
	 * @returns {false | undefined} returns false when the request should be ignored, otherwise undefined
	 */
	checkIgnore(resolveData) {
		if (
			"checkResource" in this.options &&
			this.options.checkResource &&
			this.options.checkResource(resolveData.request, resolveData.context)
		) {
			return false;
		}

		if (
			"resourceRegExp" in this.options &&
			this.options.resourceRegExp &&
			this.options.resourceRegExp.test(resolveData.request)
		) {
			if ("contextRegExp" in this.options && this.options.contextRegExp) {
				// if "contextRegExp" is given,
				// both the "resourceRegExp" and "contextRegExp" have to match.
				if (this.options.contextRegExp.test(resolveData.context)) {
					return false;
				}
			} else {
				return false;
			}
		}
	}

	/**
	 * Applies the plugin by registering its hooks on the compiler.
	 * @param {Compiler} compiler the compiler instance
	 * @returns {void}
	 */
	apply(compiler) {
		compiler.hooks.validate.tap(PLUGIN_NAME, () => {
			compiler.validate(
				require("../../schemas/plugins/IgnorePlugin.json"),
				this.options,
				{
					name: "Ignore Plugin",
					baseDataPath: "options"
				},
				(options) =>
					require("../../schemas/plugins/IgnorePlugin.check")(options)
			);
		});

		compiler.hooks.normalModuleFactory.tap(PLUGIN_NAME, (nmf) => {
			nmf.hooks.beforeResolve.tap(PLUGIN_NAME, (resolveData) => {
				const result = this.checkIgnore(resolveData);

				if (
					result === false &&
					resolveData.dependencies.length > 0 &&
					isDependencyKind(resolveData.dependencies[0], "entry")
				) {
					const module = new RawModule(
						"",
						"ignored-entry-module",
						"(ignored-entry-module)"
					);
					module.factoryMeta = { sideEffectFree: true };

					resolveData.ignoredModule = module;
				}

				return result;
			});
		});
		compiler.hooks.contextModuleFactory.tap(PLUGIN_NAME, (cmf) => {
			cmf.hooks.beforeResolve.tap(PLUGIN_NAME, this.checkIgnore);
		});
	}
}

module.exports = IgnorePlugin;