@atlaspack/core 2.16.2-canary.37 → 2.16.2-canary.371

package/dist/public/Bundle.js

@@ -0,0 +1,224 @@
+"use strict";
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _Bundle_bundle, _Bundle_bundleGraph, _Bundle_options, _NamedBundle_bundle, _NamedBundle_bundleGraph, _NamedBundle_options, _PackagedBundle_bundle, _PackagedBundle_bundleGraph, _PackagedBundle_options, _PackagedBundle_bundleInfo;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PackagedBundle = exports.NamedBundle = exports.Bundle = void 0;
+exports.bundleToInternalBundle = bundleToInternalBundle;
+exports.bundleToInternalBundleGraph = bundleToInternalBundleGraph;
+const assert_1 = __importDefault(require("assert"));
+const nullthrows_1 = __importDefault(require("nullthrows"));
+const utils_1 = require("@atlaspack/utils");
+const Asset_1 = require("./Asset");
+const graph_1 = require("@atlaspack/graph");
+const Environment_1 = __importDefault(require("./Environment"));
+const Dependency_1 = require("./Dependency");
+const Target_1 = __importDefault(require("./Target"));
+const types_1 = require("../types");
+const projectPath_1 = require("../projectPath");
+const EnvironmentManager_1 = require("../EnvironmentManager");
+const inspect = Symbol.for('nodejs.util.inspect.custom');
+const internalBundleToBundle = new utils_1.DefaultWeakMap(() => new utils_1.DefaultWeakMap(() => new WeakMap()));
+const internalBundleToNamedBundle = new utils_1.DefaultWeakMap(() => new utils_1.DefaultWeakMap(() => new WeakMap()));
+const internalBundleToPackagedBundle = new utils_1.DefaultWeakMap(() => new utils_1.DefaultWeakMap(() => new WeakMap()));
+// Friendly access for other modules within this package that need access
+// to the internal bundle.
+const _bundleToInternalBundle = new WeakMap();
+function bundleToInternalBundle(bundle) {
+    return (0, nullthrows_1.default)(_bundleToInternalBundle.get(bundle));
+}
+const _bundleToInternalBundleGraph = new WeakMap();
+function bundleToInternalBundleGraph(bundle) {
+    return (0, nullthrows_1.default)(_bundleToInternalBundleGraph.get(bundle));
+}
+// Require this private object to be present when invoking these constructors,
+// preventing others from using them. They should use the static `get` method.
+let _private = {};
+class Bundle {
+    [(_Bundle_bundle = new WeakMap(), _Bundle_bundleGraph = new WeakMap(), _Bundle_options = new WeakMap(), inspect)]() {
+        return `Bundle(${__classPrivateFieldGet(this, _Bundle_bundle, "f").id})`;
+    }
+    constructor(sentinel, bundle, bundleGraph, options) {
+        _Bundle_bundle.set(this, void 0);
+        _Bundle_bundleGraph.set(this, void 0);
+        _Bundle_options.set(this, void 0);
+        if (sentinel !== _private) {
+            throw new Error('Unexpected public usage');
+        }
+        __classPrivateFieldSet(this, _Bundle_bundle, bundle, "f");
+        __classPrivateFieldSet(this, _Bundle_bundleGraph, bundleGraph, "f");
+        __classPrivateFieldSet(this, _Bundle_options, options, "f");
+    }
+    static get(internalBundle, bundleGraph, options) {
+        let existingMap = internalBundleToBundle.get(options).get(bundleGraph);
+        let existing = existingMap.get(internalBundle);
+        if (existing != null) {
+            return existing;
+        }
+        let bundle = new Bundle(_private, internalBundle, bundleGraph, options);
+        _bundleToInternalBundle.set(bundle, internalBundle);
+        _bundleToInternalBundleGraph.set(bundle, bundleGraph);
+        existingMap.set(internalBundle, bundle);
+        return bundle;
+    }
+    get id() {
+        return __classPrivateFieldGet(this, _Bundle_bundle, "f").id;
+    }
+    get hashReference() {
+        return __classPrivateFieldGet(this, _Bundle_bundle, "f").hashReference;
+    }
+    get type() {
+        return __classPrivateFieldGet(this, _Bundle_bundle, "f").type;
+    }
+    get env() {
+        return new Environment_1.default((0, EnvironmentManager_1.fromEnvironmentId)(__classPrivateFieldGet(this, _Bundle_bundle, "f").env), __classPrivateFieldGet(this, _Bundle_options, "f"));
+    }
+    get needsStableName() {
+        return __classPrivateFieldGet(this, _Bundle_bundle, "f").needsStableName;
+    }
+    get bundleBehavior() {
+        let bundleBehavior = __classPrivateFieldGet(this, _Bundle_bundle, "f").bundleBehavior;
+        return bundleBehavior != null ? types_1.BundleBehaviorNames[bundleBehavior] : null;
+    }
+    get isSplittable() {
+        return __classPrivateFieldGet(this, _Bundle_bundle, "f").isSplittable;
+    }
+    get manualSharedBundle() {
+        return __classPrivateFieldGet(this, _Bundle_bundle, "f").manualSharedBundle;
+    }
+    get target() {
+        return new Target_1.default(__classPrivateFieldGet(this, _Bundle_bundle, "f").target, __classPrivateFieldGet(this, _Bundle_options, "f"));
+    }
+    hasAsset(asset) {
+        return __classPrivateFieldGet(this, _Bundle_bundleGraph, "f").bundleHasAsset(__classPrivateFieldGet(this, _Bundle_bundle, "f"), (0, Asset_1.assetToAssetValue)(asset));
+    }
+    hasDependency(dep) {
+        return __classPrivateFieldGet(this, _Bundle_bundleGraph, "f").bundleHasDependency(__classPrivateFieldGet(this, _Bundle_bundle, "f"), (0, Dependency_1.dependencyToInternalDependency)(dep));
+    }
+    getEntryAssets() {
+        return __classPrivateFieldGet(this, _Bundle_bundle, "f").entryAssetIds.map((id) => {
+            let assetNode = __classPrivateFieldGet(this, _Bundle_bundleGraph, "f")._graph.getNodeByContentKey(id);
+            (0, assert_1.default)(assetNode != null && assetNode.type === 'asset');
+            return (0, Asset_1.assetFromValue)(assetNode.value, __classPrivateFieldGet(this, _Bundle_options, "f"));
+        });
+    }
+    getMainEntry() {
+        if (__classPrivateFieldGet(this, _Bundle_bundle, "f").mainEntryId != null) {
+            let assetNode = __classPrivateFieldGet(this, _Bundle_bundleGraph, "f")._graph.getNodeByContentKey(__classPrivateFieldGet(this, _Bundle_bundle, "f").mainEntryId);
+            (0, assert_1.default)(assetNode != null && assetNode.type === 'asset');
+            return (0, Asset_1.assetFromValue)(assetNode.value, __classPrivateFieldGet(this, _Bundle_options, "f"));
+        }
+    }
+    traverse(visit) {
+        return __classPrivateFieldGet(this, _Bundle_bundleGraph, "f").traverseBundle(__classPrivateFieldGet(this, _Bundle_bundle, "f"), 
+        // @ts-expect-error TS2345
+        (0, graph_1.mapVisitor)((node) => {
+            if (node.type === 'asset') {
+                return {
+                    type: 'asset',
+                    value: (0, Asset_1.assetFromValue)(node.value, __classPrivateFieldGet(this, _Bundle_options, "f")),
+                };
+            }
+            else if (node.type === 'dependency') {
+                return {
+                    type: 'dependency',
+                    value: (0, Dependency_1.getPublicDependency)(node.value, __classPrivateFieldGet(this, _Bundle_options, "f")),
+                };
+            }
+        }, visit));
+    }
+    traverseAssets(visit, startAsset) {
+        return __classPrivateFieldGet(this, _Bundle_bundleGraph, "f").traverseAssets(__classPrivateFieldGet(this, _Bundle_bundle, "f"), (0, graph_1.mapVisitor)((asset) => (0, Asset_1.assetFromValue)(asset, __classPrivateFieldGet(this, _Bundle_options, "f")), visit), startAsset ? (0, Asset_1.assetToAssetValue)(startAsset) : undefined);
+    }
+}
+exports.Bundle = Bundle;
+class NamedBundle extends Bundle {
+    constructor(sentinel, bundle, bundleGraph, options) {
+        super(sentinel, bundle, bundleGraph, options);
+        _NamedBundle_bundle.set(this, void 0);
+        _NamedBundle_bundleGraph.set(this, void 0);
+        _NamedBundle_options.set(this, void 0);
+        __classPrivateFieldSet(this, _NamedBundle_bundle, bundle, "f"); // Repeating for flow
+        __classPrivateFieldSet(this, _NamedBundle_bundleGraph, bundleGraph, "f"); // Repeating for flow
+        __classPrivateFieldSet(this, _NamedBundle_options, options, "f");
+    }
+    static get(internalBundle, bundleGraph, options) {
+        let existingMap = internalBundleToNamedBundle.get(options).get(bundleGraph);
+        let existing = existingMap.get(internalBundle);
+        if (existing != null) {
+            return existing;
+        }
+        let namedBundle = new NamedBundle(_private, internalBundle, bundleGraph, options);
+        _bundleToInternalBundle.set(namedBundle, internalBundle);
+        _bundleToInternalBundleGraph.set(namedBundle, bundleGraph);
+        existingMap.set(internalBundle, namedBundle);
+        return namedBundle;
+    }
+    get name() {
+        return (0, nullthrows_1.default)(__classPrivateFieldGet(this, _NamedBundle_bundle, "f").name);
+    }
+    get displayName() {
+        return (0, nullthrows_1.default)(__classPrivateFieldGet(this, _NamedBundle_bundle, "f").displayName);
+    }
+    get publicId() {
+        return (0, nullthrows_1.default)(__classPrivateFieldGet(this, _NamedBundle_bundle, "f").publicId);
+    }
+}
+exports.NamedBundle = NamedBundle;
+_NamedBundle_bundle = new WeakMap(), _NamedBundle_bundleGraph = new WeakMap(), _NamedBundle_options = new WeakMap();
+class PackagedBundle extends NamedBundle {
+    constructor(sentinel, bundle, bundleGraph, options) {
+        super(sentinel, bundle, bundleGraph, options);
+        _PackagedBundle_bundle.set(this, void 0);
+        _PackagedBundle_bundleGraph.set(this, void 0);
+        _PackagedBundle_options.set(this, void 0);
+        _PackagedBundle_bundleInfo.set(this, void 0);
+        __classPrivateFieldSet(this, _PackagedBundle_bundle, bundle, "f"); // Repeating for flow
+        __classPrivateFieldSet(this, _PackagedBundle_bundleGraph, bundleGraph, "f"); // Repeating for flow
+        __classPrivateFieldSet(this, _PackagedBundle_options, options, "f"); // Repeating for flow
+    }
+    static get(internalBundle, bundleGraph, options) {
+        let existingMap = internalBundleToPackagedBundle
+            .get(options)
+            .get(bundleGraph);
+        let existing = existingMap.get(internalBundle);
+        if (existing != null) {
+            return existing;
+        }
+        let packagedBundle = new PackagedBundle(_private, internalBundle, bundleGraph, options);
+        _bundleToInternalBundle.set(packagedBundle, internalBundle);
+        _bundleToInternalBundleGraph.set(packagedBundle, bundleGraph);
+        existingMap.set(internalBundle, packagedBundle);
+        return packagedBundle;
+    }
+    static getWithInfo(internalBundle, bundleGraph, options, bundleInfo) {
+        let packagedBundle = PackagedBundle.get(internalBundle, bundleGraph, options);
+        __classPrivateFieldSet(packagedBundle, _PackagedBundle_bundleInfo, bundleInfo, "f");
+        return packagedBundle;
+    }
+    get filePath() {
+        return (0, projectPath_1.fromProjectPath)(__classPrivateFieldGet(this, _PackagedBundle_options, "f").projectRoot, (0, nullthrows_1.default)(__classPrivateFieldGet(this, _PackagedBundle_bundleInfo, "f")).filePath);
+    }
+    get type() {
+        // The bundle type may be overridden in the packager.
+        // However, inline bundles will not have a bundleInfo here since they are not written to the filesystem.
+        return __classPrivateFieldGet(this, _PackagedBundle_bundleInfo, "f") ? __classPrivateFieldGet(this, _PackagedBundle_bundleInfo, "f").type : __classPrivateFieldGet(this, _PackagedBundle_bundle, "f").type;
+    }
+    get stats() {
+        return (0, nullthrows_1.default)(__classPrivateFieldGet(this, _PackagedBundle_bundleInfo, "f")).stats;
+    }
+}
+exports.PackagedBundle = PackagedBundle;
+_PackagedBundle_bundle = new WeakMap(), _PackagedBundle_bundleGraph = new WeakMap(), _PackagedBundle_options = new WeakMap(), _PackagedBundle_bundleInfo = new WeakMap();

