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
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
/*
    MIT License http://www.opensource.org/licenses/mit-license.php
    Author Tobias Koppers @sokra
*/
 
"use strict";
 
const { WEBASSEMBLY_MODULE_TYPE_ASYNC } = require("../ModuleTypeConstants");
const RuntimeGlobals = require("../RuntimeGlobals");
const Template = require("../Template");
const AsyncWasmLoadingRuntimeModule = require("../wasm-async/AsyncWasmLoadingRuntimeModule");
 
/** @typedef {import("../Chunk")} Chunk */
/** @typedef {import("../Compiler")} Compiler */
 
class ReadFileCompileAsyncWasmPlugin {
    constructor({ type = "async-node", import: useImport = false } = {}) {
        this._type = type;
        this._import = useImport;
    }
    /**
     * Apply the plugin
     * @param {Compiler} compiler the compiler instance
     * @returns {void}
     */
    apply(compiler) {
        compiler.hooks.thisCompilation.tap(
            "ReadFileCompileAsyncWasmPlugin",
            compilation => {
                const globalWasmLoading = compilation.outputOptions.wasmLoading;
                /**
                 * @param {Chunk} chunk chunk
                 * @returns {boolean} true, if wasm loading is enabled for the chunk
                 */
                const isEnabledForChunk = chunk => {
                    const options = chunk.getEntryOptions();
                    const wasmLoading =
                        options && options.wasmLoading !== undefined
                            ? options.wasmLoading
                            : globalWasmLoading;
                    return wasmLoading === this._type;
                };
                /**
                 * @type {(path: string) => string}
                 */
                const generateLoadBinaryCode = this._import
                    ? path =>
                            Template.asString([
                                "Promise.all([import('fs'), import('url')]).then(([{ readFile }, { URL }]) => new Promise((resolve, reject) => {",
                                Template.indent([
                                    `readFile(new URL(${path}, import.meta.url), (err, buffer) => {`,
                                    Template.indent([
                                        "if (err) return reject(err);",
                                        "",
                                        "// Fake fetch response",
                                        "resolve({",
                                        Template.indent(["arrayBuffer() { return buffer; }"]),
                                        "});"
                                    ]),
                                    "});"
                                ]),
                                "}))"
                            ])
                    : path =>
                            Template.asString([
                                "new Promise(function (resolve, reject) {",
                                Template.indent([
                                    "try {",
                                    Template.indent([
                                        "var { readFile } = require('fs');",
                                        "var { join } = require('path');",
                                        "",
                                        `readFile(join(__dirname, ${path}), function(err, buffer){`,
                                        Template.indent([
                                            "if (err) return reject(err);",
                                            "",
                                            "// Fake fetch response",
                                            "resolve({",
                                            Template.indent(["arrayBuffer() { return buffer; }"]),
                                            "});"
                                        ]),
                                        "});"
                                    ]),
                                    "} catch (err) { reject(err); }"
                                ]),
                                "})"
                            ]);
 
                compilation.hooks.runtimeRequirementInTree
                    .for(RuntimeGlobals.instantiateWasm)
                    .tap("ReadFileCompileAsyncWasmPlugin", (chunk, set) => {
                        if (!isEnabledForChunk(chunk)) return;
                        const chunkGraph = compilation.chunkGraph;
                        if (
                            !chunkGraph.hasModuleInGraph(
                                chunk,
                                m => m.type === WEBASSEMBLY_MODULE_TYPE_ASYNC
                            )
                        ) {
                            return;
                        }
                        set.add(RuntimeGlobals.publicPath);
                        compilation.addRuntimeModule(
                            chunk,
                            new AsyncWasmLoadingRuntimeModule({
                                generateLoadBinaryCode,
                                supportsStreaming: false
                            })
                        );
                    });
            }
        );
    }
}
 
module.exports = ReadFileCompileAsyncWasmPlugin;