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

package/dist/DefaultBundler.js

@@ -0,0 +1,84 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const plugin_1 = require("@atlaspack/plugin");
+const utils_1 = require("@atlaspack/utils");
+const assert_1 = __importDefault(require("assert"));
+const bundlerConfig_1 = require("./bundlerConfig");
+const decorateLegacyGraph_1 = require("./decorateLegacyGraph");
+const idealGraph_1 = require("./idealGraph");
+const MonolithicBundler_1 = require("./MonolithicBundler");
+/**
+ *
+ * The Bundler works by creating an IdealGraph, which contains a BundleGraph that models bundles
+ * connected to other bundles by what references them, and thus models BundleGroups.
+ *
+ * First, we enter `bundle({bundleGraph, config})`. Here, "bundleGraph" is actually just the
+ * assetGraph turned into a type `MutableBundleGraph`, which will then be mutated in decorate,
+ * and turned into what we expect the bundleGraph to be as per the old (default) bundler structure
+ *  & what the rest of Atlaspack expects a BundleGraph to be.
+ *
+ * `bundle({bundleGraph, config})` First gets a Mapping of target to entries, In most cases there is
+ *  only one target, and one or more entries. (Targets are pertinent in monorepos or projects where you
+ *  will have two or more distDirs, or output folders.) Then calls create IdealGraph and Decorate per target.
+ *
+ */
+exports.default = new plugin_1.Bundler({
+    loadConfig({ config, options, logger }) {
+        return (0, bundlerConfig_1.loadBundlerConfig)(config, options, logger);
+    },
+    bundle({ bundleGraph, config, logger }) {
+        let targetMap = getEntryByTarget(bundleGraph); // Organize entries by target output folder/ distDir
+        // @ts-expect-error TS2304
+        let graphs = [];
+        for (let entries of targetMap.values()) {
+            let singleFileEntries = new Map();
+            let idealGraphEntries = new Map();
+            // Separate out the monolith bundles based on the option on target
+            for (let [entryAsset, entryDep] of entries.entries()) {
+                if (entryDep.target?.env.unstableSingleFileOutput === true) {
+                    singleFileEntries.set(entryAsset, entryDep);
+                }
+                else {
+                    idealGraphEntries.set(entryAsset, entryDep);
+                }
+            }
+            // Create separate bundleGraphs per distDir
+            graphs.push((0, idealGraph_1.createIdealGraph)(bundleGraph, config, idealGraphEntries, logger));
+            // Do this after the ideal graph so that the mutation of the bundleGraph doesn't
+            // interfere with the main bundling algorithm
+            for (let [entryAsset, entryDep] of singleFileEntries.entries()) {
+                (0, MonolithicBundler_1.addJSMonolithBundle)(bundleGraph, entryAsset, entryDep);
+            }
+        }
+        for (let g of graphs) {
+            (0, decorateLegacyGraph_1.decorateLegacyGraph)(g, bundleGraph); //mutate original graph
+        }
+    },
+    optimize() { },
+});
+function getEntryByTarget(bundleGraph) {
+    // Find entries from assetGraph per target
+    let targets = new utils_1.DefaultMap(() => new Map());
+    bundleGraph.traverse({
+        enter(
+        // @ts-expect-error TS2304
+        node, context, 
+        // @ts-expect-error TS2304
+        actions) {
+            if (node.type !== 'asset') {
+                return node;
+            }
+            (0, assert_1.default)(context != null &&
+                context.type === 'dependency' &&
+                context.value.isEntry &&
+                context.value.target != null);
+            targets.get(context.value.target.distDir).set(node.value, context.value);
+            actions.skipChildren();
+            return node;
+        },
+    });
+    return targets;
+}

package/dist/MonolithicBundler.js

@@ -0,0 +1,68 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addJSMonolithBundle = addJSMonolithBundle;
+const feature_flags_1 = require("@atlaspack/feature-flags");
+const nullthrows_1 = __importDefault(require("nullthrows"));
+function addJSMonolithBundle(bundleGraph, entryAsset, entryDep) {
+    let target = (0, nullthrows_1.default)(entryDep.target, 'Expected dependency to have a valid target');
+    // Create a single bundle to hold all JS assets
+    let bundle = bundleGraph.createBundle({
+        entryAsset,
+        target,
+        needsStableName: (0, feature_flags_1.getFeatureFlag)('singleFileOutputStableName'),
+    });
+    bundleGraph.traverse((node, _, actions) => {
+        // JS assets can be added to the bundle, but the rest are ignored
+        if (node.type === 'asset' && node.value.type === 'js') {
+            bundleGraph.addAssetToBundle(node.value, bundle);
+            return;
+        }
+        if (node.type !== 'dependency') {
+            return;
+        }
+        let dependency = node.value;
+        if (dependency.priority === 'lazy') {
+            // Any async dependencies need to be internalized into the bundle, and will
+            // be included by the asset check above
+            bundleGraph.internalizeAsyncDependency(bundle, dependency);
+            return;
+        }
+        let assets = bundleGraph.getDependencyAssets(dependency);
+        for (const asset of assets) {
+            if (asset.bundleBehavior === 'isolated' ||
+                asset.bundleBehavior === 'inlineIsolated') {
+                throw new Error(`${asset.bundleBehavior === 'isolated' ? 'Isolated' : 'Inline isolated'} assets are not supported for single file output builds`);
+            }
+            // For assets marked as inline, we create new bundles and let other
+            // plugins like optimizers include them in the primary bundle
+            if (asset.bundleBehavior === 'inline') {
+                // Create a new bundle to hold the isolated asset
+                let isolatedBundle = bundleGraph.createBundle({
+                    entryAsset: asset,
+                    target,
+                    bundleBehavior: asset.bundleBehavior,
+                });
+                bundleGraph.addAssetToBundle(asset, isolatedBundle);
+                // Add the new bundle to the bundle graph, in its own bundle group
+                bundleGraph.createBundleReference(bundle, isolatedBundle);
+                bundleGraph.addBundleToBundleGroup(isolatedBundle, bundleGraph.createBundleGroup(dependency, target));
+                // Nothing below the isolated asset needs to go in the main bundle, so
+                // we can stop traversal here
+                actions.skipChildren();
+                // To be properly isolated, all of this asset's dependencies need to go
+                // in this new bundle
+                bundleGraph.traverse((subNode) => {
+                    if (subNode.type === 'asset' && subNode.value.type === 'js') {
+                        bundleGraph.addAssetToBundle(subNode.value, isolatedBundle);
+                        return;
+                    }
+                }, asset, { skipUnusedDependencies: true });
+            }
+        }
+    }, entryAsset, { skipUnusedDependencies: true });
+    let bundleGroup = bundleGraph.createBundleGroup(entryDep, target);
+    bundleGraph.addBundleToBundleGroup(bundle, bundleGroup);
+}

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,223 @@
+"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: () => options.inputFS.readFileSync(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,
+    };
+}