@atlaspack/bundler-default 2.14.5-canary.29 → 2.14.5-canary.291

package/dist/bundleMerge.js

@@ -0,0 +1,137 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findMergeCandidates = findMergeCandidates;
+const assert_1 = __importDefault(require("assert"));
+const nullthrows_1 = __importDefault(require("nullthrows"));
+const graph_1 = require("@atlaspack/graph");
+const utils_1 = require("@atlaspack/utils");
+const memoize_1 = require("./memoize");
+function getBundlesForBundleGroup(bundleGraph, bundleGroupId) {
+    let count = 0;
+    bundleGraph.traverse((nodeId) => {
+        const node = bundleGraph.getNode(nodeId);
+        if (node &&
+            (node === 'root' ||
+                (node.bundleBehavior !== 'inline' &&
+                    node.bundleBehavior !== 'inlineIsolated'))) {
+            count++;
+        }
+    }, bundleGroupId);
+    return count;
+}
+let getBundleOverlap = (sourceBundlesA, sourceBundlesB) => {
+    let allSourceBundles = (0, utils_1.setUnion)(sourceBundlesA, sourceBundlesB);
+    let sharedSourceBundles = (0, utils_1.setIntersectStatic)(sourceBundlesA, sourceBundlesB);
+    return sharedSourceBundles.size / allSourceBundles.size;
+};
+// Returns a decimal showing the proportion source bundles are common to
+// both bundles versus the total number of source bundles.
+function checkBundleThreshold(bundleA, bundleB, threshold) {
+    return (getBundleOverlap(bundleA.bundle.sourceBundles, bundleB.bundle.sourceBundles) >= threshold);
+}
+let checkSharedSourceBundles = (0, memoize_1.memoize)((bundle, importantAncestorBundles) => {
+    return importantAncestorBundles.every((ancestorId) => bundle.sourceBundles.has(ancestorId));
+});
+let hasSuitableBundleGroup = (0, memoize_1.memoize)((bundleGraph, bundle, minBundlesInGroup) => {
+    for (let sourceBundle of bundle.sourceBundles) {
+        let bundlesInGroup = getBundlesForBundleGroup(bundleGraph, sourceBundle);
+        if (bundlesInGroup >= minBundlesInGroup) {
+            return true;
+        }
+    }
+    return false;
+});
+function validMerge(bundleGraph, config, bundleA, bundleB) {
+    if (config.maxBundleSize != null) {
+        if (bundleA.bundle.size > config.maxBundleSize ||
+            bundleB.bundle.size > config.maxBundleSize) {
+            return false;
+        }
+    }
+    if (config.overlapThreshold != null) {
+        if (!checkBundleThreshold(bundleA, bundleB, config.overlapThreshold)) {
+            return false;
+        }
+    }
+    if (config.sourceBundles != null) {
+        if (!checkSharedSourceBundles(bundleA.bundle, config.sourceBundles) ||
+            !checkSharedSourceBundles(bundleB.bundle, config.sourceBundles)) {
+            return false;
+        }
+    }
+    if (config.minBundlesInGroup != null) {
+        if (!hasSuitableBundleGroup(bundleGraph, bundleA.bundle, config.minBundlesInGroup) ||
+            !hasSuitableBundleGroup(bundleGraph, bundleB.bundle, config.minBundlesInGroup)) {
+            return false;
+        }
+    }
+    return true;
+}
+function getMergeClusters(graph, candidates) {
+    let clusters = [];
+    for (let [candidate, edgeType] of candidates.entries()) {
+        let cluster = [];
+        graph.traverse((nodeId) => {
+            cluster.push((0, nullthrows_1.default)(graph.getNode(nodeId)));
+            // Remove node from candidates as it has already been processed
+            candidates.delete(nodeId);
+        }, candidate, edgeType);
+        clusters.push(cluster);
+    }
+    return clusters;
+}
+function getPossibleMergeCandidates(bundleGraph, bundles) {
+    let mergeCandidates = bundles.map((bundleId) => {
+        let bundle = bundleGraph.getNode(bundleId);
+        (0, assert_1.default)(bundle && bundle !== 'root', 'Bundle should exist');
+        return {
+            id: bundleId,
+            bundle,
+            contentKey: bundleId.toString(),
+        };
+    });
+    const uniquePairs = [];
+    for (let i = 0; i < mergeCandidates.length; i++) {
+        for (let j = i + 1; j < mergeCandidates.length; j++) {
+            let a = mergeCandidates[i];
+            let b = mergeCandidates[j];
+            // @ts-expect-error TS18048
+            if (a.bundle.internalizedAssets.equals(b.bundle.internalizedAssets)) {
+                uniquePairs.push([a, b]);
+            }
+        }
+    }
+    return uniquePairs;
+}
+function findMergeCandidates(bundleGraph, bundles, config) {
+    let graph = new graph_1.ContentGraph();
+    let candidates = new Map();
+    let allPossibleMergeCandidates = getPossibleMergeCandidates(bundleGraph, bundles);
+    // Build graph of clustered merge candidates
+    for (let i = 0; i < config.length; i++) {
+        // Ensure edge type coresponds to config index
+        let edgeType = i + 1;
+        for (let group of allPossibleMergeCandidates) {
+            let candidateA = group[0];
+            let candidateB = group[1];
+            if (!validMerge(bundleGraph, config[i], candidateA, candidateB)) {
+                continue;
+            }
+            let bundleNode = graph.addNodeByContentKeyIfNeeded(candidateA.contentKey, candidateA.id);
+            let otherBundleNode = graph.addNodeByContentKeyIfNeeded(candidateB.contentKey, candidateB.id);
+            // Add edge in both directions
+            graph.addEdge(bundleNode, otherBundleNode, edgeType);
+            graph.addEdge(otherBundleNode, bundleNode, edgeType);
+            candidates.set(bundleNode, edgeType);
+            candidates.set(otherBundleNode, edgeType);
+        }
+        // Remove bundles that have been allocated to a higher priority merge
+        allPossibleMergeCandidates = allPossibleMergeCandidates.filter((group) => !graph.hasContentKey(group[0].contentKey) &&
+            !graph.hasContentKey(group[1].contentKey));
+    }
+    (0, memoize_1.clearCaches)();
+    return getMergeClusters(graph, candidates);
+}

