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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
/*
    MIT License http://www.opensource.org/licenses/mit-license.php
    Author Tobias Koppers @sokra
*/
"use strict";
 
const Generator = require("../Generator");
const WebAssemblyExportImportedDependency = require("../dependencies/WebAssemblyExportImportedDependency");
const WebAssemblyImportDependency = require("../dependencies/WebAssemblyImportDependency");
const WebAssemblyInInitialChunkError = require("./WebAssemblyInInitialChunkError");
 
/** @typedef {import("../Compiler")} Compiler */
 
let WebAssemblyGenerator;
let WebAssemblyJavascriptGenerator;
let WebAssemblyParser;
 
class WebAssemblyModulesPlugin {
    constructor(options) {
        this.options = options;
    }
 
    /**
     * @param {Compiler} compiler compiler
     * @returns {void}
     */
    apply(compiler) {
        compiler.hooks.compilation.tap(
            "WebAssemblyModulesPlugin",
            (compilation, { normalModuleFactory }) => {
                compilation.dependencyFactories.set(
                    WebAssemblyImportDependency,
                    normalModuleFactory
                );
 
                compilation.dependencyFactories.set(
                    WebAssemblyExportImportedDependency,
                    normalModuleFactory
                );
 
                normalModuleFactory.hooks.createParser
                    .for("webassembly/experimental")
                    .tap("WebAssemblyModulesPlugin", () => {
                        if (WebAssemblyParser === undefined) {
                            WebAssemblyParser = require("./WebAssemblyParser");
                        }
                        return new WebAssemblyParser();
                    });
 
                normalModuleFactory.hooks.createGenerator
                    .for("webassembly/experimental")
                    .tap("WebAssemblyModulesPlugin", () => {
                        if (WebAssemblyGenerator === undefined) {
                            WebAssemblyGenerator = require("./WebAssemblyGenerator");
                        }
                        if (WebAssemblyJavascriptGenerator === undefined) {
                            WebAssemblyJavascriptGenerator = require("./WebAssemblyJavascriptGenerator");
                        }
                        return Generator.byType({
                            javascript: new WebAssemblyJavascriptGenerator(),
                            webassembly: new WebAssemblyGenerator(this.options)
                        });
                    });
 
                compilation.chunkTemplate.hooks.renderManifest.tap(
                    "WebAssemblyModulesPlugin",
                    (result, options) => {
                        const chunk = options.chunk;
                        const outputOptions = options.outputOptions;
                        const moduleTemplates = options.moduleTemplates;
                        const dependencyTemplates = options.dependencyTemplates;
 
                        for (const module of chunk.modulesIterable) {
                            if (module.type && module.type.startsWith("webassembly")) {
                                const filenameTemplate =
                                    outputOptions.webassemblyModuleFilename;
 
                                result.push({
                                    render: () =>
                                        this.renderWebAssembly(
                                            module,
                                            moduleTemplates.webassembly,
                                            dependencyTemplates
                                        ),
                                    filenameTemplate,
                                    pathOptions: {
                                        module
                                    },
                                    identifier: `webassemblyModule${module.id}`,
                                    hash: module.hash
                                });
                            }
                        }
 
                        return result;
                    }
                );
 
                compilation.hooks.afterChunks.tap("WebAssemblyModulesPlugin", () => {
                    const initialWasmModules = new Set();
                    for (const chunk of compilation.chunks) {
                        if (chunk.canBeInitial()) {
                            for (const module of chunk.modulesIterable) {
                                if (module.type.startsWith("webassembly")) {
                                    initialWasmModules.add(module);
                                }
                            }
                        }
                    }
                    for (const module of initialWasmModules) {
                        compilation.errors.push(
                            new WebAssemblyInInitialChunkError(
                                module,
                                compilation.requestShortener
                            )
                        );
                    }
                });
            }
        );
    }
 
    renderWebAssembly(module, moduleTemplate, dependencyTemplates) {
        return moduleTemplate.render(module, dependencyTemplates, {});
    }
}
 
module.exports = WebAssemblyModulesPlugin;