source control 1.1

Tomas

2022-05-19 957a1f10a06fdbb76f1a0ba94fe44126c613fee3

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
82
83
84
85
86
87
88
89
90
91
92
93
94
95
/*
    MIT License http://www.opensource.org/licenses/mit-license.php
    Author Tobias Koppers @sokra
*/
"use strict";
 
const DelegatedModule = require("./DelegatedModule");
 
// options.source
// options.type
// options.context
// options.scope
// options.content
class DelegatedModuleFactoryPlugin {
    constructor(options) {
        this.options = options;
        options.type = options.type || "require";
        options.extensions = options.extensions || [
            "",
            ".wasm",
            ".mjs",
            ".js",
            ".json"
        ];
    }
 
    apply(normalModuleFactory) {
        const scope = this.options.scope;
        if (scope) {
            normalModuleFactory.hooks.factory.tap(
                "DelegatedModuleFactoryPlugin",
                factory => (data, callback) => {
                    const dependency = data.dependencies[0];
                    const request = dependency.request;
                    if (request && request.indexOf(scope + "/") === 0) {
                        const innerRequest = "." + request.substr(scope.length);
                        let resolved;
                        if (innerRequest in this.options.content) {
                            resolved = this.options.content[innerRequest];
                            return callback(
                                null,
                                new DelegatedModule(
                                    this.options.source,
                                    resolved,
                                    this.options.type,
                                    innerRequest,
                                    request
                                )
                            );
                        }
                        for (let i = 0; i < this.options.extensions.length; i++) {
                            const extension = this.options.extensions[i];
                            const requestPlusExt = innerRequest + extension;
                            if (requestPlusExt in this.options.content) {
                                resolved = this.options.content[requestPlusExt];
                                return callback(
                                    null,
                                    new DelegatedModule(
                                        this.options.source,
                                        resolved,
                                        this.options.type,
                                        requestPlusExt,
                                        request + extension
                                    )
                                );
                            }
                        }
                    }
                    return factory(data, callback);
                }
            );
        } else {
            normalModuleFactory.hooks.module.tap(
                "DelegatedModuleFactoryPlugin",
                module => {
                    if (module.libIdent) {
                        const request = module.libIdent(this.options);
                        if (request && request in this.options.content) {
                            const resolved = this.options.content[request];
                            return new DelegatedModule(
                                this.options.source,
                                resolved,
                                this.options.type,
                                request,
                                module
                            );
                        }
                    }
                    return module;
                }
            );
        }
    }
}
module.exports = DelegatedModuleFactoryPlugin;