初始化

cnf

2025-05-10 386fa0eca75ddc88165f9b73038f2a2239e1072e

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
/*
    MIT License http://www.opensource.org/licenses/mit-license.php
*/
 
"use strict";
 
const RuntimeGlobals = require("../RuntimeGlobals");
const RuntimeModule = require("../RuntimeModule");
const Template = require("../Template");
 
/** @typedef {import("../Compilation")} Compilation */
/** @typedef {import("../Module").ReadOnlyRuntimeRequirements} ReadOnlyRuntimeRequirements */
 
class EnsureChunkRuntimeModule extends RuntimeModule {
    /**
     * @param {ReadOnlyRuntimeRequirements} runtimeRequirements runtime requirements
     */
    constructor(runtimeRequirements) {
        super("ensure chunk");
        this.runtimeRequirements = runtimeRequirements;
    }
 
    /**
     * @returns {string | null} runtime code
     */
    generate() {
        const compilation = /** @type {Compilation} */ (this.compilation);
        const { runtimeTemplate } = compilation;
        // Check if there are non initial chunks which need to be imported using require-ensure
        if (this.runtimeRequirements.has(RuntimeGlobals.ensureChunkHandlers)) {
            const withFetchPriority = this.runtimeRequirements.has(
                RuntimeGlobals.hasFetchPriority
            );
            const handlers = RuntimeGlobals.ensureChunkHandlers;
            return Template.asString([
                `${handlers} = {};`,
                "// This file contains only the entry chunk.",
                "// The chunk loading function for additional chunks",
                `${RuntimeGlobals.ensureChunk} = ${runtimeTemplate.basicFunction(
                    `chunkId${withFetchPriority ? ", fetchPriority" : ""}`,
                    [
                        `return Promise.all(Object.keys(${handlers}).reduce(${runtimeTemplate.basicFunction(
                            "promises, key",
                            [
                                `${handlers}[key](chunkId, promises${
                                    withFetchPriority ? ", fetchPriority" : ""
                                });`,
                                "return promises;"
                            ]
                        )}, []));`
                    ]
                )};`
            ]);
        }
        // There ensureChunk is used somewhere in the tree, so we need an empty requireEnsure
        // function. This can happen with multiple entrypoints.
        return Template.asString([
            "// The chunk loading function for additional chunks",
            "// Since all referenced chunks are already included",
            "// in this file, this function is empty here.",
            `${RuntimeGlobals.ensureChunk} = ${runtimeTemplate.returningFunction(
                "Promise.resolve()"
            )};`
        ]);
    }
}
 
module.exports = EnsureChunkRuntimeModule;