package/dist/public/BundleGraph.js

@@ -0,0 +1,371 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _BundleGraph_graph, _BundleGraph_options, _BundleGraph_createBundle;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bundleGraphToInternalBundleGraph = bundleGraphToInternalBundleGraph;
+const assert_1 = __importDefault(require("assert"));
+const nullthrows_1 = __importDefault(require("nullthrows"));
+const graph_1 = require("@atlaspack/graph");
+const Asset_1 = require("./Asset");
+const Bundle_1 = require("./Bundle");
+const Dependency_1 = __importStar(require("./Dependency"));
+const Target_1 = require("./Target");
+const utils_1 = require("../utils");
+const BundleGroup_1 = __importStar(require("./BundleGroup"));
+// Friendly access for other modules within this package that need access
+// to the internal bundle.
+const _bundleGraphToInternalBundleGraph = new WeakMap();
+function bundleGraphToInternalBundleGraph(bundleGraph) {
+    return (0, nullthrows_1.default)(_bundleGraphToInternalBundleGraph.get(bundleGraph));
+}
+class BundleGraph {
+    constructor(graph, createBundle, options) {
+        _BundleGraph_graph.set(this, void 0);
+        _BundleGraph_options.set(this, void 0);
+        _BundleGraph_createBundle.set(this, void 0);
+        __classPrivateFieldSet(this, _BundleGraph_graph, graph, "f");
+        __classPrivateFieldSet(this, _BundleGraph_options, options, "f");
+        __classPrivateFieldSet(this, _BundleGraph_createBundle, createBundle, "f");
+        _bundleGraphToInternalBundleGraph.set(this, graph);
+    }
+    getAssetById(id) {
+        return (0, Asset_1.assetFromValue)(__classPrivateFieldGet(this, _BundleGraph_graph, "f").getAssetById(id), __classPrivateFieldGet(this, _BundleGraph_options, "f"));
+    }
+    getAssetPublicId(asset) {
+        return __classPrivateFieldGet(this, _BundleGraph_graph, "f").getAssetPublicId((0, Asset_1.assetToAssetValue)(asset));
+    }
+    isDependencySkipped(dep) {
+        return __classPrivateFieldGet(this, _BundleGraph_graph, "f").isDependencySkipped((0, Dependency_1.dependencyToInternalDependency)(dep));
+    }
+    getResolvedAsset(dep, bundle) {
+        let resolution = __classPrivateFieldGet(this, _BundleGraph_graph, "f").getResolvedAsset((0, Dependency_1.dependencyToInternalDependency)(dep), bundle && (0, Bundle_1.bundleToInternalBundle)(bundle));
+        if (resolution) {
+            return (0, Asset_1.assetFromValue)(resolution, __classPrivateFieldGet(this, _BundleGraph_options, "f"));
+        }
+    }
+    getIncomingDependencies(asset) {
+        return __classPrivateFieldGet(this, _BundleGraph_graph, "f")
+            .getIncomingDependencies((0, Asset_1.assetToAssetValue)(asset))
+            .map((dep) => (0, Dependency_1.getPublicDependency)(dep, __classPrivateFieldGet(this, _BundleGraph_options, "f")));
+    }
+    getAssetWithDependency(dep) {
+        let asset = __classPrivateFieldGet(this, _BundleGraph_graph, "f").getAssetWithDependency((0, Dependency_1.dependencyToInternalDependency)(dep));
+        if (asset) {
+            return (0, Asset_1.assetFromValue)(asset, __classPrivateFieldGet(this, _BundleGraph_options, "f"));
+        }
+    }
+    getBundleGroupsContainingBundle(bundle) {
+        return __classPrivateFieldGet(this, _BundleGraph_graph, "f")
+            .getBundleGroupsContainingBundle((0, Bundle_1.bundleToInternalBundle)(bundle))
+            .map((bundleGroup) => new BundleGroup_1.default(bundleGroup, __classPrivateFieldGet(this, _BundleGraph_options, "f")));
+    }
+    getReferencedBundles(bundle, opts) {
+        return __classPrivateFieldGet(this, _BundleGraph_graph, "f")
+            .getReferencedBundles((0, Bundle_1.bundleToInternalBundle)(bundle), opts)
+            .map((bundle) => __classPrivateFieldGet(this, _BundleGraph_createBundle, "f").call(this, bundle, __classPrivateFieldGet(this, _BundleGraph_graph, "f"), __classPrivateFieldGet(this, _BundleGraph_options, "f")));
+    }
+    getReferencingBundles(bundle) {
+        return __classPrivateFieldGet(this, _BundleGraph_graph, "f")
+            .getReferencingBundles((0, Bundle_1.bundleToInternalBundle)(bundle))
+            .map((bundle) => __classPrivateFieldGet(this, _BundleGraph_createBundle, "f").call(this, bundle, __classPrivateFieldGet(this, _BundleGraph_graph, "f"), __classPrivateFieldGet(this, _BundleGraph_options, "f")));
+    }
+    resolveAsyncDependency(dependency, bundle) {
+        let resolved = __classPrivateFieldGet(this, _BundleGraph_graph, "f").resolveAsyncDependency((0, Dependency_1.dependencyToInternalDependency)(dependency), bundle && (0, Bundle_1.bundleToInternalBundle)(bundle));
+        if (resolved == null) {
+            return;
+        }
+        else if (resolved.type === 'bundle_group') {
+            return {
+                type: 'bundle_group',
+                value: new BundleGroup_1.default(resolved.value, __classPrivateFieldGet(this, _BundleGraph_options, "f")),
+            };
+        }
+        return {
+            type: 'asset',
+            value: (0, Asset_1.assetFromValue)(resolved.value, __classPrivateFieldGet(this, _BundleGraph_options, "f")),
+        };
+    }
+    getReferencedBundle(dependency, bundle) {
+        let result = __classPrivateFieldGet(this, _BundleGraph_graph, "f").getReferencedBundle((0, Dependency_1.dependencyToInternalDependency)(dependency), (0, Bundle_1.bundleToInternalBundle)(bundle));
+        if (result != null) {
+            return __classPrivateFieldGet(this, _BundleGraph_createBundle, "f").call(this, result, __classPrivateFieldGet(this, _BundleGraph_graph, "f"), __classPrivateFieldGet(this, _BundleGraph_options, "f"));
+        }
+    }
+    getDependencies(asset) {
+        return __classPrivateFieldGet(this, _BundleGraph_graph, "f")
+            .getDependencies((0, Asset_1.assetToAssetValue)(asset))
+            .map((dep) => (0, Dependency_1.getPublicDependency)(dep, __classPrivateFieldGet(this, _BundleGraph_options, "f")));
+    }
+    isAssetReachableFromBundle(asset, bundle) {
+        return __classPrivateFieldGet(this, _BundleGraph_graph, "f").isAssetReachableFromBundle((0, Asset_1.assetToAssetValue)(asset), (0, Bundle_1.bundleToInternalBundle)(bundle));
+    }
+    isAssetReferenced(bundle, asset) {
+        return __classPrivateFieldGet(this, _BundleGraph_graph, "f").isAssetReferenced((0, Bundle_1.bundleToInternalBundle)(bundle), (0, Asset_1.assetToAssetValue)(asset));
+    }
+    isAssetReferencedFastCheck(bundle, asset) {
+        return __classPrivateFieldGet(this, _BundleGraph_graph, "f").isAssetReferencedFastCheck((0, Bundle_1.bundleToInternalBundle)(bundle), (0, Asset_1.assetToAssetValue)(asset));
+    }
+    getReferencedAssets(bundle) {
+        let internalReferencedAssets = __classPrivateFieldGet(this, _BundleGraph_graph, "f").getReferencedAssets((0, Bundle_1.bundleToInternalBundle)(bundle));
+        // Convert internal assets to public assets
+        let publicReferencedAssets = new Set();
+        for (let internalAsset of internalReferencedAssets) {
+            publicReferencedAssets.add((0, Asset_1.assetFromValue)(internalAsset, __classPrivateFieldGet(this, _BundleGraph_options, "f")));
+        }
+        return publicReferencedAssets;
+    }
+    hasParentBundleOfType(bundle, type) {
+        return __classPrivateFieldGet(this, _BundleGraph_graph, "f").hasParentBundleOfType((0, Bundle_1.bundleToInternalBundle)(bundle), type);
+    }
+    getBundlesInBundleGroup(bundleGroup, opts) {
+        return __classPrivateFieldGet(this, _BundleGraph_graph, "f")
+            .getBundlesInBundleGroup((0, BundleGroup_1.bundleGroupToInternalBundleGroup)(bundleGroup), opts)
+            .map((bundle) => __classPrivateFieldGet(this, _BundleGraph_createBundle, "f").call(this, bundle, __classPrivateFieldGet(this, _BundleGraph_graph, "f"), __classPrivateFieldGet(this, _BundleGraph_options, "f")));
+    }
+    getBundles(opts) {
+        return __classPrivateFieldGet(this, _BundleGraph_graph, "f")
+            .getBundles(opts)
+            .map((bundle) => __classPrivateFieldGet(this, _BundleGraph_createBundle, "f").call(this, bundle, __classPrivateFieldGet(this, _BundleGraph_graph, "f"), __classPrivateFieldGet(this, _BundleGraph_options, "f")));
+    }
+    isEntryBundleGroup(bundleGroup) {
+        return __classPrivateFieldGet(this, _BundleGraph_graph, "f").isEntryBundleGroup((0, BundleGroup_1.bundleGroupToInternalBundleGroup)(bundleGroup));
+    }
+    getChildBundles(bundle) {
+        return __classPrivateFieldGet(this, _BundleGraph_graph, "f")
+            .getChildBundles((0, Bundle_1.bundleToInternalBundle)(bundle))
+            .map((bundle) => __classPrivateFieldGet(this, _BundleGraph_createBundle, "f").call(this, bundle, __classPrivateFieldGet(this, _BundleGraph_graph, "f"), __classPrivateFieldGet(this, _BundleGraph_options, "f")));
+    }
+    getParentBundles(bundle) {
+        return __classPrivateFieldGet(this, _BundleGraph_graph, "f")
+            .getParentBundles((0, Bundle_1.bundleToInternalBundle)(bundle))
+            .map((bundle) => __classPrivateFieldGet(this, _BundleGraph_createBundle, "f").call(this, bundle, __classPrivateFieldGet(this, _BundleGraph_graph, "f"), __classPrivateFieldGet(this, _BundleGraph_options, "f")));
+    }
+    getSymbolResolution(asset, symbol, boundary) {
+        let res = __classPrivateFieldGet(this, _BundleGraph_graph, "f").getSymbolResolution((0, Asset_1.assetToAssetValue)(asset), symbol, boundary ? (0, Bundle_1.bundleToInternalBundle)(boundary) : null);
+        return {
+            asset: (0, Asset_1.assetFromValue)(res.asset, __classPrivateFieldGet(this, _BundleGraph_options, "f")),
+            exportSymbol: res.exportSymbol,
+            symbol: res.symbol,
+            loc: (0, utils_1.fromInternalSourceLocation)(__classPrivateFieldGet(this, _BundleGraph_options, "f").projectRoot, res.loc),
+        };
+    }
+    getExportedSymbols(asset, boundary) {
+        let res = __classPrivateFieldGet(this, _BundleGraph_graph, "f").getExportedSymbols((0, Asset_1.assetToAssetValue)(asset), boundary ? (0, Bundle_1.bundleToInternalBundle)(boundary) : null);
+        return res.map((e) => ({
+            asset: (0, Asset_1.assetFromValue)(e.asset, __classPrivateFieldGet(this, _BundleGraph_options, "f")),
+            exportSymbol: e.exportSymbol,
+            symbol: e.symbol,
+            loc: (0, utils_1.fromInternalSourceLocation)(__classPrivateFieldGet(this, _BundleGraph_options, "f").projectRoot, e.loc),
+            exportAs: e.exportAs,
+        }));
+    }
+    traverse(visit, start, opts) {
+        return __classPrivateFieldGet(this, _BundleGraph_graph, "f").traverse(
+        // @ts-expect-error TS2345
+        (0, graph_1.mapVisitor)((node, actions) => {
+            // Skipping unused dependencies here is faster than doing an isDependencySkipped check inside the visitor
+            // because the node needs to be re-looked up by id from the hashmap.
+            if (opts?.skipUnusedDependencies &&
+                node.type === 'dependency' &&
+                (node.hasDeferred || node.excluded)) {
+                actions.skipChildren();
+                return null;
+            }
+            return node.type === 'asset'
+                ? { type: 'asset', value: (0, Asset_1.assetFromValue)(node.value, __classPrivateFieldGet(this, _BundleGraph_options, "f")) }
+                : {
+                    type: 'dependency',
+                    value: (0, Dependency_1.getPublicDependency)(node.value, __classPrivateFieldGet(this, _BundleGraph_options, "f")),
+                };
+        }, visit), start ? (0, Asset_1.assetToAssetValue)(start) : undefined);
+    }
+    traverseBundles(visit, startBundle) {
+        return __classPrivateFieldGet(this, _BundleGraph_graph, "f").traverseBundles((0, graph_1.mapVisitor)((bundle) => __classPrivateFieldGet(this, _BundleGraph_createBundle, "f").call(this, bundle, __classPrivateFieldGet(this, _BundleGraph_graph, "f"), __classPrivateFieldGet(this, _BundleGraph_options, "f")), visit), startBundle == null ? undefined : (0, Bundle_1.bundleToInternalBundle)(startBundle));
+    }
+    getBundlesWithAsset(asset) {
+        return __classPrivateFieldGet(this, _BundleGraph_graph, "f")
+            .getBundlesWithAsset((0, Asset_1.assetToAssetValue)(asset))
+            .map((bundle) => __classPrivateFieldGet(this, _BundleGraph_createBundle, "f").call(this, bundle, __classPrivateFieldGet(this, _BundleGraph_graph, "f"), __classPrivateFieldGet(this, _BundleGraph_options, "f")));
+    }
+    getBundlesWithDependency(dependency) {
+        return __classPrivateFieldGet(this, _BundleGraph_graph, "f")
+            .getBundlesWithDependency((0, Dependency_1.dependencyToInternalDependency)(dependency))
+            .map((bundle) => __classPrivateFieldGet(this, _BundleGraph_createBundle, "f").call(this, bundle, __classPrivateFieldGet(this, _BundleGraph_graph, "f"), __classPrivateFieldGet(this, _BundleGraph_options, "f")));
+    }
+    getUsedSymbols(v) {
+        if (v instanceof Asset_1.Asset) {
+            return __classPrivateFieldGet(this, _BundleGraph_graph, "f").getUsedSymbolsAsset((0, Asset_1.assetToAssetValue)(v));
+        }
+        else {
+            (0, assert_1.default)(v instanceof Dependency_1.default);
+            return __classPrivateFieldGet(this, _BundleGraph_graph, "f").getUsedSymbolsDependency((0, Dependency_1.dependencyToInternalDependency)(v));
+        }
+    }
+    getEntryRoot(target) {
+        return __classPrivateFieldGet(this, _BundleGraph_graph, "f").getEntryRoot(__classPrivateFieldGet(this, _BundleGraph_options, "f").projectRoot, (0, Target_1.targetToInternalTarget)(target));
+    }
+    // Given a set of dependencies, return any conditions where those dependencies are either
+    // the true or false dependency for those conditions. This is currently used to work out which
+    // conditions belong to a bundle in packaging.
+    getConditionsForDependencies(deps, bundle) {
+        const conditions = new Set();
+        const depIds = deps.map((dep) => dep.id);
+        for (const condition of __classPrivateFieldGet(this, _BundleGraph_graph, "f")._conditions.values()) {
+            if (depIds.includes(condition.ifTrueDependency.id) ||
+                depIds.includes(condition.ifFalseDependency.id)) {
+                const [[trueAsset, ifTrueBundles], [falseAsset, ifFalseBundles]] = [
+                    condition.ifTrueDependency,
+                    condition.ifFalseDependency,
+                ].map((dep) => {
+                    const asset = __classPrivateFieldGet(this, _BundleGraph_graph, "f").getResolvedAsset(dep, (0, Bundle_1.bundleToInternalBundle)(bundle));
+                    if (asset &&
+                        __classPrivateFieldGet(this, _BundleGraph_graph, "f").bundleHasAsset((0, Bundle_1.bundleToInternalBundle)(bundle), asset)) {
+                        // Asset is in the same bundle, we know it doesn't need to be loaded externally
+                        return [asset, []];
+                    }
+                    const resolvedAsync = __classPrivateFieldGet(this, _BundleGraph_graph, "f").resolveAsyncDependency(dep, (0, Bundle_1.bundleToInternalBundle)(bundle));
+                    if (resolvedAsync?.type === 'asset') {
+                        // Single bundle to load dynamically
+                        return [
+                            resolvedAsync.value,
+                            [
+                                __classPrivateFieldGet(this, _BundleGraph_createBundle, "f").call(this, (0, nullthrows_1.default)(__classPrivateFieldGet(this, _BundleGraph_graph, "f").getReferencedBundle(dep, (0, Bundle_1.bundleToInternalBundle)(bundle)), `Failed to load referenced bundle for '${dep.specifier}' specifier from '${String(dep.sourcePath)}'`), __classPrivateFieldGet(this, _BundleGraph_graph, "f"), __classPrivateFieldGet(this, _BundleGraph_options, "f")),
+                            ],
+                        ];
+                    }
+                    else if (resolvedAsync) {
+                        // Bundle group means we have multiple bundles to load first
+                        return [
+                            __classPrivateFieldGet(this, _BundleGraph_graph, "f").getAssetById(resolvedAsync.value.entryAssetId),
+                            __classPrivateFieldGet(this, _BundleGraph_graph, "f")
+                                .getBundlesInBundleGroup(resolvedAsync.value)
+                                .map((b) => __classPrivateFieldGet(this, _BundleGraph_createBundle, "f").call(this, b, __classPrivateFieldGet(this, _BundleGraph_graph, "f"), __classPrivateFieldGet(this, _BundleGraph_options, "f"))),
+                        ];
+                    }
+                    else {
+                        return [
+                            (0, nullthrows_1.default)(asset, `Failed to load depenendency for '${dep.specifier}' specifier from '${String(dep.sourcePath)}'`),
+                            [],
+                        ];
+                    }
+                });
+                conditions.add({
+                    publicId: condition.publicId,
+                    key: condition.key,
+                    ifTrueDependency: (0, nullthrows_1.default)(deps.find((dep) => dep.id === condition.ifTrueDependency.id), 'ifTrueDependency was null'),
+                    ifFalseDependency: (0, nullthrows_1.default)(deps.find((dep) => dep.id === condition.ifFalseDependency.id), 'ifFalseDependency was null'),
+                    ifTrueBundles,
+                    ifFalseBundles,
+                    ifTrueAssetId: __classPrivateFieldGet(this, _BundleGraph_graph, "f").getAssetPublicId(trueAsset),
+                    ifFalseAssetId: __classPrivateFieldGet(this, _BundleGraph_graph, "f").getAssetPublicId(falseAsset),
+                });
+            }
+        }
+        // @ts-expect-error TS2322
+        return conditions;
+    }
+    // This is used to generate information for building a manifest that can
+    // be used by a webserver to understand which conditions are used by which bundles,
+    // and which bundles those conditions require depending on what they evaluate to.
+    getConditionalBundleMapping() {
+        let bundleConditions = new Map();
+        // Convert the internal references in conditions to public API references
+        for (const cond of __classPrivateFieldGet(this, _BundleGraph_graph, "f")._conditions.values()) {
+            let assets = Array.from(cond.assets).map((asset) => (0, nullthrows_1.default)(this.getAssetById(asset.id)));
+            let bundles = new Set();
+            let ifTrueBundles = [];
+            let ifFalseBundles = [];
+            for (const asset of assets) {
+                const bundlesWithAsset = this.getBundlesWithAsset(asset);
+                for (const bundle of bundlesWithAsset) {
+                    bundles.add(bundle);
+                }
+                const assetDeps = this.getDependencies(asset);
+                const depToBundles = (dep) => {
+                    const publicDep = (0, nullthrows_1.default)(assetDeps.find((assetDep) => dep.id === assetDep.id));
+                    const resolved = this.resolveAsyncDependency(publicDep);
+                    if (!resolved) {
+                        // If there's no async dependency, don't list it as required
+                        return [];
+                    }
+                    (0, assert_1.default)(resolved.type === 'bundle_group');
+                    return this.getBundlesInBundleGroup(resolved.value);
+                };
+                // @ts-expect-error TS2345
+                ifTrueBundles.push(...depToBundles(cond.ifTrueDependency));
+                // @ts-expect-error TS2345
+                ifFalseBundles.push(...depToBundles(cond.ifFalseDependency));
+            }
+            for (let bundle of bundles) {
+                const conditions = bundleConditions.get(bundle.id) ?? new Map();
+                const currentCondition = conditions.get(cond.key);
+                conditions.set(cond.key, {
+                    bundle,
+                    ifTrueBundles: [
+                        ...(currentCondition?.ifTrueBundles ?? []),
+                        ...ifTrueBundles,
+                    ],
+                    ifFalseBundles: [
+                        ...(currentCondition?.ifFalseBundles ?? []),
+                        ...ifFalseBundles,
+                    ],
+                });
+                bundleConditions.set(bundle.id, conditions);
+            }
+        }
+        return bundleConditions;
+    }
+    getReferencedConditionalBundles(bundle) {
+        return __classPrivateFieldGet(this, _BundleGraph_graph, "f")
+            .getReferencedConditionalBundles((0, Bundle_1.bundleToInternalBundle)(bundle))
+            .map((result) => __classPrivateFieldGet(this, _BundleGraph_createBundle, "f").call(this, result, __classPrivateFieldGet(this, _BundleGraph_graph, "f"), __classPrivateFieldGet(this, _BundleGraph_options, "f")));
+    }
+}
+_BundleGraph_graph = new WeakMap(), _BundleGraph_options = new WeakMap(), _BundleGraph_createBundle = new WeakMap();
+exports.default = BundleGraph;

