@atlaspack/bundler-default 2.14.5-canary.36 → 2.14.5-canary.360

package/dist/decorateLegacyGraph.js

@@ -0,0 +1,189 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decorateLegacyGraph = decorateLegacyGraph;
+const graph_1 = require("@atlaspack/graph");
+const feature_flags_1 = require("@atlaspack/feature-flags");
+const assert_1 = __importDefault(require("assert"));
+const nullthrows_1 = __importDefault(require("nullthrows"));
+const idealGraph_1 = require("./idealGraph");
+function decorateLegacyGraph(idealGraph, bundleGraph) {
+    let idealBundleToLegacyBundle = new Map();
+    let { bundleGraph: idealBundleGraph, dependencyBundleGraph, bundleGroupBundleIds, manualAssetToBundle, } = idealGraph;
+    // This line can be deleted once supportWebpackChunkName feature flag is removed.
+    let entryBundleToBundleGroup = new Map();
+    // Step Create Bundles: Create bundle groups, bundles, and shared bundles and add assets to them
+    for (let [bundleNodeId, idealBundle] of idealBundleGraph.nodes.entries()) {
+        if (!idealBundle || idealBundle === 'root')
+            continue;
+        let entryAsset = idealBundle.mainEntryAsset;
+        // This line can be deleted once supportWebpackChunkName feature flag is removed.
+        let bundleGroup;
+        let bundle;
+        if (bundleGroupBundleIds.has(bundleNodeId)) {
+            (0, assert_1.default)(idealBundle.manualSharedBundle == null, 'Processing a manualSharedBundle as a BundleGroup');
+            let dependencies = dependencyBundleGraph
+                .getNodeIdsConnectedTo(dependencyBundleGraph.getNodeIdByContentKey(String(bundleNodeId)), graph_1.ALL_EDGE_TYPES)
+                .map((nodeId) => {
+                let dependency = (0, nullthrows_1.default)(dependencyBundleGraph.getNode(nodeId));
+                (0, assert_1.default)(dependency.type === 'dependency');
+                return dependency.value;
+            });
+            (0, assert_1.default)(entryAsset != null, 'Processing a bundleGroup with no entry asset');
+            let bundleGroups = new Map();
+            for (let dependency of dependencies) {
+                bundleGroup = bundleGraph.createBundleGroup(dependency, idealBundle.target);
+                bundleGroups.set(bundleGroup.entryAssetId, bundleGroup);
+            }
+            if ((0, feature_flags_1.getFeatureFlag)('supportWebpackChunkName')) {
+                (0, assert_1.default)(bundleGroups.size > 0, 'No bundle groups created');
+            }
+            else {
+                (0, assert_1.default)(bundleGroup);
+                entryBundleToBundleGroup.set(bundleNodeId, bundleGroup);
+            }
+            bundle = (0, nullthrows_1.default)(bundleGraph.createBundle({
+                entryAsset: (0, nullthrows_1.default)(entryAsset),
+                bundleRoots: Array.from(idealBundle.bundleRoots),
+                needsStableName: idealBundle.needsStableName,
+                bundleBehavior: idealBundle.bundleBehavior,
+                target: idealBundle.target,
+                manualSharedBundle: idealBundle.manualSharedBundle,
+            }));
+            if ((0, feature_flags_1.getFeatureFlag)('supportWebpackChunkName')) {
+                for (let bundleGroup of bundleGroups.values()) {
+                    bundleGraph.addBundleToBundleGroup(bundle, bundleGroup);
+                }
+            }
+            else {
+                (0, assert_1.default)(bundleGroup);
+                bundleGraph.addBundleToBundleGroup(bundle, bundleGroup);
+            }
+        }
+        else if (idealBundle.sourceBundles.size > 0 &&
+            !idealBundle.mainEntryAsset) {
+            let uniqueKey = idealBundle.uniqueKey != null
+                ? idealBundle.uniqueKey
+                : [...idealBundle.assets].map((asset) => asset.id).join(',');
+            bundle = (0, nullthrows_1.default)(bundleGraph.createBundle({
+                uniqueKey,
+                needsStableName: idealBundle.needsStableName,
+                bundleBehavior: idealBundle.bundleBehavior,
+                type: idealBundle.type,
+                target: idealBundle.target,
+                env: idealBundle.env,
+                manualSharedBundle: idealBundle.manualSharedBundle,
+            }));
+        }
+        else if (idealBundle.uniqueKey != null) {
+            bundle = (0, nullthrows_1.default)(bundleGraph.createBundle({
+                uniqueKey: idealBundle.uniqueKey,
+                needsStableName: idealBundle.needsStableName,
+                bundleBehavior: idealBundle.bundleBehavior,
+                type: idealBundle.type,
+                target: idealBundle.target,
+                env: idealBundle.env,
+                manualSharedBundle: idealBundle.manualSharedBundle,
+            }));
+        }
+        else {
+            (0, assert_1.default)(entryAsset != null);
+            bundle = (0, nullthrows_1.default)(bundleGraph.createBundle({
+                entryAsset,
+                bundleRoots: Array.from(idealBundle.bundleRoots),
+                needsStableName: idealBundle.needsStableName,
+                bundleBehavior: idealBundle.bundleBehavior,
+                target: idealBundle.target,
+                manualSharedBundle: idealBundle.manualSharedBundle,
+            }));
+        }
+        idealBundleToLegacyBundle.set(idealBundle, bundle);
+        for (let asset of idealBundle.assets) {
+            bundleGraph.addAssetToBundle(asset, bundle);
+        }
+    }
+    // Step Internalization: Internalize dependencies for bundles
+    for (let idealBundle of idealBundleGraph.nodes) {
+        if (!idealBundle || idealBundle === 'root')
+            continue;
+        let bundle = (0, nullthrows_1.default)(idealBundleToLegacyBundle.get(idealBundle));
+        if (idealBundle.internalizedAssets) {
+            idealBundle.internalizedAssets.forEach((internalized) => {
+                let incomingDeps = bundleGraph.getIncomingDependencies(idealGraph.assets[internalized]);
+                for (let incomingDep of incomingDeps) {
+                    if (incomingDep.priority === 'lazy' &&
+                        incomingDep.specifierType !== 'url' &&
+                        bundle.hasDependency(incomingDep)) {
+                        bundleGraph.internalizeAsyncDependency(bundle, incomingDep);
+                    }
+                }
+            });
+        }
+    }
+    // Manual Shared Bundles
+    // NOTE: This only works under the assumption that manual shared bundles would have
+    // always already been loaded before the bundle that requires internalization.
+    for (let manualSharedAsset of manualAssetToBundle.keys()) {
+        let incomingDeps = bundleGraph.getIncomingDependencies(manualSharedAsset);
+        for (let incomingDep of incomingDeps) {
+            if (incomingDep.priority === 'lazy' &&
+                incomingDep.specifierType !== 'url') {
+                let bundles = bundleGraph.getBundlesWithDependency(incomingDep);
+                for (let bundle of bundles) {
+                    bundleGraph.internalizeAsyncDependency(bundle, incomingDep);
+                }
+            }
+        }
+    }
+    // Step Add to BundleGroups: Add bundles to their bundle groups
+    idealBundleGraph.traverse((nodeId, _, actions) => {
+        let node = idealBundleGraph.getNode(nodeId);
+        if (node === 'root') {
+            return;
+        }
+        actions.skipChildren();
+        let outboundNodeIds = idealBundleGraph.getNodeIdsConnectedFrom(nodeId);
+        let entryBundle = (0, nullthrows_1.default)(idealBundleGraph.getNode(nodeId));
+        (0, assert_1.default)(entryBundle !== 'root');
+        let legacyEntryBundle = (0, nullthrows_1.default)(idealBundleToLegacyBundle.get(entryBundle));
+        for (let id of outboundNodeIds) {
+            let siblingBundle = (0, nullthrows_1.default)(idealBundleGraph.getNode(id));
+            (0, assert_1.default)(siblingBundle !== 'root');
+            let legacySiblingBundle = (0, nullthrows_1.default)(idealBundleToLegacyBundle.get(siblingBundle));
+            bundleGraph.createBundleReference(legacyEntryBundle, legacySiblingBundle);
+        }
+    });
+    // Step References: Add references to all bundles
+    for (let [asset, references] of idealGraph.assetReference) {
+        for (let [dependency, bundle] of references) {
+            let legacyBundle = (0, nullthrows_1.default)(idealBundleToLegacyBundle.get(bundle));
+            bundleGraph.createAssetReference(dependency, asset, legacyBundle);
+        }
+    }
+    // @ts-expect-error TS2488
+    for (let { type, from, to } of idealBundleGraph.getAllEdges()) {
+        let sourceBundle = (0, nullthrows_1.default)(idealBundleGraph.getNode(from));
+        if (sourceBundle === 'root') {
+            continue;
+        }
+        // @ts-expect-error TS2367
+        (0, assert_1.default)(sourceBundle !== 'root');
+        let legacySourceBundle = (0, nullthrows_1.default)(idealBundleToLegacyBundle.get(sourceBundle));
+        let targetBundle = (0, nullthrows_1.default)(idealBundleGraph.getNode(to));
+        if (targetBundle === 'root') {
+            continue;
+        }
+        // @ts-expect-error TS2367
+        (0, assert_1.default)(targetBundle !== 'root');
+        let legacyTargetBundle = (0, nullthrows_1.default)(idealBundleToLegacyBundle.get(targetBundle));
+        if ((0, feature_flags_1.getFeatureFlag)('conditionalBundlingApi') &&
+            type === idealGraph_1.idealBundleGraphEdges.conditional) {
+            bundleGraph.createBundleConditionalReference(legacySourceBundle, legacyTargetBundle);
+        }
+        else {
+            bundleGraph.createBundleReference(legacySourceBundle, legacyTargetBundle);
+        }
+    }
+}