package/dist/bundlerConfig.js

@@ -0,0 +1,225 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadBundlerConfig = loadBundlerConfig;
+const diagnostic_1 = require("@atlaspack/diagnostic");
+const feature_flags_1 = require("@atlaspack/feature-flags");
+const utils_1 = require("@atlaspack/utils");
+const assert_1 = __importDefault(require("assert"));
+function resolveModeConfig(config, mode) {
+    let generalConfig = {};
+    let modeConfig = {};
+    for (const key of Object.keys(config)) {
+        if (key === 'development' || key === 'production') {
+            if (key === mode) {
+                // @ts-expect-error TS2322
+                modeConfig = config[key];
+            }
+        }
+        else {
+            generalConfig[key] = config[key];
+        }
+    }
+    return {
+        ...generalConfig,
+        ...modeConfig,
+    };
+}
+// Default options by http version.
+const HTTP_OPTIONS = {
+    '1': {
+        minBundles: 1,
+        manualSharedBundles: [],
+        minBundleSize: 30000,
+        maxParallelRequests: 6,
+        disableSharedBundles: false,
+        sharedBundleMerge: [],
+    },
+    '2': {
+        minBundles: 1,
+        manualSharedBundles: [],
+        minBundleSize: 20000,
+        maxParallelRequests: 25,
+        disableSharedBundles: false,
+        sharedBundleMerge: [],
+    },
+};
+const CONFIG_SCHEMA = {
+    type: 'object',
+    properties: {
+        http: {
+            type: 'number',
+            enum: Object.keys(HTTP_OPTIONS).map((k) => Number(k)),
+        },
+        manualSharedBundles: {
+            type: 'array',
+            items: {
+                type: 'object',
+                properties: {
+                    name: {
+                        type: 'string',
+                    },
+                    assets: {
+                        type: 'array',
+                        items: {
+                            type: 'string',
+                        },
+                    },
+                    types: {
+                        type: 'array',
+                        items: {
+                            type: 'string',
+                        },
+                    },
+                    root: {
+                        type: 'string',
+                    },
+                    split: {
+                        type: 'number',
+                    },
+                },
+                required: ['name', 'assets'],
+                additionalProperties: false,
+            },
+        },
+        sharedBundleMerge: {
+            type: 'array',
+            items: {
+                type: 'object',
+                properties: {
+                    overlapThreshold: {
+                        type: 'number',
+                    },
+                    maxBundleSize: {
+                        type: 'number',
+                    },
+                    sourceBundles: {
+                        type: 'array',
+                        items: {
+                            type: 'string',
+                        },
+                    },
+                    minBundlesInGroup: {
+                        type: 'number',
+                    },
+                },
+                additionalProperties: false,
+            },
+        },
+        asyncBundleMerge: {
+            type: 'object',
+            properties: {
+                bundleSize: {
+                    type: 'number',
+                    required: true,
+                },
+                maxOverfetchSize: {
+                    type: 'number',
+                    required: true,
+                },
+                ignore: {
+                    type: 'array',
+                    items: {
+                        type: 'string',
+                    },
+                },
+            },
+            additionalProperties: false,
+        },
+        minBundles: {
+            type: 'number',
+        },
+        minBundleSize: {
+            type: 'number',
+        },
+        maxParallelRequests: {
+            type: 'number',
+        },
+        disableSharedBundles: {
+            type: 'boolean',
+        },
+        loadConditionalBundlesInParallel: {
+            type: 'boolean',
+        },
+        sharedBundleMergeThreshold: {
+            type: 'number',
+        },
+    },
+    additionalProperties: false,
+};
+async function loadBundlerConfig(config, options, logger) {
+    let conf;
+    if ((0, feature_flags_1.getFeatureFlag)('resolveBundlerConfigFromCwd')) {
+        conf = await config.getConfigFrom(`${process.cwd()}/index`, [], {
+            packageKey: '@atlaspack/bundler-default',
+        });
+    }
+    else {
+        conf = await config.getConfig([], {
+            packageKey: '@atlaspack/bundler-default',
+        });
+    }
+    if (!conf) {
+        const modDefault = {
+            ...HTTP_OPTIONS['2'],
+            projectRoot: options.projectRoot,
+        };
+        // @ts-expect-error TS2322
+        return modDefault;
+    }
+    (0, assert_1.default)(conf?.contents != null);
+    let modeConfig = resolveModeConfig(conf.contents, options.mode);
+    // minBundles will be ignored if shared bundles are disabled
+    if (modeConfig.minBundles != null &&
+        modeConfig.disableSharedBundles === true) {
+        logger.warn({
+            origin: '@atlaspack/bundler-default',
+            message: `The value of "${modeConfig.minBundles}" set for minBundles will not be used as shared bundles have been disabled`,
+        });
+    }
+    // minBundleSize will be ignored if shared bundles are disabled
+    if (modeConfig.minBundleSize != null &&
+        modeConfig.disableSharedBundles === true) {
+        logger.warn({
+            origin: '@atlaspack/bundler-default',
+            message: `The value of "${modeConfig.minBundleSize}" set for minBundleSize will not be used as shared bundles have been disabled`,
+        });
+    }
+    // maxParallelRequests will be ignored if shared bundles are disabled
+    if (modeConfig.maxParallelRequests != null &&
+        modeConfig.disableSharedBundles === true) {
+        logger.warn({
+            origin: '@atlaspack/bundler-default',
+            message: `The value of "${modeConfig.maxParallelRequests}" set for maxParallelRequests will not be used as shared bundles have been disabled`,
+        });
+    }
+    if (modeConfig.manualSharedBundles) {
+        let nameArray = modeConfig.manualSharedBundles.map((a) => a.name);
+        let nameSet = new Set(nameArray);
+        (0, assert_1.default)(nameSet.size == nameArray.length, 'The name field must be unique for property manualSharedBundles');
+    }
+    utils_1.validateSchema.diagnostic(CONFIG_SCHEMA, {
+        data: modeConfig,
+        source: (0, feature_flags_1.getFeatureFlag)('schemaValidationDeferSourceLoading')
+            ? () => options.inputFS.readFileSync(conf.filePath, 'utf8')
+            : await options.inputFS.readFile(conf.filePath, 'utf8'),
+        filePath: conf.filePath,
+        prependKey: `/${(0, diagnostic_1.encodeJSONKeyComponent)('@atlaspack/bundler-default')}`,
+    }, '@atlaspack/bundler-default', 'Invalid config for @atlaspack/bundler-default');
+    let http = modeConfig.http ?? 2;
+    // @ts-expect-error TS7053
+    let defaults = HTTP_OPTIONS[http];
+    return {
+        minBundles: modeConfig.minBundles ?? defaults.minBundles,
+        minBundleSize: modeConfig.minBundleSize ?? defaults.minBundleSize,
+        sharedBundleMerge: modeConfig.sharedBundleMerge ?? defaults.sharedBundleMerge,
+        asyncBundleMerge: modeConfig.asyncBundleMerge,
+        maxParallelRequests: modeConfig.maxParallelRequests ?? defaults.maxParallelRequests,
+        projectRoot: options.projectRoot,
+        disableSharedBundles: modeConfig.disableSharedBundles ?? defaults.disableSharedBundles,
+        manualSharedBundles: modeConfig.manualSharedBundles ?? defaults.manualSharedBundles,
+        loadConditionalBundlesInParallel: modeConfig.loadConditionalBundlesInParallel,
+    };
+}

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);
+        }
+    }
+}