1 |
|
2 |
|
3 |
|
4 |
|
5 | "use strict";
|
6 |
|
7 | const util = require("util");
|
8 | const SortableSet = require("./util/SortableSet");
|
9 | const intersect = require("./util/SetHelpers").intersect;
|
10 | const GraphHelpers = require("./GraphHelpers");
|
11 | const Entrypoint = require("./Entrypoint");
|
12 | let debugId = 1000;
|
13 | const ERR_CHUNK_ENTRY = "Chunk.entry was removed. Use hasRuntime()";
|
14 | const ERR_CHUNK_INITIAL =
|
15 | "Chunk.initial was removed. Use canBeInitial/isOnlyInitial()";
|
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 | const sortModuleById = (a, b) => {
|
41 | if (a.id < b.id) return -1;
|
42 | if (b.id < a.id) return 1;
|
43 | return 0;
|
44 | };
|
45 |
|
46 |
|
47 |
|
48 |
|
49 |
|
50 |
|
51 |
|
52 | const sortChunkGroupById = (a, b) => {
|
53 | if (a.id < b.id) return -1;
|
54 | if (b.id < a.id) return 1;
|
55 | return 0;
|
56 | };
|
57 |
|
58 |
|
59 |
|
60 |
|
61 |
|
62 |
|
63 |
|
64 | const sortByIdentifier = (a, b) => {
|
65 | if (a.identifier() > b.identifier()) return 1;
|
66 | if (a.identifier() < b.identifier()) return -1;
|
67 | return 0;
|
68 | };
|
69 |
|
70 |
|
71 |
|
72 |
|
73 |
|
74 | const getModulesIdent = set => {
|
75 | set.sort();
|
76 | let str = "";
|
77 | for (const m of set) {
|
78 | str += m.identifier() + "#";
|
79 | }
|
80 | return str;
|
81 | };
|
82 |
|
83 |
|
84 |
|
85 |
|
86 |
|
87 |
|
88 | const getArray = set => Array.from(set);
|
89 |
|
90 | /**
|
91 | * @param {SortableSet<Module>} set the sortable Set to get the count/size of
|
92 | * @returns {number} the size of the modules
|
93 | */
|
94 | const getModulesSize = set => {
|
95 | let size = 0;
|
96 | for (const module of set) {
|
97 | size += module.size();
|
98 | }
|
99 | return size;
|
100 | };
|
101 |
|
102 |
|
103 |
|
104 |
|
105 |
|
106 | class Chunk {
|
107 | |
108 |
|
109 |
|
110 | constructor(name) {
|
111 |
|
112 | this.id = null;
|
113 |
|
114 | this.ids = null;
|
115 |
|
116 | this.debugId = debugId++;
|
117 |
|
118 | this.name = name;
|
119 |
|
120 | this.preventIntegration = false;
|
121 |
|
122 | this.entryModule = undefined;
|
123 |
|
124 | this._modules = new SortableSet(undefined, sortByIdentifier);
|
125 |
|
126 | this.filenameTemplate = undefined;
|
127 |
|
128 | this._groups = new SortableSet(undefined, sortChunkGroupById);
|
129 |
|
130 | this.files = [];
|
131 |
|
132 | this.rendered = false;
|
133 |
|
134 | this.hash = undefined;
|
135 |
|
136 | this.contentHash = Object.create(null);
|
137 |
|
138 | this.renderedHash = undefined;
|
139 |
|
140 | this.chunkReason = undefined;
|
141 |
|
142 | this.extraAsync = false;
|
143 | this.removedModules = undefined;
|
144 | }
|
145 |
|
146 | |
147 |
|
148 |
|
149 |
|
150 | get entry() {
|
151 | throw new Error(ERR_CHUNK_ENTRY);
|
152 | }
|
153 |
|
154 | |
155 |
|
156 |
|
157 |
|
158 |
|
159 | set entry(data) {
|
160 | throw new Error(ERR_CHUNK_ENTRY);
|
161 | }
|
162 |
|
163 | |
164 |
|
165 |
|
166 |
|
167 | get initial() {
|
168 | throw new Error(ERR_CHUNK_INITIAL);
|
169 | }
|
170 |
|
171 | |
172 |
|
173 |
|
174 |
|
175 |
|
176 | set initial(data) {
|
177 | throw new Error(ERR_CHUNK_INITIAL);
|
178 | }
|
179 |
|
180 | |
181 |
|
182 |
|
183 | hasRuntime() {
|
184 | for (const chunkGroup of this._groups) {
|
185 | if (
|
186 | chunkGroup.isInitial() &&
|
187 | chunkGroup instanceof Entrypoint &&
|
188 | chunkGroup.getRuntimeChunk() === this
|
189 | ) {
|
190 | return true;
|
191 | }
|
192 | }
|
193 | return false;
|
194 | }
|
195 |
|
196 | |
197 |
|
198 |
|
199 | canBeInitial() {
|
200 | for (const chunkGroup of this._groups) {
|
201 | if (chunkGroup.isInitial()) return true;
|
202 | }
|
203 | return false;
|
204 | }
|
205 |
|
206 | |
207 |
|
208 |
|
209 | isOnlyInitial() {
|
210 | if (this._groups.size <= 0) return false;
|
211 | for (const chunkGroup of this._groups) {
|
212 | if (!chunkGroup.isInitial()) return false;
|
213 | }
|
214 | return true;
|
215 | }
|
216 |
|
217 | |
218 |
|
219 |
|
220 | hasEntryModule() {
|
221 | return !!this.entryModule;
|
222 | }
|
223 |
|
224 | |
225 |
|
226 |
|
227 |
|
228 | addModule(module) {
|
229 | if (!this._modules.has(module)) {
|
230 | this._modules.add(module);
|
231 | return true;
|
232 | }
|
233 | return false;
|
234 | }
|
235 |
|
236 | |
237 |
|
238 |
|
239 |
|
240 | removeModule(module) {
|
241 | if (this._modules.delete(module)) {
|
242 | module.removeChunk(this);
|
243 | return true;
|
244 | }
|
245 | return false;
|
246 | }
|
247 |
|
248 | |
249 |
|
250 |
|
251 |
|
252 | setModules(modules) {
|
253 | this._modules = new SortableSet(modules, sortByIdentifier);
|
254 | }
|
255 |
|
256 | |
257 |
|
258 |
|
259 | getNumberOfModules() {
|
260 | return this._modules.size;
|
261 | }
|
262 |
|
263 | |
264 |
|
265 |
|
266 | get modulesIterable() {
|
267 | return this._modules;
|
268 | }
|
269 |
|
270 | |
271 |
|
272 |
|
273 |
|
274 | addGroup(chunkGroup) {
|
275 | if (this._groups.has(chunkGroup)) return false;
|
276 | this._groups.add(chunkGroup);
|
277 | return true;
|
278 | }
|
279 |
|
280 | |
281 |
|
282 |
|
283 |
|
284 | removeGroup(chunkGroup) {
|
285 | if (!this._groups.has(chunkGroup)) return false;
|
286 | this._groups.delete(chunkGroup);
|
287 | return true;
|
288 | }
|
289 |
|
290 | |
291 |
|
292 |
|
293 |
|
294 | isInGroup(chunkGroup) {
|
295 | return this._groups.has(chunkGroup);
|
296 | }
|
297 |
|
298 | |
299 |
|
300 |
|
301 | getNumberOfGroups() {
|
302 | return this._groups.size;
|
303 | }
|
304 |
|
305 | |
306 |
|
307 |
|
308 | get groupsIterable() {
|
309 | return this._groups;
|
310 | }
|
311 |
|
312 | |
313 |
|
314 |
|
315 |
|
316 | compareTo(otherChunk) {
|
317 | if (this.name && !otherChunk.name) return -1;
|
318 | if (!this.name && otherChunk.name) return 1;
|
319 | if (this.name < otherChunk.name) return -1;
|
320 | if (this.name > otherChunk.name) return 1;
|
321 | if (this._modules.size > otherChunk._modules.size) return -1;
|
322 | if (this._modules.size < otherChunk._modules.size) return 1;
|
323 | this._modules.sort();
|
324 | otherChunk._modules.sort();
|
325 | const a = this._modules[Symbol.iterator]();
|
326 | const b = otherChunk._modules[Symbol.iterator]();
|
327 |
|
328 | while (true) {
|
329 | const aItem = a.next();
|
330 | if (aItem.done) return 0;
|
331 | const bItem = b.next();
|
332 | const aModuleIdentifier = aItem.value.identifier();
|
333 | const bModuleIdentifier = bItem.value.identifier();
|
334 | if (aModuleIdentifier < bModuleIdentifier) return -1;
|
335 | if (aModuleIdentifier > bModuleIdentifier) return 1;
|
336 | }
|
337 | }
|
338 |
|
339 | |
340 |
|
341 |
|
342 |
|
343 | containsModule(module) {
|
344 | return this._modules.has(module);
|
345 | }
|
346 |
|
347 | |
348 |
|
349 |
|
350 | getModules() {
|
351 | return this._modules.getFromCache(getArray);
|
352 | }
|
353 |
|
354 | getModulesIdent() {
|
355 | return this._modules.getFromUnorderedCache(getModulesIdent);
|
356 | }
|
357 |
|
358 | |
359 |
|
360 |
|
361 |
|
362 | remove(reason) {
|
363 |
|
364 |
|
365 | for (const module of Array.from(this._modules)) {
|
366 | module.removeChunk(this);
|
367 | }
|
368 | for (const chunkGroup of this._groups) {
|
369 | chunkGroup.removeChunk(this);
|
370 | }
|
371 | }
|
372 |
|
373 | |
374 |
|
375 |
|
376 |
|
377 |
|
378 |
|
379 | moveModule(module, otherChunk) {
|
380 | GraphHelpers.disconnectChunkAndModule(this, module);
|
381 | GraphHelpers.connectChunkAndModule(otherChunk, module);
|
382 | module.rewriteChunkInReasons(this, [otherChunk]);
|
383 | }
|
384 |
|
385 | |
386 |
|
387 |
|
388 |
|
389 |
|
390 |
|
391 | integrate(otherChunk, reason) {
|
392 | if (!this.canBeIntegrated(otherChunk)) {
|
393 | return false;
|
394 | }
|
395 |
|
396 |
|
397 | if (this.name && otherChunk.name) {
|
398 | if (this.hasEntryModule() === otherChunk.hasEntryModule()) {
|
399 |
|
400 |
|
401 | if (this.name.length !== otherChunk.name.length) {
|
402 | this.name =
|
403 | this.name.length < otherChunk.name.length
|
404 | ? this.name
|
405 | : otherChunk.name;
|
406 | } else {
|
407 | this.name = this.name < otherChunk.name ? this.name : otherChunk.name;
|
408 | }
|
409 | } else if (otherChunk.hasEntryModule()) {
|
410 |
|
411 | this.name = otherChunk.name;
|
412 | }
|
413 | } else if (otherChunk.name) {
|
414 | this.name = otherChunk.name;
|
415 | }
|
416 |
|
417 |
|
418 | for (const module of Array.from(otherChunk._modules)) {
|
419 | otherChunk.moveModule(module, this);
|
420 | }
|
421 | otherChunk._modules.clear();
|
422 |
|
423 | if (otherChunk.entryModule) {
|
424 | this.entryModule = otherChunk.entryModule;
|
425 | }
|
426 |
|
427 | for (const chunkGroup of otherChunk._groups) {
|
428 | chunkGroup.replaceChunk(otherChunk, this);
|
429 | this.addGroup(chunkGroup);
|
430 | }
|
431 | otherChunk._groups.clear();
|
432 |
|
433 | return true;
|
434 | }
|
435 |
|
436 | |
437 |
|
438 |
|
439 |
|
440 | split(newChunk) {
|
441 | for (const chunkGroup of this._groups) {
|
442 | chunkGroup.insertChunk(newChunk, this);
|
443 | newChunk.addGroup(chunkGroup);
|
444 | }
|
445 | }
|
446 |
|
447 | isEmpty() {
|
448 | return this._modules.size === 0;
|
449 | }
|
450 |
|
451 | updateHash(hash) {
|
452 | hash.update(`${this.id} `);
|
453 | hash.update(this.ids ? this.ids.join(",") : "");
|
454 | hash.update(`${this.name || ""} `);
|
455 | for (const m of this._modules) {
|
456 | hash.update(m.hash);
|
457 | }
|
458 | }
|
459 |
|
460 | canBeIntegrated(otherChunk) {
|
461 | if (this.preventIntegration || otherChunk.preventIntegration) {
|
462 | return false;
|
463 | }
|
464 |
|
465 | const isAvailable = (a, b) => {
|
466 | const queue = new Set(b.groupsIterable);
|
467 | for (const chunkGroup of queue) {
|
468 | if (a.isInGroup(chunkGroup)) continue;
|
469 | if (chunkGroup.isInitial()) return false;
|
470 | for (const parent of chunkGroup.parentsIterable) {
|
471 | queue.add(parent);
|
472 | }
|
473 | }
|
474 | return true;
|
475 | };
|
476 |
|
477 | const selfHasRuntime = this.hasRuntime();
|
478 | const otherChunkHasRuntime = otherChunk.hasRuntime();
|
479 |
|
480 | if (selfHasRuntime !== otherChunkHasRuntime) {
|
481 | if (selfHasRuntime) {
|
482 | return isAvailable(this, otherChunk);
|
483 | } else if (otherChunkHasRuntime) {
|
484 | return isAvailable(otherChunk, this);
|
485 | } else {
|
486 | return false;
|
487 | }
|
488 | }
|
489 |
|
490 | if (this.hasEntryModule() || otherChunk.hasEntryModule()) {
|
491 | return false;
|
492 | }
|
493 |
|
494 | return true;
|
495 | }
|
496 |
|
497 | |
498 |
|
499 |
|
500 |
|
501 |
|
502 |
|
503 | addMultiplierAndOverhead(size, options) {
|
504 | const overhead =
|
505 | typeof options.chunkOverhead === "number" ? options.chunkOverhead : 10000;
|
506 | const multiplicator = this.canBeInitial()
|
507 | ? options.entryChunkMultiplicator || 10
|
508 | : 1;
|
509 |
|
510 | return size * multiplicator + overhead;
|
511 | }
|
512 |
|
513 | |
514 |
|
515 |
|
516 | modulesSize() {
|
517 | return this._modules.getFromUnorderedCache(getModulesSize);
|
518 | }
|
519 |
|
520 | |
521 |
|
522 |
|
523 |
|
524 | size(options = {}) {
|
525 | return this.addMultiplierAndOverhead(this.modulesSize(), options);
|
526 | }
|
527 |
|
528 | |
529 |
|
530 |
|
531 |
|
532 |
|
533 | integratedSize(otherChunk, options) {
|
534 |
|
535 | if (!this.canBeIntegrated(otherChunk)) {
|
536 | return false;
|
537 | }
|
538 |
|
539 | let integratedModulesSize = this.modulesSize();
|
540 |
|
541 | for (const otherModule of otherChunk._modules) {
|
542 | if (!this._modules.has(otherModule)) {
|
543 | integratedModulesSize += otherModule.size();
|
544 | }
|
545 | }
|
546 |
|
547 | return this.addMultiplierAndOverhead(integratedModulesSize, options);
|
548 | }
|
549 |
|
550 | |
551 |
|
552 |
|
553 |
|
554 | sortModules(sortByFn) {
|
555 | this._modules.sortWith(sortByFn || sortModuleById);
|
556 | }
|
557 |
|
558 | sortItems() {
|
559 | this.sortModules();
|
560 | }
|
561 |
|
562 | |
563 |
|
564 |
|
565 | getAllAsyncChunks() {
|
566 | const queue = new Set();
|
567 | const chunks = new Set();
|
568 |
|
569 | const initialChunks = intersect(
|
570 | Array.from(this.groupsIterable, g => new Set(g.chunks))
|
571 | );
|
572 |
|
573 | for (const chunkGroup of this.groupsIterable) {
|
574 | for (const child of chunkGroup.childrenIterable) {
|
575 | queue.add(child);
|
576 | }
|
577 | }
|
578 |
|
579 | for (const chunkGroup of queue) {
|
580 | for (const chunk of chunkGroup.chunks) {
|
581 | if (!initialChunks.has(chunk)) {
|
582 | chunks.add(chunk);
|
583 | }
|
584 | }
|
585 | for (const child of chunkGroup.childrenIterable) {
|
586 | queue.add(child);
|
587 | }
|
588 | }
|
589 |
|
590 | return chunks;
|
591 | }
|
592 |
|
593 | |
594 |
|
595 |
|
596 |
|
597 |
|
598 |
|
599 |
|
600 | |
601 |
|
602 |
|
603 |
|
604 | getChunkMaps(realHash) {
|
605 |
|
606 | const chunkHashMap = Object.create(null);
|
607 |
|
608 | const chunkContentHashMap = Object.create(null);
|
609 |
|
610 | const chunkNameMap = Object.create(null);
|
611 |
|
612 | for (const chunk of this.getAllAsyncChunks()) {
|
613 | chunkHashMap[chunk.id] = realHash ? chunk.hash : chunk.renderedHash;
|
614 | for (const key of Object.keys(chunk.contentHash)) {
|
615 | if (!chunkContentHashMap[key]) {
|
616 | chunkContentHashMap[key] = Object.create(null);
|
617 | }
|
618 | chunkContentHashMap[key][chunk.id] = chunk.contentHash[key];
|
619 | }
|
620 | if (chunk.name) {
|
621 | chunkNameMap[chunk.id] = chunk.name;
|
622 | }
|
623 | }
|
624 |
|
625 | return {
|
626 | hash: chunkHashMap,
|
627 | contentHash: chunkContentHashMap,
|
628 | name: chunkNameMap
|
629 | };
|
630 | }
|
631 |
|
632 | |
633 |
|
634 |
|
635 | getChildIdsByOrders() {
|
636 | const lists = new Map();
|
637 | for (const group of this.groupsIterable) {
|
638 | if (group.chunks[group.chunks.length - 1] === this) {
|
639 | for (const childGroup of group.childrenIterable) {
|
640 |
|
641 | if (typeof childGroup.options === "object") {
|
642 | for (const key of Object.keys(childGroup.options)) {
|
643 | if (key.endsWith("Order")) {
|
644 | const name = key.substr(0, key.length - "Order".length);
|
645 | let list = lists.get(name);
|
646 | if (list === undefined) lists.set(name, (list = []));
|
647 | list.push({
|
648 | order: childGroup.options[key],
|
649 | group: childGroup
|
650 | });
|
651 | }
|
652 | }
|
653 | }
|
654 | }
|
655 | }
|
656 | }
|
657 | const result = Object.create(null);
|
658 | for (const [name, list] of lists) {
|
659 | list.sort((a, b) => {
|
660 | const cmp = b.order - a.order;
|
661 | if (cmp !== 0) return cmp;
|
662 |
|
663 | if (a.group.compareTo) {
|
664 | return a.group.compareTo(b.group);
|
665 | }
|
666 | return 0;
|
667 | });
|
668 | result[name] = Array.from(
|
669 | list.reduce((set, item) => {
|
670 | for (const chunk of item.group.chunks) {
|
671 | set.add(chunk.id);
|
672 | }
|
673 | return set;
|
674 | }, new Set())
|
675 | );
|
676 | }
|
677 | return result;
|
678 | }
|
679 |
|
680 | getChildIdsByOrdersMap(includeDirectChildren) {
|
681 | const chunkMaps = Object.create(null);
|
682 |
|
683 | const addChildIdsByOrdersToMap = chunk => {
|
684 | const data = chunk.getChildIdsByOrders();
|
685 | for (const key of Object.keys(data)) {
|
686 | let chunkMap = chunkMaps[key];
|
687 | if (chunkMap === undefined) {
|
688 | chunkMaps[key] = chunkMap = Object.create(null);
|
689 | }
|
690 | chunkMap[chunk.id] = data[key];
|
691 | }
|
692 | };
|
693 |
|
694 | if (includeDirectChildren) {
|
695 | const chunks = new Set();
|
696 | for (const chunkGroup of this.groupsIterable) {
|
697 | for (const chunk of chunkGroup.chunks) {
|
698 | chunks.add(chunk);
|
699 | }
|
700 | }
|
701 | for (const chunk of chunks) {
|
702 | addChildIdsByOrdersToMap(chunk);
|
703 | }
|
704 | }
|
705 |
|
706 | for (const chunk of this.getAllAsyncChunks()) {
|
707 | addChildIdsByOrdersToMap(chunk);
|
708 | }
|
709 |
|
710 | return chunkMaps;
|
711 | }
|
712 |
|
713 | |
714 |
|
715 |
|
716 |
|
717 |
|
718 |
|
719 | |
720 |
|
721 |
|
722 |
|
723 | getChunkModuleMaps(filterFn) {
|
724 |
|
725 | const chunkModuleIdMap = Object.create(null);
|
726 |
|
727 | const chunkModuleHashMap = Object.create(null);
|
728 |
|
729 | for (const chunk of this.getAllAsyncChunks()) {
|
730 |
|
731 | let array;
|
732 | for (const module of chunk.modulesIterable) {
|
733 | if (filterFn(module)) {
|
734 | if (array === undefined) {
|
735 | array = [];
|
736 | chunkModuleIdMap[chunk.id] = array;
|
737 | }
|
738 | array.push(module.id);
|
739 | chunkModuleHashMap[module.id] = module.renderedHash;
|
740 | }
|
741 | }
|
742 | if (array !== undefined) {
|
743 | array.sort();
|
744 | }
|
745 | }
|
746 |
|
747 | return {
|
748 | id: chunkModuleIdMap,
|
749 | hash: chunkModuleHashMap
|
750 | };
|
751 | }
|
752 |
|
753 | |
754 |
|
755 |
|
756 |
|
757 |
|
758 |
|
759 | hasModuleInGraph(filterFn, filterChunkFn) {
|
760 | const queue = new Set(this.groupsIterable);
|
761 | const chunksProcessed = new Set();
|
762 |
|
763 | for (const chunkGroup of queue) {
|
764 | for (const chunk of chunkGroup.chunks) {
|
765 | if (!chunksProcessed.has(chunk)) {
|
766 | chunksProcessed.add(chunk);
|
767 | if (!filterChunkFn || filterChunkFn(chunk)) {
|
768 | for (const module of chunk.modulesIterable) {
|
769 | if (filterFn(module)) {
|
770 | return true;
|
771 | }
|
772 | }
|
773 | }
|
774 | }
|
775 | }
|
776 | for (const child of chunkGroup.childrenIterable) {
|
777 | queue.add(child);
|
778 | }
|
779 | }
|
780 | return false;
|
781 | }
|
782 |
|
783 | toString() {
|
784 | return `Chunk[${Array.from(this._modules).join()}]`;
|
785 | }
|
786 | }
|
787 |
|
788 |
|
789 | Object.defineProperty(Chunk.prototype, "forEachModule", {
|
790 | configurable: false,
|
791 | value: util.deprecate(
|
792 | |
793 |
|
794 |
|
795 |
|
796 |
|
797 |
|
798 |
|
799 | function(fn) {
|
800 | this._modules.forEach(fn);
|
801 | },
|
802 | "Chunk.forEachModule: Use for(const module of chunk.modulesIterable) instead"
|
803 | )
|
804 | });
|
805 |
|
806 |
|
807 | Object.defineProperty(Chunk.prototype, "mapModules", {
|
808 | configurable: false,
|
809 | value: util.deprecate(
|
810 | |
811 |
|
812 |
|
813 |
|
814 |
|
815 |
|
816 |
|
817 | function(fn) {
|
818 | return Array.from(this._modules, fn);
|
819 | },
|
820 | "Chunk.mapModules: Use Array.from(chunk.modulesIterable, fn) instead"
|
821 | )
|
822 | });
|
823 |
|
824 |
|
825 | Object.defineProperty(Chunk.prototype, "chunks", {
|
826 | configurable: false,
|
827 | get() {
|
828 | throw new Error("Chunk.chunks: Use ChunkGroup.getChildren() instead");
|
829 | },
|
830 | set() {
|
831 | throw new Error("Chunk.chunks: Use ChunkGroup.add/removeChild() instead");
|
832 | }
|
833 | });
|
834 |
|
835 |
|
836 | Object.defineProperty(Chunk.prototype, "parents", {
|
837 | configurable: false,
|
838 | get() {
|
839 | throw new Error("Chunk.parents: Use ChunkGroup.getParents() instead");
|
840 | },
|
841 | set() {
|
842 | throw new Error("Chunk.parents: Use ChunkGroup.add/removeParent() instead");
|
843 | }
|
844 | });
|
845 |
|
846 |
|
847 | Object.defineProperty(Chunk.prototype, "blocks", {
|
848 | configurable: false,
|
849 | get() {
|
850 | throw new Error("Chunk.blocks: Use ChunkGroup.getBlocks() instead");
|
851 | },
|
852 | set() {
|
853 | throw new Error("Chunk.blocks: Use ChunkGroup.add/removeBlock() instead");
|
854 | }
|
855 | });
|
856 |
|
857 |
|
858 | Object.defineProperty(Chunk.prototype, "entrypoints", {
|
859 | configurable: false,
|
860 | get() {
|
861 | throw new Error(
|
862 | "Chunk.entrypoints: Use Chunks.groupsIterable and filter by instanceof Entrypoint instead"
|
863 | );
|
864 | },
|
865 | set() {
|
866 | throw new Error("Chunk.entrypoints: Use Chunks.addGroup instead");
|
867 | }
|
868 | });
|
869 |
|
870 | module.exports = Chunk;
|