1 |
|
2 |
|
3 |
|
4 |
|
5 |
|
6 | "use strict";
|
7 |
|
8 | const AsyncDependencyToInitialChunkError = require("./AsyncDependencyToInitialChunkError");
|
9 | const { connectChunkGroupParentAndChild } = require("./GraphHelpers");
|
10 | const ModuleGraphConnection = require("./ModuleGraphConnection");
|
11 | const { getEntryRuntime, mergeRuntime } = require("./util/runtime");
|
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 | const EMPTY_SET = (new Set());
|
62 | EMPTY_SET.plus = EMPTY_SET;
|
63 |
|
64 |
|
65 |
|
66 |
|
67 |
|
68 |
|
69 | const bySetSize = (a, b) => {
|
70 | return b.size + b.plus.size - a.size - a.plus.size;
|
71 | };
|
72 |
|
73 |
|
74 |
|
75 |
|
76 |
|
77 |
|
78 |
|
79 | const getActiveStateOfConnections = (connections, runtime) => {
|
80 | let merged = connections[0].getActiveState(runtime);
|
81 | if (merged === true) return true;
|
82 | for (let i = 1; i < connections.length; i++) {
|
83 | const c = connections[i];
|
84 | merged = ModuleGraphConnection.addConnectionStates(
|
85 | merged,
|
86 | c.getActiveState(runtime)
|
87 | );
|
88 | if (merged === true) return true;
|
89 | }
|
90 | return merged;
|
91 | };
|
92 |
|
93 |
|
94 |
|
95 |
|
96 |
|
97 |
|
98 | const extractBlockModulesMap = compilation => {
|
99 | const { moduleGraph } = compilation;
|
100 |
|
101 |
|
102 | const blockModulesMap = new Map();
|
103 |
|
104 | const blockQueue = new Set();
|
105 |
|
106 | for (const module of compilation.modules) {
|
107 |
|
108 | let moduleMap;
|
109 |
|
110 | for (const connection of moduleGraph.getOutgoingConnections(module)) {
|
111 | const d = connection.dependency;
|
112 |
|
113 | if (!d) continue;
|
114 | const m = connection.module;
|
115 |
|
116 | if (!m) continue;
|
117 |
|
118 | if (connection.weak) continue;
|
119 | const state = connection.getActiveState(undefined);
|
120 |
|
121 | if (state === false) continue;
|
122 |
|
123 |
|
124 |
|
125 | if (moduleMap === undefined) {
|
126 | moduleMap = new WeakMap();
|
127 | }
|
128 | moduleMap.set(connection.dependency, connection);
|
129 | }
|
130 |
|
131 | blockQueue.clear();
|
132 | blockQueue.add(module);
|
133 | for (const block of blockQueue) {
|
134 | let modules;
|
135 |
|
136 | if (moduleMap !== undefined && block.dependencies) {
|
137 | for (const dep of block.dependencies) {
|
138 | const connection = moduleMap.get(dep);
|
139 | if (connection !== undefined) {
|
140 | const { module } = connection;
|
141 | if (modules === undefined) {
|
142 | modules = new Map();
|
143 | blockModulesMap.set(block, modules);
|
144 | }
|
145 | const old = modules.get(module);
|
146 | if (old !== undefined) {
|
147 | old.push(connection);
|
148 | } else {
|
149 | modules.set(module, [connection]);
|
150 | }
|
151 | }
|
152 | }
|
153 | }
|
154 |
|
155 | if (block.blocks) {
|
156 | for (const b of block.blocks) {
|
157 | blockQueue.add(b);
|
158 | }
|
159 | }
|
160 | }
|
161 | }
|
162 |
|
163 | return blockModulesMap;
|
164 | };
|
165 |
|
166 |
|
167 |
|
168 |
|
169 |
|
170 |
|
171 |
|
172 |
|
173 |
|
174 |
|
175 |
|
176 | const visitModules = (
|
177 | logger,
|
178 | compilation,
|
179 | inputEntrypointsAndModules,
|
180 | chunkGroupInfoMap,
|
181 | blockConnections,
|
182 | blocksWithNestedBlocks,
|
183 | allCreatedChunkGroups
|
184 | ) => {
|
185 | const { moduleGraph, chunkGraph } = compilation;
|
186 |
|
187 | logger.time("visitModules: prepare");
|
188 | const blockModulesMap = extractBlockModulesMap(compilation);
|
189 |
|
190 | let statProcessedQueueItems = 0;
|
191 | let statProcessedBlocks = 0;
|
192 | let statConnectedChunkGroups = 0;
|
193 | let statProcessedChunkGroupsForMerging = 0;
|
194 | let statMergedAvailableModuleSets = 0;
|
195 | let statForkedAvailableModules = 0;
|
196 | let statForkedAvailableModulesCount = 0;
|
197 | let statForkedAvailableModulesCountPlus = 0;
|
198 | let statForkedMergedModulesCount = 0;
|
199 | let statForkedMergedModulesCountPlus = 0;
|
200 | let statForkedResultModulesCount = 0;
|
201 | let statChunkGroupInfoUpdated = 0;
|
202 | let statChildChunkGroupsReconnected = 0;
|
203 |
|
204 | let nextChunkGroupIndex = 0;
|
205 | let nextFreeModulePreOrderIndex = 0;
|
206 | let nextFreeModulePostOrderIndex = 0;
|
207 |
|
208 |
|
209 | const blockChunkGroups = new Map();
|
210 |
|
211 |
|
212 | const namedChunkGroups = new Map();
|
213 |
|
214 |
|
215 | const namedAsyncEntrypoints = new Map();
|
216 |
|
217 | const ADD_AND_ENTER_ENTRY_MODULE = 0;
|
218 | const ADD_AND_ENTER_MODULE = 1;
|
219 | const ENTER_MODULE = 2;
|
220 | const PROCESS_BLOCK = 3;
|
221 | const PROCESS_ENTRY_BLOCK = 4;
|
222 | const LEAVE_MODULE = 5;
|
223 |
|
224 |
|
225 | let queue = [];
|
226 |
|
227 |
|
228 | const queueConnect = new Map();
|
229 |
|
230 | const chunkGroupsForCombining = new Set();
|
231 |
|
232 |
|
233 |
|
234 | for (const [chunkGroup, modules] of inputEntrypointsAndModules) {
|
235 | const runtime = getEntryRuntime(
|
236 | compilation,
|
237 | chunkGroup.name,
|
238 | chunkGroup.options
|
239 | );
|
240 |
|
241 | const chunkGroupInfo = {
|
242 | chunkGroup,
|
243 | runtime,
|
244 | minAvailableModules: undefined,
|
245 | minAvailableModulesOwned: false,
|
246 | availableModulesToBeMerged: [],
|
247 | skippedItems: undefined,
|
248 | resultingAvailableModules: undefined,
|
249 | children: undefined,
|
250 | availableSources: undefined,
|
251 | availableChildren: undefined,
|
252 | preOrderIndex: 0,
|
253 | postOrderIndex: 0
|
254 | };
|
255 | chunkGroup.index = nextChunkGroupIndex++;
|
256 | if (chunkGroup.getNumberOfParents() > 0) {
|
257 |
|
258 |
|
259 |
|
260 | const skippedItems = new Set();
|
261 | for (const module of modules) {
|
262 | skippedItems.add(module);
|
263 | }
|
264 | chunkGroupInfo.skippedItems = skippedItems;
|
265 | chunkGroupsForCombining.add(chunkGroupInfo);
|
266 | } else {
|
267 |
|
268 | chunkGroupInfo.minAvailableModules = EMPTY_SET;
|
269 | const chunk = chunkGroup.getEntrypointChunk();
|
270 | for (const module of modules) {
|
271 | queue.push({
|
272 | action: ADD_AND_ENTER_MODULE,
|
273 | block: module,
|
274 | module,
|
275 | chunk,
|
276 | chunkGroup,
|
277 | chunkGroupInfo
|
278 | });
|
279 | }
|
280 | }
|
281 | chunkGroupInfoMap.set(chunkGroup, chunkGroupInfo);
|
282 | if (chunkGroup.name) {
|
283 | namedChunkGroups.set(chunkGroup.name, chunkGroupInfo);
|
284 | }
|
285 | }
|
286 |
|
287 | for (const chunkGroupInfo of chunkGroupsForCombining) {
|
288 | const { chunkGroup } = chunkGroupInfo;
|
289 | chunkGroupInfo.availableSources = new Set();
|
290 | for (const parent of chunkGroup.parentsIterable) {
|
291 | const parentChunkGroupInfo = chunkGroupInfoMap.get(parent);
|
292 | chunkGroupInfo.availableSources.add(parentChunkGroupInfo);
|
293 | if (parentChunkGroupInfo.availableChildren === undefined) {
|
294 | parentChunkGroupInfo.availableChildren = new Set();
|
295 | }
|
296 | parentChunkGroupInfo.availableChildren.add(chunkGroupInfo);
|
297 | }
|
298 | }
|
299 |
|
300 |
|
301 |
|
302 | queue.reverse();
|
303 |
|
304 |
|
305 | const outdatedChunkGroupInfo = new Set();
|
306 |
|
307 | const chunkGroupsForMerging = new Set();
|
308 |
|
309 | let queueDelayed = [];
|
310 |
|
311 | logger.timeEnd("visitModules: prepare");
|
312 |
|
313 |
|
314 | const skipConnectionBuffer = [];
|
315 |
|
316 | const skipBuffer = [];
|
317 |
|
318 | const queueBuffer = [];
|
319 |
|
320 |
|
321 | let module;
|
322 |
|
323 | let chunk;
|
324 |
|
325 | let chunkGroup;
|
326 |
|
327 | let block;
|
328 |
|
329 | let chunkGroupInfo;
|
330 |
|
331 |
|
332 | |
333 |
|
334 |
|
335 |
|
336 | const iteratorBlock = b => {
|
337 |
|
338 |
|
339 | let cgi = blockChunkGroups.get(b);
|
340 |
|
341 | let c;
|
342 |
|
343 | let entrypoint;
|
344 | const entryOptions = b.groupOptions && b.groupOptions.entryOptions;
|
345 | if (cgi === undefined) {
|
346 | const chunkName = (b.groupOptions && b.groupOptions.name) || b.chunkName;
|
347 | if (entryOptions) {
|
348 | cgi = namedAsyncEntrypoints.get(chunkName);
|
349 | if (!cgi) {
|
350 | entrypoint = compilation.addAsyncEntrypoint(
|
351 | entryOptions,
|
352 | module,
|
353 | b.loc,
|
354 | b.request
|
355 | );
|
356 | entrypoint.index = nextChunkGroupIndex++;
|
357 | cgi = {
|
358 | chunkGroup: entrypoint,
|
359 | runtime: entrypoint.options.runtime || entrypoint.name,
|
360 | minAvailableModules: EMPTY_SET,
|
361 | minAvailableModulesOwned: false,
|
362 | availableModulesToBeMerged: [],
|
363 | skippedItems: undefined,
|
364 | resultingAvailableModules: undefined,
|
365 | children: undefined,
|
366 | availableSources: undefined,
|
367 | availableChildren: undefined,
|
368 | preOrderIndex: 0,
|
369 | postOrderIndex: 0
|
370 | };
|
371 | chunkGroupInfoMap.set(entrypoint, cgi);
|
372 |
|
373 | chunkGraph.connectBlockAndChunkGroup(b, entrypoint);
|
374 | if (chunkName) {
|
375 | namedAsyncEntrypoints.set(chunkName, cgi);
|
376 | }
|
377 | } else {
|
378 | entrypoint = (cgi.chunkGroup);
|
379 |
|
380 | entrypoint.addOrigin(module, b.loc, b.request);
|
381 | chunkGraph.connectBlockAndChunkGroup(b, entrypoint);
|
382 | }
|
383 |
|
384 |
|
385 | queueDelayed.push({
|
386 | action: PROCESS_ENTRY_BLOCK,
|
387 | block: b,
|
388 | module: module,
|
389 | chunk: entrypoint.chunks[0],
|
390 | chunkGroup: entrypoint,
|
391 | chunkGroupInfo: cgi
|
392 | });
|
393 | } else {
|
394 | cgi = namedChunkGroups.get(chunkName);
|
395 | if (!cgi) {
|
396 | c = compilation.addChunkInGroup(
|
397 | b.groupOptions || b.chunkName,
|
398 | module,
|
399 | b.loc,
|
400 | b.request
|
401 | );
|
402 | c.index = nextChunkGroupIndex++;
|
403 | cgi = {
|
404 | chunkGroup: c,
|
405 | runtime: chunkGroupInfo.runtime,
|
406 | minAvailableModules: undefined,
|
407 | minAvailableModulesOwned: undefined,
|
408 | availableModulesToBeMerged: [],
|
409 | skippedItems: undefined,
|
410 | resultingAvailableModules: undefined,
|
411 | children: undefined,
|
412 | availableSources: undefined,
|
413 | availableChildren: undefined,
|
414 | preOrderIndex: 0,
|
415 | postOrderIndex: 0
|
416 | };
|
417 | allCreatedChunkGroups.add(c);
|
418 | chunkGroupInfoMap.set(c, cgi);
|
419 | if (chunkName) {
|
420 | namedChunkGroups.set(chunkName, cgi);
|
421 | }
|
422 | } else {
|
423 | c = cgi.chunkGroup;
|
424 | if (c.isInitial()) {
|
425 | compilation.errors.push(
|
426 | new AsyncDependencyToInitialChunkError(chunkName, module, b.loc)
|
427 | );
|
428 | c = chunkGroup;
|
429 | }
|
430 | c.addOptions(b.groupOptions);
|
431 | c.addOrigin(module, b.loc, b.request);
|
432 | }
|
433 | blockConnections.set(b, []);
|
434 | }
|
435 | blockChunkGroups.set(b, cgi);
|
436 | } else if (entryOptions) {
|
437 | entrypoint = (cgi.chunkGroup);
|
438 | } else {
|
439 | c = cgi.chunkGroup;
|
440 | }
|
441 |
|
442 | if (c !== undefined) {
|
443 |
|
444 |
|
445 | blockConnections.get(b).push({
|
446 | originChunkGroupInfo: chunkGroupInfo,
|
447 | chunkGroup: c
|
448 | });
|
449 |
|
450 |
|
451 | let connectList = queueConnect.get(chunkGroupInfo);
|
452 | if (connectList === undefined) {
|
453 | connectList = new Set();
|
454 | queueConnect.set(chunkGroupInfo, connectList);
|
455 | }
|
456 | connectList.add(cgi);
|
457 |
|
458 |
|
459 |
|
460 |
|
461 | queueDelayed.push({
|
462 | action: PROCESS_BLOCK,
|
463 | block: b,
|
464 | module: module,
|
465 | chunk: c.chunks[0],
|
466 | chunkGroup: c,
|
467 | chunkGroupInfo: cgi
|
468 | });
|
469 | } else {
|
470 | chunkGroupInfo.chunkGroup.addAsyncEntrypoint(entrypoint);
|
471 | }
|
472 | };
|
473 |
|
474 | |
475 |
|
476 |
|
477 |
|
478 | const processBlock = block => {
|
479 | statProcessedBlocks++;
|
480 |
|
481 | const blockModules = blockModulesMap.get(block);
|
482 |
|
483 | if (blockModules !== undefined) {
|
484 | const { minAvailableModules, runtime } = chunkGroupInfo;
|
485 |
|
486 |
|
487 | for (const entry of blockModules) {
|
488 | const [refModule, connections] = entry;
|
489 | if (chunkGraph.isModuleInChunk(refModule, chunk)) {
|
490 |
|
491 | continue;
|
492 | }
|
493 | const activeState = getActiveStateOfConnections(connections, runtime);
|
494 | if (activeState !== true) {
|
495 | skipConnectionBuffer.push(entry);
|
496 | if (activeState === false) continue;
|
497 | }
|
498 | if (
|
499 | activeState === true &&
|
500 | (minAvailableModules.has(refModule) ||
|
501 | minAvailableModules.plus.has(refModule))
|
502 | ) {
|
503 |
|
504 | skipBuffer.push(refModule);
|
505 | continue;
|
506 | }
|
507 |
|
508 |
|
509 | queueBuffer.push({
|
510 | action: activeState === true ? ADD_AND_ENTER_MODULE : PROCESS_BLOCK,
|
511 | block: refModule,
|
512 | module: refModule,
|
513 | chunk,
|
514 | chunkGroup,
|
515 | chunkGroupInfo
|
516 | });
|
517 | }
|
518 |
|
519 | if (skipConnectionBuffer.length > 0) {
|
520 | let { skippedModuleConnections } = chunkGroupInfo;
|
521 | if (skippedModuleConnections === undefined) {
|
522 | chunkGroupInfo.skippedModuleConnections = skippedModuleConnections = new Set();
|
523 | }
|
524 | for (let i = skipConnectionBuffer.length - 1; i >= 0; i--) {
|
525 | skippedModuleConnections.add(skipConnectionBuffer[i]);
|
526 | }
|
527 | skipConnectionBuffer.length = 0;
|
528 | }
|
529 | if (skipBuffer.length > 0) {
|
530 | let { skippedItems } = chunkGroupInfo;
|
531 | if (skippedItems === undefined) {
|
532 | chunkGroupInfo.skippedItems = skippedItems = new Set();
|
533 | }
|
534 | for (let i = skipBuffer.length - 1; i >= 0; i--) {
|
535 | skippedItems.add(skipBuffer[i]);
|
536 | }
|
537 | skipBuffer.length = 0;
|
538 | }
|
539 | if (queueBuffer.length > 0) {
|
540 | for (let i = queueBuffer.length - 1; i >= 0; i--) {
|
541 | queue.push(queueBuffer[i]);
|
542 | }
|
543 | queueBuffer.length = 0;
|
544 | }
|
545 | }
|
546 |
|
547 |
|
548 | for (const b of block.blocks) {
|
549 | iteratorBlock(b);
|
550 | }
|
551 |
|
552 | if (block.blocks.length > 0 && module !== block) {
|
553 | blocksWithNestedBlocks.add(block);
|
554 | }
|
555 | };
|
556 |
|
557 | |
558 |
|
559 |
|
560 |
|
561 | const processEntryBlock = block => {
|
562 | statProcessedBlocks++;
|
563 |
|
564 | const blockModules = blockModulesMap.get(block);
|
565 |
|
566 | if (blockModules !== undefined) {
|
567 |
|
568 | for (const [refModule, connections] of blockModules) {
|
569 | const activeState = getActiveStateOfConnections(connections, undefined);
|
570 |
|
571 |
|
572 | queueBuffer.push({
|
573 | action:
|
574 | activeState === true ? ADD_AND_ENTER_ENTRY_MODULE : PROCESS_BLOCK,
|
575 | block: refModule,
|
576 | module: refModule,
|
577 | chunk,
|
578 | chunkGroup,
|
579 | chunkGroupInfo
|
580 | });
|
581 | }
|
582 |
|
583 | if (queueBuffer.length > 0) {
|
584 | for (let i = queueBuffer.length - 1; i >= 0; i--) {
|
585 | queue.push(queueBuffer[i]);
|
586 | }
|
587 | queueBuffer.length = 0;
|
588 | }
|
589 | }
|
590 |
|
591 |
|
592 | for (const b of block.blocks) {
|
593 | iteratorBlock(b);
|
594 | }
|
595 |
|
596 | if (block.blocks.length > 0 && module !== block) {
|
597 | blocksWithNestedBlocks.add(block);
|
598 | }
|
599 | };
|
600 |
|
601 | const processQueue = () => {
|
602 | while (queue.length) {
|
603 | statProcessedQueueItems++;
|
604 | const queueItem = queue.pop();
|
605 | module = queueItem.module;
|
606 | block = queueItem.block;
|
607 | chunk = queueItem.chunk;
|
608 | chunkGroup = queueItem.chunkGroup;
|
609 | chunkGroupInfo = queueItem.chunkGroupInfo;
|
610 |
|
611 | switch (queueItem.action) {
|
612 | case ADD_AND_ENTER_ENTRY_MODULE:
|
613 | chunkGraph.connectChunkAndEntryModule(
|
614 | chunk,
|
615 | module,
|
616 | (chunkGroup)
|
617 | );
|
618 |
|
619 | case ADD_AND_ENTER_MODULE: {
|
620 | if (chunkGraph.isModuleInChunk(module, chunk)) {
|
621 |
|
622 | break;
|
623 | }
|
624 |
|
625 | chunkGraph.connectChunkAndModule(chunk, module);
|
626 | }
|
627 |
|
628 | case ENTER_MODULE: {
|
629 | const index = chunkGroup.getModulePreOrderIndex(module);
|
630 | if (index === undefined) {
|
631 | chunkGroup.setModulePreOrderIndex(
|
632 | module,
|
633 | chunkGroupInfo.preOrderIndex++
|
634 | );
|
635 | }
|
636 |
|
637 | if (
|
638 | moduleGraph.setPreOrderIndexIfUnset(
|
639 | module,
|
640 | nextFreeModulePreOrderIndex
|
641 | )
|
642 | ) {
|
643 | nextFreeModulePreOrderIndex++;
|
644 | }
|
645 |
|
646 |
|
647 | queueItem.action = LEAVE_MODULE;
|
648 | queue.push(queueItem);
|
649 | }
|
650 |
|
651 | case PROCESS_BLOCK: {
|
652 | processBlock(block);
|
653 | break;
|
654 | }
|
655 | case PROCESS_ENTRY_BLOCK: {
|
656 | processEntryBlock(block);
|
657 | break;
|
658 | }
|
659 | case LEAVE_MODULE: {
|
660 | const index = chunkGroup.getModulePostOrderIndex(module);
|
661 | if (index === undefined) {
|
662 | chunkGroup.setModulePostOrderIndex(
|
663 | module,
|
664 | chunkGroupInfo.postOrderIndex++
|
665 | );
|
666 | }
|
667 |
|
668 | if (
|
669 | moduleGraph.setPostOrderIndexIfUnset(
|
670 | module,
|
671 | nextFreeModulePostOrderIndex
|
672 | )
|
673 | ) {
|
674 | nextFreeModulePostOrderIndex++;
|
675 | }
|
676 | break;
|
677 | }
|
678 | }
|
679 | }
|
680 | };
|
681 |
|
682 | const calculateResultingAvailableModules = chunkGroupInfo => {
|
683 | if (chunkGroupInfo.resultingAvailableModules)
|
684 | return chunkGroupInfo.resultingAvailableModules;
|
685 |
|
686 | const minAvailableModules = chunkGroupInfo.minAvailableModules;
|
687 |
|
688 |
|
689 |
|
690 |
|
691 |
|
692 |
|
693 |
|
694 |
|
695 | let resultingAvailableModules;
|
696 | if (minAvailableModules.size > minAvailableModules.plus.size) {
|
697 |
|
698 | resultingAvailableModules = (new Set());
|
699 | for (const module of minAvailableModules.plus)
|
700 | minAvailableModules.add(module);
|
701 | minAvailableModules.plus = EMPTY_SET;
|
702 | resultingAvailableModules.plus = minAvailableModules;
|
703 | chunkGroupInfo.minAvailableModulesOwned = false;
|
704 | } else {
|
705 |
|
706 | resultingAvailableModules = (new Set(
|
707 | minAvailableModules
|
708 | ));
|
709 | resultingAvailableModules.plus = minAvailableModules.plus;
|
710 | }
|
711 |
|
712 |
|
713 | for (const chunk of chunkGroupInfo.chunkGroup.chunks) {
|
714 | for (const m of chunkGraph.getChunkModulesIterable(chunk)) {
|
715 | resultingAvailableModules.add(m);
|
716 | }
|
717 | }
|
718 | return (chunkGroupInfo.resultingAvailableModules = resultingAvailableModules);
|
719 | };
|
720 |
|
721 | const processConnectQueue = () => {
|
722 |
|
723 |
|
724 | for (const [chunkGroupInfo, targets] of queueConnect) {
|
725 |
|
726 | if (chunkGroupInfo.children === undefined) {
|
727 | chunkGroupInfo.children = targets;
|
728 | } else {
|
729 | for (const target of targets) {
|
730 | chunkGroupInfo.children.add(target);
|
731 | }
|
732 | }
|
733 |
|
734 |
|
735 | const resultingAvailableModules = calculateResultingAvailableModules(
|
736 | chunkGroupInfo
|
737 | );
|
738 |
|
739 | const runtime = chunkGroupInfo.runtime;
|
740 |
|
741 |
|
742 | for (const target of targets) {
|
743 | target.availableModulesToBeMerged.push(resultingAvailableModules);
|
744 | chunkGroupsForMerging.add(target);
|
745 | const oldRuntime = target.runtime;
|
746 | const newRuntime = mergeRuntime(oldRuntime, runtime);
|
747 | if (oldRuntime !== newRuntime) {
|
748 | target.runtime = newRuntime;
|
749 | outdatedChunkGroupInfo.add(target);
|
750 | }
|
751 | }
|
752 |
|
753 | statConnectedChunkGroups += targets.size;
|
754 | }
|
755 | queueConnect.clear();
|
756 | };
|
757 |
|
758 | const processChunkGroupsForMerging = () => {
|
759 | statProcessedChunkGroupsForMerging += chunkGroupsForMerging.size;
|
760 |
|
761 |
|
762 | for (const info of chunkGroupsForMerging) {
|
763 | const availableModulesToBeMerged = info.availableModulesToBeMerged;
|
764 | let cachedMinAvailableModules = info.minAvailableModules;
|
765 |
|
766 | statMergedAvailableModuleSets += availableModulesToBeMerged.length;
|
767 |
|
768 |
|
769 |
|
770 |
|
771 |
|
772 | if (availableModulesToBeMerged.length > 1) {
|
773 | availableModulesToBeMerged.sort(bySetSize);
|
774 | }
|
775 | let changed = false;
|
776 | merge: for (const availableModules of availableModulesToBeMerged) {
|
777 | if (cachedMinAvailableModules === undefined) {
|
778 | cachedMinAvailableModules = availableModules;
|
779 | info.minAvailableModules = cachedMinAvailableModules;
|
780 | info.minAvailableModulesOwned = false;
|
781 | changed = true;
|
782 | } else {
|
783 | if (info.minAvailableModulesOwned) {
|
784 |
|
785 | if (cachedMinAvailableModules.plus === availableModules.plus) {
|
786 | for (const m of cachedMinAvailableModules) {
|
787 | if (!availableModules.has(m)) {
|
788 | cachedMinAvailableModules.delete(m);
|
789 | changed = true;
|
790 | }
|
791 | }
|
792 | } else {
|
793 | for (const m of cachedMinAvailableModules) {
|
794 | if (!availableModules.has(m) && !availableModules.plus.has(m)) {
|
795 | cachedMinAvailableModules.delete(m);
|
796 | changed = true;
|
797 | }
|
798 | }
|
799 | for (const m of cachedMinAvailableModules.plus) {
|
800 | if (!availableModules.has(m) && !availableModules.plus.has(m)) {
|
801 |
|
802 |
|
803 | const iterator = cachedMinAvailableModules.plus[
|
804 | Symbol.iterator
|
805 | ]();
|
806 |
|
807 |
|
808 | let it;
|
809 | while (!(it = iterator.next()).done) {
|
810 | const module = it.value;
|
811 | if (module === m) break;
|
812 | cachedMinAvailableModules.add(module);
|
813 | }
|
814 |
|
815 | while (!(it = iterator.next()).done) {
|
816 | const module = it.value;
|
817 | if (
|
818 | availableModules.has(module) ||
|
819 | availableModules.plus.has(m)
|
820 | ) {
|
821 | cachedMinAvailableModules.add(module);
|
822 | }
|
823 | }
|
824 | cachedMinAvailableModules.plus = EMPTY_SET;
|
825 | changed = true;
|
826 | continue merge;
|
827 | }
|
828 | }
|
829 | }
|
830 | } else if (cachedMinAvailableModules.plus === availableModules.plus) {
|
831 |
|
832 |
|
833 | if (availableModules.size < cachedMinAvailableModules.size) {
|
834 |
|
835 |
|
836 | statForkedAvailableModules++;
|
837 | statForkedAvailableModulesCount += availableModules.size;
|
838 | statForkedMergedModulesCount += cachedMinAvailableModules.size;
|
839 |
|
840 | const newSet = (new Set());
|
841 | newSet.plus = availableModules.plus;
|
842 | for (const m of availableModules) {
|
843 | if (cachedMinAvailableModules.has(m)) {
|
844 | newSet.add(m);
|
845 | }
|
846 | }
|
847 | statForkedResultModulesCount += newSet.size;
|
848 | cachedMinAvailableModules = newSet;
|
849 | info.minAvailableModulesOwned = true;
|
850 | info.minAvailableModules = newSet;
|
851 | changed = true;
|
852 | continue merge;
|
853 | }
|
854 | for (const m of cachedMinAvailableModules) {
|
855 | if (!availableModules.has(m)) {
|
856 |
|
857 |
|
858 | statForkedAvailableModules++;
|
859 | statForkedAvailableModulesCount +=
|
860 | cachedMinAvailableModules.size;
|
861 | statForkedMergedModulesCount += availableModules.size;
|
862 |
|
863 |
|
864 | const newSet = (new Set());
|
865 | newSet.plus = availableModules.plus;
|
866 | const iterator = cachedMinAvailableModules[Symbol.iterator]();
|
867 |
|
868 |
|
869 | let it;
|
870 | while (!(it = iterator.next()).done) {
|
871 | const module = it.value;
|
872 | if (module === m) break;
|
873 | newSet.add(module);
|
874 | }
|
875 |
|
876 | while (!(it = iterator.next()).done) {
|
877 | const module = it.value;
|
878 | if (availableModules.has(module)) {
|
879 | newSet.add(module);
|
880 | }
|
881 | }
|
882 | statForkedResultModulesCount += newSet.size;
|
883 | cachedMinAvailableModules = newSet;
|
884 | info.minAvailableModulesOwned = true;
|
885 | info.minAvailableModules = newSet;
|
886 | changed = true;
|
887 | continue merge;
|
888 | }
|
889 | }
|
890 | } else {
|
891 | for (const m of cachedMinAvailableModules) {
|
892 | if (!availableModules.has(m) && !availableModules.plus.has(m)) {
|
893 |
|
894 |
|
895 | statForkedAvailableModules++;
|
896 | statForkedAvailableModulesCount +=
|
897 | cachedMinAvailableModules.size;
|
898 | statForkedAvailableModulesCountPlus +=
|
899 | cachedMinAvailableModules.plus.size;
|
900 | statForkedMergedModulesCount += availableModules.size;
|
901 | statForkedMergedModulesCountPlus += availableModules.plus.size;
|
902 |
|
903 | const newSet = (new Set());
|
904 | newSet.plus = EMPTY_SET;
|
905 | const iterator = cachedMinAvailableModules[Symbol.iterator]();
|
906 |
|
907 |
|
908 | let it;
|
909 | while (!(it = iterator.next()).done) {
|
910 | const module = it.value;
|
911 | if (module === m) break;
|
912 | newSet.add(module);
|
913 | }
|
914 |
|
915 | while (!(it = iterator.next()).done) {
|
916 | const module = it.value;
|
917 | if (
|
918 | availableModules.has(module) ||
|
919 | availableModules.plus.has(module)
|
920 | ) {
|
921 | newSet.add(module);
|
922 | }
|
923 | }
|
924 |
|
925 | for (const module of cachedMinAvailableModules.plus) {
|
926 | if (
|
927 | availableModules.has(module) ||
|
928 | availableModules.plus.has(module)
|
929 | ) {
|
930 | newSet.add(module);
|
931 | }
|
932 | }
|
933 | statForkedResultModulesCount += newSet.size;
|
934 | cachedMinAvailableModules = newSet;
|
935 | info.minAvailableModulesOwned = true;
|
936 | info.minAvailableModules = newSet;
|
937 | changed = true;
|
938 | continue merge;
|
939 | }
|
940 | }
|
941 | for (const m of cachedMinAvailableModules.plus) {
|
942 | if (!availableModules.has(m) && !availableModules.plus.has(m)) {
|
943 |
|
944 |
|
945 | statForkedAvailableModules++;
|
946 | statForkedAvailableModulesCount +=
|
947 | cachedMinAvailableModules.size;
|
948 | statForkedAvailableModulesCountPlus +=
|
949 | cachedMinAvailableModules.plus.size;
|
950 | statForkedMergedModulesCount += availableModules.size;
|
951 | statForkedMergedModulesCountPlus += availableModules.plus.size;
|
952 |
|
953 |
|
954 | const newSet = (new Set(
|
955 | cachedMinAvailableModules
|
956 | ));
|
957 | newSet.plus = EMPTY_SET;
|
958 | const iterator = cachedMinAvailableModules.plus[
|
959 | Symbol.iterator
|
960 | ]();
|
961 |
|
962 |
|
963 | let it;
|
964 | while (!(it = iterator.next()).done) {
|
965 | const module = it.value;
|
966 | if (module === m) break;
|
967 | newSet.add(module);
|
968 | }
|
969 |
|
970 | while (!(it = iterator.next()).done) {
|
971 | const module = it.value;
|
972 | if (
|
973 | availableModules.has(module) ||
|
974 | availableModules.plus.has(module)
|
975 | ) {
|
976 | newSet.add(module);
|
977 | }
|
978 | }
|
979 | statForkedResultModulesCount += newSet.size;
|
980 | cachedMinAvailableModules = newSet;
|
981 | info.minAvailableModulesOwned = true;
|
982 | info.minAvailableModules = newSet;
|
983 | changed = true;
|
984 | continue merge;
|
985 | }
|
986 | }
|
987 | }
|
988 | }
|
989 | }
|
990 | availableModulesToBeMerged.length = 0;
|
991 | if (changed) {
|
992 | info.resultingAvailableModules = undefined;
|
993 | outdatedChunkGroupInfo.add(info);
|
994 | }
|
995 | }
|
996 | chunkGroupsForMerging.clear();
|
997 | };
|
998 |
|
999 | const processChunkGroupsForCombining = () => {
|
1000 | loop: for (const info of chunkGroupsForCombining) {
|
1001 | for (const source of info.availableSources) {
|
1002 | if (!source.minAvailableModules) continue loop;
|
1003 | }
|
1004 | const availableModules = (new Set());
|
1005 | availableModules.plus = EMPTY_SET;
|
1006 | const mergeSet = set => {
|
1007 | if (set.size > availableModules.plus.size) {
|
1008 | for (const item of availableModules.plus) availableModules.add(item);
|
1009 | availableModules.plus = set;
|
1010 | } else {
|
1011 | for (const item of set) availableModules.add(item);
|
1012 | }
|
1013 | };
|
1014 | // combine minAvailableModules from all resultingAvailableModules
|
1015 | for (const source of info.availableSources) {
|
1016 | const resultingAvailableModules = calculateResultingAvailableModules(
|
1017 | source
|
1018 | );
|
1019 | mergeSet(resultingAvailableModules);
|
1020 | mergeSet(resultingAvailableModules.plus);
|
1021 | }
|
1022 | info.minAvailableModules = availableModules;
|
1023 | info.minAvailableModulesOwned = false;
|
1024 | info.resultingAvailableModules = undefined;
|
1025 | outdatedChunkGroupInfo.add(info);
|
1026 | }
|
1027 | chunkGroupsForCombining.clear();
|
1028 | };
|
1029 |
|
1030 | const processOutdatedChunkGroupInfo = () => {
|
1031 | statChunkGroupInfoUpdated += outdatedChunkGroupInfo.size;
|
1032 |
|
1033 | for (const info of outdatedChunkGroupInfo) {
|
1034 |
|
1035 | if (info.skippedItems !== undefined) {
|
1036 | const { minAvailableModules } = info;
|
1037 | for (const module of info.skippedItems) {
|
1038 | if (
|
1039 | !minAvailableModules.has(module) &&
|
1040 | !minAvailableModules.plus.has(module)
|
1041 | ) {
|
1042 | queue.push({
|
1043 | action: ADD_AND_ENTER_MODULE,
|
1044 | block: module,
|
1045 | module,
|
1046 | chunk: info.chunkGroup.chunks[0],
|
1047 | chunkGroup: info.chunkGroup,
|
1048 | chunkGroupInfo: info
|
1049 | });
|
1050 | info.skippedItems.delete(module);
|
1051 | }
|
1052 | }
|
1053 | }
|
1054 |
|
1055 |
|
1056 | if (info.skippedModuleConnections !== undefined) {
|
1057 | const { minAvailableModules, runtime } = info;
|
1058 | for (const entry of info.skippedModuleConnections) {
|
1059 | const [module, connections] = entry;
|
1060 | const activeState = getActiveStateOfConnections(connections, runtime);
|
1061 | if (activeState === false) continue;
|
1062 | if (activeState === true) {
|
1063 | info.skippedModuleConnections.delete(entry);
|
1064 | }
|
1065 | if (
|
1066 | activeState === true &&
|
1067 | (minAvailableModules.has(module) ||
|
1068 | minAvailableModules.plus.has(module))
|
1069 | ) {
|
1070 | info.skippedItems.add(module);
|
1071 | continue;
|
1072 | }
|
1073 | queue.push({
|
1074 | action: activeState === true ? ADD_AND_ENTER_MODULE : PROCESS_BLOCK,
|
1075 | block: module,
|
1076 | module,
|
1077 | chunk: info.chunkGroup.chunks[0],
|
1078 | chunkGroup: info.chunkGroup,
|
1079 | chunkGroupInfo: info
|
1080 | });
|
1081 | }
|
1082 | }
|
1083 |
|
1084 |
|
1085 | if (info.children !== undefined) {
|
1086 | statChildChunkGroupsReconnected += info.children.size;
|
1087 | for (const cgi of info.children) {
|
1088 | let connectList = queueConnect.get(info);
|
1089 | if (connectList === undefined) {
|
1090 | connectList = new Set();
|
1091 | queueConnect.set(info, connectList);
|
1092 | }
|
1093 | connectList.add(cgi);
|
1094 | }
|
1095 | }
|
1096 |
|
1097 |
|
1098 | if (info.availableChildren !== undefined) {
|
1099 | for (const cgi of info.availableChildren) {
|
1100 | chunkGroupsForCombining.add(cgi);
|
1101 | }
|
1102 | }
|
1103 | }
|
1104 | outdatedChunkGroupInfo.clear();
|
1105 | };
|
1106 |
|
1107 |
|
1108 |
|
1109 | while (queue.length || queueConnect.size) {
|
1110 | logger.time("visitModules: visiting");
|
1111 | processQueue();
|
1112 | logger.timeEnd("visitModules: visiting");
|
1113 |
|
1114 | if (chunkGroupsForCombining.size > 0) {
|
1115 | logger.time("visitModules: combine available modules");
|
1116 | processChunkGroupsForCombining();
|
1117 | logger.timeEnd("visitModules: combine available modules");
|
1118 | }
|
1119 |
|
1120 | if (queueConnect.size > 0) {
|
1121 | logger.time("visitModules: calculating available modules");
|
1122 | processConnectQueue();
|
1123 | logger.timeEnd("visitModules: calculating available modules");
|
1124 |
|
1125 | if (chunkGroupsForMerging.size > 0) {
|
1126 | logger.time("visitModules: merging available modules");
|
1127 | processChunkGroupsForMerging();
|
1128 | logger.timeEnd("visitModules: merging available modules");
|
1129 | }
|
1130 | }
|
1131 |
|
1132 | if (outdatedChunkGroupInfo.size > 0) {
|
1133 | logger.time("visitModules: check modules for revisit");
|
1134 | processOutdatedChunkGroupInfo();
|
1135 | logger.timeEnd("visitModules: check modules for revisit");
|
1136 | }
|
1137 |
|
1138 |
|
1139 |
|
1140 |
|
1141 | if (queue.length === 0) {
|
1142 | const tempQueue = queue;
|
1143 | queue = queueDelayed.reverse();
|
1144 | queueDelayed = tempQueue;
|
1145 | }
|
1146 | }
|
1147 |
|
1148 | logger.log(
|
1149 | `${statProcessedQueueItems} queue items processed (${statProcessedBlocks} blocks)`
|
1150 | );
|
1151 | logger.log(`${statConnectedChunkGroups} chunk groups connected`);
|
1152 | logger.log(
|
1153 | `${statProcessedChunkGroupsForMerging} chunk groups processed for merging (${statMergedAvailableModuleSets} module sets, ${statForkedAvailableModules} forked, ${statForkedAvailableModulesCount} + ${statForkedAvailableModulesCountPlus} modules forked, ${statForkedMergedModulesCount} + ${statForkedMergedModulesCountPlus} modules merged into fork, ${statForkedResultModulesCount} resulting modules)`
|
1154 | );
|
1155 | logger.log(
|
1156 | `${statChunkGroupInfoUpdated} chunk group info updated (${statChildChunkGroupsReconnected} already connected chunk groups reconnected)`
|
1157 | );
|
1158 | };
|
1159 |
|
1160 |
|
1161 |
|
1162 |
|
1163 |
|
1164 |
|
1165 |
|
1166 |
|
1167 | const connectChunkGroups = (
|
1168 | compilation,
|
1169 | blocksWithNestedBlocks,
|
1170 | blockConnections,
|
1171 | chunkGroupInfoMap
|
1172 | ) => {
|
1173 | const { chunkGraph } = compilation;
|
1174 |
|
1175 | |
1176 |
|
1177 |
|
1178 |
|
1179 |
|
1180 |
|
1181 |
|
1182 | const areModulesAvailable = (chunkGroup, availableModules) => {
|
1183 | for (const chunk of chunkGroup.chunks) {
|
1184 | for (const module of chunkGraph.getChunkModulesIterable(chunk)) {
|
1185 | if (!availableModules.has(module) && !availableModules.plus.has(module))
|
1186 | return false;
|
1187 | }
|
1188 | }
|
1189 | return true;
|
1190 | };
|
1191 |
|
1192 |
|
1193 | for (const [block, connections] of blockConnections) {
|
1194 |
|
1195 |
|
1196 |
|
1197 |
|
1198 |
|
1199 |
|
1200 | if (
|
1201 |
|
1202 | !blocksWithNestedBlocks.has(block) &&
|
1203 | connections.every(({ chunkGroup, originChunkGroupInfo }) =>
|
1204 | areModulesAvailable(
|
1205 | chunkGroup,
|
1206 | originChunkGroupInfo.resultingAvailableModules
|
1207 | )
|
1208 | )
|
1209 | ) {
|
1210 | continue;
|
1211 | }
|
1212 |
|
1213 |
|
1214 | for (let i = 0; i < connections.length; i++) {
|
1215 | const { chunkGroup, originChunkGroupInfo } = connections[i];
|
1216 |
|
1217 |
|
1218 | chunkGraph.connectBlockAndChunkGroup(block, chunkGroup);
|
1219 |
|
1220 |
|
1221 | connectChunkGroupParentAndChild(
|
1222 | originChunkGroupInfo.chunkGroup,
|
1223 | chunkGroup
|
1224 | );
|
1225 | }
|
1226 | }
|
1227 | };
|
1228 |
|
1229 |
|
1230 |
|
1231 |
|
1232 |
|
1233 |
|
1234 | const cleanupUnconnectedGroups = (compilation, allCreatedChunkGroups) => {
|
1235 | const { chunkGraph } = compilation;
|
1236 |
|
1237 | for (const chunkGroup of allCreatedChunkGroups) {
|
1238 | if (chunkGroup.getNumberOfParents() === 0) {
|
1239 | for (const chunk of chunkGroup.chunks) {
|
1240 | compilation.chunks.delete(chunk);
|
1241 | chunkGraph.disconnectChunk(chunk);
|
1242 | }
|
1243 | chunkGraph.disconnectChunkGroup(chunkGroup);
|
1244 | chunkGroup.remove();
|
1245 | }
|
1246 | }
|
1247 | };
|
1248 |
|
1249 |
|
1250 |
|
1251 |
|
1252 |
|
1253 |
|
1254 |
|
1255 | const buildChunkGraph = (compilation, inputEntrypointsAndModules) => {
|
1256 | const logger = compilation.getLogger("webpack.buildChunkGraph");
|
1257 |
|
1258 |
|
1259 |
|
1260 |
|
1261 | const blockConnections = new Map();
|
1262 |
|
1263 |
|
1264 | const allCreatedChunkGroups = new Set();
|
1265 |
|
1266 |
|
1267 | const chunkGroupInfoMap = new Map();
|
1268 |
|
1269 |
|
1270 | const blocksWithNestedBlocks = new Set();
|
1271 |
|
1272 |
|
1273 |
|
1274 | logger.time("visitModules");
|
1275 | visitModules(
|
1276 | logger,
|
1277 | compilation,
|
1278 | inputEntrypointsAndModules,
|
1279 | chunkGroupInfoMap,
|
1280 | blockConnections,
|
1281 | blocksWithNestedBlocks,
|
1282 | allCreatedChunkGroups
|
1283 | );
|
1284 | logger.timeEnd("visitModules");
|
1285 |
|
1286 |
|
1287 |
|
1288 | logger.time("connectChunkGroups");
|
1289 | connectChunkGroups(
|
1290 | compilation,
|
1291 | blocksWithNestedBlocks,
|
1292 | blockConnections,
|
1293 | chunkGroupInfoMap
|
1294 | );
|
1295 | logger.timeEnd("connectChunkGroups");
|
1296 |
|
1297 | for (const [chunkGroup, chunkGroupInfo] of chunkGroupInfoMap) {
|
1298 | for (const chunk of chunkGroup.chunks)
|
1299 | chunk.runtime = mergeRuntime(chunk.runtime, chunkGroupInfo.runtime);
|
1300 | }
|
1301 |
|
1302 |
|
1303 |
|
1304 | logger.time("cleanup");
|
1305 | cleanupUnconnectedGroups(compilation, allCreatedChunkGroups);
|
1306 | logger.timeEnd("cleanup");
|
1307 | };
|
1308 |
|
1309 | module.exports = buildChunkGraph;
|