init

马宇豪

2024-07-16 f591c27b57e2418c9495bc02ae8cfff84d35bc18

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
70
71
72
73
74
75
76
77
78
79
80
81
/*
    MIT License http://www.opensource.org/licenses/mit-license.php
    Author Tobias Koppers @sokra
*/
 
"use strict";
 
const ModuleFilenameHelpers = require("./ModuleFilenameHelpers");
const NormalModule = require("./NormalModule");
const createSchemaValidation = require("./util/create-schema-validation");
 
/** @typedef {import("../declarations/plugins/LoaderOptionsPlugin").LoaderOptionsPluginOptions} LoaderOptionsPluginOptions */
/** @typedef {import("./Compiler")} Compiler */
/** @typedef {import("./ModuleFilenameHelpers").MatchObject} MatchObject  */
 
const validate = createSchemaValidation(
    require("../schemas/plugins/LoaderOptionsPlugin.check.js"),
    () => require("../schemas/plugins/LoaderOptionsPlugin.json"),
    {
        name: "Loader Options Plugin",
        baseDataPath: "options"
    }
);
 
class LoaderOptionsPlugin {
    /**
     * @param {LoaderOptionsPluginOptions & MatchObject} options options object
     */
    constructor(options = {}) {
        validate(options);
        // If no options are set then generate empty options object
        if (typeof options !== "object") options = {};
        if (!options.test) {
            // This is mocking a RegExp object which always returns true
            // TODO: Figure out how to do `as unknown as RegExp` for this line
            // in JSDoc equivalent
            /** @type {any} */
            const defaultTrueMockRegExp = {
                test: () => true
            };
 
            /** @type {RegExp} */
            options.test = defaultTrueMockRegExp;
        }
        this.options = options;
    }
 
    /**
     * Apply the plugin
     * @param {Compiler} compiler the compiler instance
     * @returns {void}
     */
    apply(compiler) {
        const options = this.options;
        compiler.hooks.compilation.tap("LoaderOptionsPlugin", compilation => {
            NormalModule.getCompilationHooks(compilation).loader.tap(
                "LoaderOptionsPlugin",
                (context, module) => {
                    const resource = module.resource;
                    if (!resource) return;
                    const i = resource.indexOf("?");
                    if (
                        ModuleFilenameHelpers.matchObject(
                            options,
                            i < 0 ? resource : resource.slice(0, i)
                        )
                    ) {
                        for (const key of Object.keys(options)) {
                            if (key === "include" || key === "exclude" || key === "test") {
                                continue;
                            }
                            context[key] = options[key];
                        }
                    }
                }
            );
        });
    }
}
 
module.exports = LoaderOptionsPlugin;