W260426/14.webpack/node_modules/webpack/lib/dependencies/RequireEnsureDependenciesBlockParserPlugin.js

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

"use strict";

const RequireEnsureDependenciesBlock = require("./RequireEnsureDependenciesBlock");
const RequireEnsureDependency = require("./RequireEnsureDependency");
const RequireEnsureItemDependency = require("./RequireEnsureItemDependency");
const getFunctionExpression = require("./getFunctionExpression");

/** @import { Expression, SpreadElement } from "estree" */
/** @import { GroupOptions } from "../AsyncDependenciesBlock" */
/** @import BasicEvaluatedExpression from "../javascript/BasicEvaluatedExpression" */
/** @import JavascriptParser, { Range } from "../javascript/JavascriptParser" */
/** @import { FunctionExpressionResult } from "./getFunctionExpression" */

const PLUGIN_NAME = "RequireEnsureDependenciesBlockParserPlugin";

module.exports = class RequireEnsureDependenciesBlockParserPlugin {
	/**
	 * Applies the plugin by registering its hooks on the compiler.
	 * @param {JavascriptParser} parser the parser
	 * @returns {void}
	 */
	apply(parser) {
		parser.hooks.call.for("require.ensure").tap(PLUGIN_NAME, (expr) => {
			/** @type {string | GroupOptions | null} */
			let chunkName = null;
			/** @type {undefined | Expression | SpreadElement} */
			let errorExpressionArg;
			/** @type {undefined | FunctionExpressionResult} */
			let errorExpression;
			switch (expr.arguments.length) {
				case 4: {
					const chunkNameExpr = parser.evaluateExpression(expr.arguments[3]);
					if (!chunkNameExpr.isString()) return;
					chunkName =
						/** @type {string} */
						(chunkNameExpr.string);
				}
				// falls through
				case 3: {
					errorExpressionArg = expr.arguments[2];
					errorExpression = getFunctionExpression(errorExpressionArg);

					if (!errorExpression && !chunkName) {
						const chunkNameExpr = parser.evaluateExpression(expr.arguments[2]);
						if (!chunkNameExpr.isString()) return;
						chunkName =
							/** @type {string} */
							(chunkNameExpr.string);
					}
				}
				// falls through
				case 2: {
					const dependenciesExpr = parser.evaluateExpression(expr.arguments[0]);
					const dependenciesItems = /** @type {BasicEvaluatedExpression[]} */ (
						dependenciesExpr.isArray()
							? dependenciesExpr.items
							: [dependenciesExpr]
					);
					const successExpressionArg = expr.arguments[1];
					const successExpression = getFunctionExpression(successExpressionArg);

					if (successExpression) {
						parser.walkExpressions(successExpression.expressions);
					}
					if (errorExpression) {
						parser.walkExpressions(errorExpression.expressions);
					}

					const depBlock = new RequireEnsureDependenciesBlock(
						chunkName,
						parser.getLocation(expr)
					);
					const errorCallbackExists =
						expr.arguments.length === 4 ||
						(!chunkName && expr.arguments.length === 3);
					const dep = new RequireEnsureDependency(
						/** @type {Range} */ (expr.range),
						/** @type {Range} */ (expr.arguments[1].range),
						errorCallbackExists &&
							/** @type {Range} */ (expr.arguments[2].range)
					);
					dep.loc = parser.getLocation(expr);
					depBlock.addDependency(dep);
					const old = parser.state.current;
					parser.state.current = /** @type {EXPECTED_ANY} */ (depBlock);
					try {
						let failed = false;
						parser.inFunctionScope(true, [], () => {
							for (const ee of dependenciesItems) {
								if (ee.isString()) {
									const ensureDependency = new RequireEnsureItemDependency(
										/** @type {string} */ (ee.string)
									);
									ensureDependency.loc = parser.getLocation(expr);
									depBlock.addDependency(ensureDependency);
								} else {
									failed = true;
								}
							}
						});
						if (failed) {
							return;
						}
						if (successExpression) {
							if (successExpression.fn.body.type === "BlockStatement") {
								// Opt-out of Dead Control Flow detection for this block
								const oldTerminated = parser.scope.terminated;
								parser.walkStatement(successExpression.fn.body);
								parser.scope.terminated = oldTerminated;
							} else {
								parser.walkExpression(successExpression.fn.body);
							}
						}
						old.addBlock(depBlock);
					} finally {
						parser.state.current = old;
					}
					if (!successExpression) {
						parser.walkExpression(successExpressionArg);
					}
					if (errorExpression) {
						if (errorExpression.fn.body.type === "BlockStatement") {
							parser.walkStatement(errorExpression.fn.body);
						} else {
							parser.walkExpression(errorExpression.fn.body);
						}
					} else if (errorExpressionArg) {
						parser.walkExpression(errorExpressionArg);
					}
					return true;
				}
			}
		});
	}
};