:测试提交“

qx

2025-08-06 fe97f78b9a343ee9fa45a3531d03d73dcd1df31b

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
/*
    MIT License http://www.opensource.org/licenses/mit-license.php
    Author Tobias Koppers @sokra
*/
 
"use strict";
 
const { STAGE_BASIC } = require("../OptimizationStages");
 
/** @typedef {import("../Chunk")} Chunk */
/** @typedef {import("../ChunkGroup")} ChunkGroup */
/** @typedef {import("../Compiler")} Compiler */
 
const PLUGIN_NAME = "EnsureChunkConditionsPlugin";
 
class EnsureChunkConditionsPlugin {
    /**
     * Apply the plugin
     * @param {Compiler} compiler the compiler instance
     * @returns {void}
     */
    apply(compiler) {
        compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
            /**
             * @param {Iterable<Chunk>} chunks the chunks
             */
            const handler = (chunks) => {
                const chunkGraph = compilation.chunkGraph;
                // These sets are hoisted here to save memory
                // They are cleared at the end of every loop
                /** @type {Set<Chunk>} */
                const sourceChunks = new Set();
                /** @type {Set<ChunkGroup>} */
                const chunkGroups = new Set();
                for (const module of compilation.modules) {
                    if (!module.hasChunkCondition()) continue;
                    for (const chunk of chunkGraph.getModuleChunksIterable(module)) {
                        if (!module.chunkCondition(chunk, compilation)) {
                            sourceChunks.add(chunk);
                            for (const group of chunk.groupsIterable) {
                                chunkGroups.add(group);
                            }
                        }
                    }
                    if (sourceChunks.size === 0) continue;
                    /** @type {Set<Chunk>} */
                    const targetChunks = new Set();
                    chunkGroupLoop: for (const chunkGroup of chunkGroups) {
                        // Can module be placed in a chunk of this group?
                        for (const chunk of chunkGroup.chunks) {
                            if (module.chunkCondition(chunk, compilation)) {
                                targetChunks.add(chunk);
                                continue chunkGroupLoop;
                            }
                        }
                        // We reached the entrypoint: fail
                        if (chunkGroup.isInitial()) {
                            throw new Error(
                                `Cannot fulfil chunk condition of ${module.identifier()}`
                            );
                        }
                        // Try placing in all parents
                        for (const group of chunkGroup.parentsIterable) {
                            chunkGroups.add(group);
                        }
                    }
                    for (const sourceChunk of sourceChunks) {
                        chunkGraph.disconnectChunkAndModule(sourceChunk, module);
                    }
                    for (const targetChunk of targetChunks) {
                        chunkGraph.connectChunkAndModule(targetChunk, module);
                    }
                    sourceChunks.clear();
                    chunkGroups.clear();
                }
            };
            compilation.hooks.optimizeChunks.tap(
                {
                    name: PLUGIN_NAME,
                    stage: STAGE_BASIC
                },
                handler
            );
        });
    }
}
 
module.exports = EnsureChunkConditionsPlugin;