啊鑫
8 天以前 fca192d3c38c5dcfbb6ace8bc71d6078f6a079b2
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
/*
    MIT License http://www.opensource.org/licenses/mit-license.php
    Author Tobias Koppers @sokra
*/
 
"use strict";
 
const RequireContextDependency = require("./RequireContextDependency");
 
/** @typedef {import("../ContextModule").ContextMode} ContextMode */
/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
/** @typedef {import("../javascript/JavascriptParser").Range} Range */
 
const PLUGIN_NAME = "RequireContextDependencyParserPlugin";
 
module.exports = class RequireContextDependencyParserPlugin {
    /**
     * @param {JavascriptParser} parser the parser
     * @returns {void}
     */
    apply(parser) {
        parser.hooks.call.for("require.context").tap(PLUGIN_NAME, expr => {
            let regExp = /^\.\/.*$/;
            let recursive = true;
            /** @type {ContextMode} */
            let mode = "sync";
            switch (expr.arguments.length) {
                case 4: {
                    const modeExpr = parser.evaluateExpression(expr.arguments[3]);
                    if (!modeExpr.isString()) return;
                    mode = /** @type {ContextMode} */ (modeExpr.string);
                }
                // falls through
                case 3: {
                    const regExpExpr = parser.evaluateExpression(expr.arguments[2]);
                    if (!regExpExpr.isRegExp()) return;
                    regExp = /** @type {RegExp} */ (regExpExpr.regExp);
                }
                // falls through
                case 2: {
                    const recursiveExpr = parser.evaluateExpression(expr.arguments[1]);
                    if (!recursiveExpr.isBoolean()) return;
                    recursive = /** @type {boolean} */ (recursiveExpr.bool);
                }
                // falls through
                case 1: {
                    const requestExpr = parser.evaluateExpression(expr.arguments[0]);
                    if (!requestExpr.isString()) return;
                    const dep = new RequireContextDependency(
                        {
                            request: /** @type {string} */ (requestExpr.string),
                            recursive,
                            regExp,
                            mode,
                            category: "commonjs"
                        },
                        /** @type {Range} */
                        (expr.range)
                    );
                    dep.loc = /** @type {DependencyLocation} */ (expr.loc);
                    dep.optional = Boolean(parser.scope.inTry);
                    parser.state.current.addDependency(dep);
                    return true;
                }
            }
        });
    }
};