package/dist/public/BundleGroup.js

@@ -0,0 +1,53 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _BundleGroup_bundleGroup, _BundleGroup_options;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bundleGroupToInternalBundleGroup = bundleGroupToInternalBundleGroup;
+const nullthrows_1 = __importDefault(require("nullthrows"));
+const Target_1 = __importDefault(require("./Target"));
+const internalBundleGroupToBundleGroup = new WeakMap();
+const _bundleGroupToInternalBundleGroup = new WeakMap();
+function bundleGroupToInternalBundleGroup(target) {
+    return (0, nullthrows_1.default)(_bundleGroupToInternalBundleGroup.get(target));
+}
+const inspect = Symbol.for('nodejs.util.inspect.custom');
+class BundleGroup {
+    constructor(bundleGroup, options) {
+        // @ts-expect-error TS2564
+        _BundleGroup_bundleGroup.set(this, void 0);
+        // @ts-expect-error TS2564
+        _BundleGroup_options.set(this, void 0);
+        let existing = internalBundleGroupToBundleGroup.get(bundleGroup);
+        if (existing != null) {
+            return existing;
+        }
+        __classPrivateFieldSet(this, _BundleGroup_bundleGroup, bundleGroup, "f");
+        __classPrivateFieldSet(this, _BundleGroup_options, options, "f");
+        _bundleGroupToInternalBundleGroup.set(this, bundleGroup);
+        internalBundleGroupToBundleGroup.set(bundleGroup, this);
+        return this;
+    }
+    get target() {
+        return new Target_1.default(__classPrivateFieldGet(this, _BundleGroup_bundleGroup, "f").target, __classPrivateFieldGet(this, _BundleGroup_options, "f"));
+    }
+    get entryAssetId() {
+        return __classPrivateFieldGet(this, _BundleGroup_bundleGroup, "f").entryAssetId;
+    }
+    [(_BundleGroup_bundleGroup = new WeakMap(), _BundleGroup_options = new WeakMap(), inspect)]() {
+        return `BundleGroup(${this.entryAssetId})`;
+    }
+}
+exports.default = BundleGroup;