node-ejs-renderer/node_modules/webpack/lib/dependencies/AMDRequireDependenciesBlockParserPlugin.js

405 lines
12 KiB
JavaScript
Raw Normal View History

2024-06-09 13:55:01 -04:00
/*
MIT License http://www.opensource.org/licenses/mit-license.php
Author Tobias Koppers @sokra
*/
"use strict";
const RuntimeGlobals = require("../RuntimeGlobals");
const UnsupportedFeatureWarning = require("../UnsupportedFeatureWarning");
const AMDRequireArrayDependency = require("./AMDRequireArrayDependency");
const AMDRequireContextDependency = require("./AMDRequireContextDependency");
const AMDRequireDependenciesBlock = require("./AMDRequireDependenciesBlock");
const AMDRequireDependency = require("./AMDRequireDependency");
const AMDRequireItemDependency = require("./AMDRequireItemDependency");
const ConstDependency = require("./ConstDependency");
const ContextDependencyHelpers = require("./ContextDependencyHelpers");
const LocalModuleDependency = require("./LocalModuleDependency");
const { getLocalModule } = require("./LocalModulesHelpers");
const UnsupportedDependency = require("./UnsupportedDependency");
const getFunctionExpression = require("./getFunctionExpression");
/** @typedef {import("estree").CallExpression} CallExpression */
/** @typedef {import("estree").Expression} Expression */
/** @typedef {import("estree").Identifier} Identifier */
/** @typedef {import("estree").SourceLocation} SourceLocation */
/** @typedef {import("estree").SpreadElement} SpreadElement */
/** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
/** @typedef {import("../Module").BuildInfo} BuildInfo */
/** @typedef {import("../javascript/BasicEvaluatedExpression")} BasicEvaluatedExpression */
/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
/** @typedef {import("../javascript/JavascriptParser").Range} Range */
class AMDRequireDependenciesBlockParserPlugin {
/**
* @param {JavascriptParserOptions} options parserOptions
*/
constructor(options) {
this.options = options;
}
/**
* @param {JavascriptParser} parser the parser
* @param {Expression | SpreadElement} expression expression
* @returns {boolean} need bind this
*/
processFunctionArgument(parser, expression) {
let bindThis = true;
const fnData = getFunctionExpression(expression);
if (fnData) {
parser.inScope(
fnData.fn.params.filter(i => {
return !["require", "module", "exports"].includes(
/** @type {Identifier} */ (i).name
);
}),
() => {
if (fnData.fn.body.type === "BlockStatement") {
parser.walkStatement(fnData.fn.body);
} else {
parser.walkExpression(fnData.fn.body);
}
}
);
parser.walkExpressions(fnData.expressions);
if (fnData.needThis === false) {
bindThis = false;
}
} else {
parser.walkExpression(expression);
}
return bindThis;
}
/**
* @param {JavascriptParser} parser the parser
* @returns {void}
*/
apply(parser) {
parser.hooks.call
.for("require")
.tap(
"AMDRequireDependenciesBlockParserPlugin",
this.processCallRequire.bind(this, parser)
);
}
/**
* @param {JavascriptParser} parser the parser
* @param {CallExpression} expr call expression
* @param {BasicEvaluatedExpression} param param
* @returns {boolean | undefined} result
*/
processArray(parser, expr, param) {
if (param.isArray()) {
for (const p of /** @type {BasicEvaluatedExpression[]} */ (param.items)) {
const result = this.processItem(parser, expr, p);
if (result === undefined) {
this.processContext(parser, expr, p);
}
}
return true;
} else if (param.isConstArray()) {
/** @type {(string | LocalModuleDependency | AMDRequireItemDependency)[]} */
const deps = [];
for (const request of /** @type {any[]} */ (param.array)) {
let dep, localModule;
if (request === "require") {
dep = RuntimeGlobals.require;
} else if (["exports", "module"].includes(request)) {
dep = request;
} else if ((localModule = getLocalModule(parser.state, request))) {
localModule.flagUsed();
dep = new LocalModuleDependency(localModule, undefined, false);
dep.loc = /** @type {DependencyLocation} */ (expr.loc);
parser.state.module.addPresentationalDependency(dep);
} else {
dep = this.newRequireItemDependency(request);
dep.loc = /** @type {DependencyLocation} */ (expr.loc);
dep.optional = !!parser.scope.inTry;
parser.state.current.addDependency(dep);
}
deps.push(dep);
}
const dep = this.newRequireArrayDependency(
deps,
/** @type {Range} */ (param.range)
);
dep.loc = /** @type {DependencyLocation} */ (expr.loc);
dep.optional = !!parser.scope.inTry;
parser.state.module.addPresentationalDependency(dep);
return true;
}
}
/**
* @param {JavascriptParser} parser the parser
* @param {CallExpression} expr call expression
* @param {BasicEvaluatedExpression} param param
* @returns {boolean | undefined} result
*/
processItem(parser, expr, param) {
if (param.isConditional()) {
for (const p of /** @type {BasicEvaluatedExpression[]} */ (
param.options
)) {
const result = this.processItem(parser, expr, p);
if (result === undefined) {
this.processContext(parser, expr, p);
}
}
return true;
} else if (param.isString()) {
let dep, localModule;
if (param.string === "require") {
dep = new ConstDependency(
RuntimeGlobals.require,
/** @type {TODO} */ (param.string),
[RuntimeGlobals.require]
);
} else if (param.string === "module") {
dep = new ConstDependency(
/** @type {BuildInfo} */
(parser.state.module.buildInfo).moduleArgument,
/** @type {Range} */ (param.range),
[RuntimeGlobals.module]
);
} else if (param.string === "exports") {
dep = new ConstDependency(
/** @type {BuildInfo} */
(parser.state.module.buildInfo).exportsArgument,
/** @type {Range} */ (param.range),
[RuntimeGlobals.exports]
);
} else if (
(localModule = getLocalModule(
parser.state,
/** @type {string} */ (param.string)
))
) {
localModule.flagUsed();
dep = new LocalModuleDependency(localModule, param.range, false);
} else {
dep = this.newRequireItemDependency(
/** @type {string} */ (param.string),
param.range
);
dep.loc = /** @type {DependencyLocation} */ (expr.loc);
dep.optional = !!parser.scope.inTry;
parser.state.current.addDependency(dep);
return true;
}
dep.loc = /** @type {DependencyLocation} */ (expr.loc);
parser.state.module.addPresentationalDependency(dep);
return true;
}
}
/**
* @param {JavascriptParser} parser the parser
* @param {CallExpression} expr call expression
* @param {BasicEvaluatedExpression} param param
* @returns {boolean | undefined} result
*/
processContext(parser, expr, param) {
const dep = ContextDependencyHelpers.create(
AMDRequireContextDependency,
/** @type {Range} */ (param.range),
param,
expr,
this.options,
{
category: "amd"
},
parser
);
if (!dep) return;
dep.loc = /** @type {DependencyLocation} */ (expr.loc);
dep.optional = !!parser.scope.inTry;
parser.state.current.addDependency(dep);
return true;
}
/**
* @param {BasicEvaluatedExpression} param param
* @returns {string | undefined} result
*/
processArrayForRequestString(param) {
if (param.isArray()) {
const result =
/** @type {BasicEvaluatedExpression[]} */
(param.items).map(item => this.processItemForRequestString(item));
if (result.every(Boolean)) return result.join(" ");
} else if (param.isConstArray()) {
return /** @type {string[]} */ (param.array).join(" ");
}
}
/**
* @param {BasicEvaluatedExpression} param param
* @returns {string | undefined} result
*/
processItemForRequestString(param) {
if (param.isConditional()) {
const result =
/** @type {BasicEvaluatedExpression[]} */
(param.options).map(item => this.processItemForRequestString(item));
if (result.every(Boolean)) return result.join("|");
} else if (param.isString()) {
return param.string;
}
}
/**
* @param {JavascriptParser} parser the parser
* @param {CallExpression} expr call expression
* @returns {boolean | undefined} result
*/
processCallRequire(parser, expr) {
/** @type {BasicEvaluatedExpression | undefined} */
let param;
/** @type {AMDRequireDependenciesBlock | undefined | null} */
let depBlock;
/** @type {AMDRequireDependency | undefined} */
let dep;
/** @type {boolean | undefined} */
let result;
const old = parser.state.current;
if (expr.arguments.length >= 1) {
param = parser.evaluateExpression(expr.arguments[0]);
depBlock = this.newRequireDependenciesBlock(
/** @type {DependencyLocation} */ (expr.loc),
/** @type {string} */ (this.processArrayForRequestString(param))
);
dep = this.newRequireDependency(
/** @type {Range} */ (expr.range),
/** @type {Range} */ (param.range),
expr.arguments.length > 1
? /** @type {Range} */ (expr.arguments[1].range)
: null,
expr.arguments.length > 2
? /** @type {Range} */ (expr.arguments[2].range)
: null
);
dep.loc = /** @type {DependencyLocation} */ (expr.loc);
depBlock.addDependency(dep);
parser.state.current = /** @type {TODO} */ (depBlock);
}
if (expr.arguments.length === 1) {
parser.inScope([], () => {
result = this.processArray(
parser,
expr,
/** @type {BasicEvaluatedExpression} */ (param)
);
});
parser.state.current = old;
if (!result) return;
parser.state.current.addBlock(
/** @type {AMDRequireDependenciesBlock} */ (depBlock)
);
return true;
}
if (expr.arguments.length === 2 || expr.arguments.length === 3) {
try {
parser.inScope([], () => {
result = this.processArray(
parser,
expr,
/** @type {BasicEvaluatedExpression} */ (param)
);
});
if (!result) {
const dep = new UnsupportedDependency(
"unsupported",
/** @type {Range} */ (expr.range)
);
old.addPresentationalDependency(dep);
if (parser.state.module) {
parser.state.module.addError(
new UnsupportedFeatureWarning(
"Cannot statically analyse 'require(…, …)' in line " +
/** @type {SourceLocation} */ (expr.loc).start.line,
/** @type {DependencyLocation} */ (expr.loc)
)
);
}
depBlock = null;
return true;
}
/** @type {AMDRequireDependency} */
(dep).functionBindThis = this.processFunctionArgument(
parser,
expr.arguments[1]
);
if (expr.arguments.length === 3) {
/** @type {AMDRequireDependency} */
(dep).errorCallbackBindThis = this.processFunctionArgument(
parser,
expr.arguments[2]
);
}
} finally {
parser.state.current = old;
if (depBlock) parser.state.current.addBlock(depBlock);
}
return true;
}
}
/**
* @param {DependencyLocation} loc location
* @param {string} request request
* @returns {AMDRequireDependenciesBlock} AMDRequireDependenciesBlock
*/
newRequireDependenciesBlock(loc, request) {
return new AMDRequireDependenciesBlock(loc, request);
}
/**
* @param {Range} outerRange outer range
* @param {Range} arrayRange array range
* @param {Range | null} functionRange function range
* @param {Range | null} errorCallbackRange error callback range
* @returns {AMDRequireDependency} dependency
*/
newRequireDependency(
outerRange,
arrayRange,
functionRange,
errorCallbackRange
) {
return new AMDRequireDependency(
outerRange,
arrayRange,
functionRange,
errorCallbackRange
);
}
/**
* @param {string} request request
* @param {Range=} range range
* @returns {AMDRequireItemDependency} AMDRequireItemDependency
*/
newRequireItemDependency(request, range) {
return new AMDRequireItemDependency(request, range);
}
/**
* @param {(string | LocalModuleDependency | AMDRequireItemDependency)[]} depsArray deps array
* @param {Range} range range
* @returns {AMDRequireArrayDependency} AMDRequireArrayDependency
*/
newRequireArrayDependency(depsArray, range) {
return new AMDRequireArrayDependency(depsArray, range);
}
}
module.exports = AMDRequireDependenciesBlockParserPlugin;