@atlaspack/core 2.12.1-canary.3432 → 2.12.1-canary.3434

package/lib/Atlaspack.js

@@ -151,6 +151,11 @@ class Atlaspack {
     if (this.#initialized) {
       return;
     }
+    const featureFlags = {
+      ..._featureFlags().DEFAULT_FEATURE_FLAGS,
+      ...this.#initialOptions.featureFlags
+    };
+    (0, _featureFlags().setFeatureFlags)(featureFlags);
     await _sourceMap().init;
     await (_rust().init === null || _rust().init === void 0 ? void 0 : (0, _rust().init)());
     try {
@@ -162,7 +167,10 @@ class Atlaspack {
       // Fallthrough
       _logger().default.warn(e);
     }
-    let resolvedOptions = await (0, _resolveOptions.default)(this.#initialOptions);
+    let resolvedOptions = await (0, _resolveOptions.default)({
+      ...this.#initialOptions,
+      featureFlags
+    });
     this.#resolvedOptions = resolvedOptions;
     let rustAtlaspack;
     if (resolvedOptions.featureFlags.atlaspackV3) {
@@ -192,7 +200,6 @@ class Atlaspack {
         }
       });
     }
-    (0, _featureFlags().setFeatureFlags)(resolvedOptions.featureFlags);
     let {
       config
     } = await (0, _AtlaspackConfigRequest.loadAtlaspackConfig)(resolvedOptions);

package/lib/BundleGraph.js

@@ -44,6 +44,13 @@ var _utils2 = require("./utils");
 var _Environment = require("./public/Environment");
 var _projectPath = require("./projectPath");
 var _constants = require("./constants");
+function _featureFlags() {
+  const data = require("@atlaspack/feature-flags");
+  _featureFlags = function () {
+    return data;
+  };
+  return data;
+}
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 const bundleGraphEdgeTypes = exports.bundleGraphEdgeTypes = {
   // A lack of an edge type indicates to follow the edge while traversing
@@ -107,16 +114,19 @@ class BundleGraph {
   /** The internal core Graph structure */
 
   _bundlePublicIds /*: Set<string> */ = new Set();
+  _conditions /*: Map<string, Condition> */ = new Map();
   constructor({
     graph,
     publicIdByAssetId,
     assetPublicIds,
-    bundleContentHashes
+    bundleContentHashes,
+    conditions
   }) {
     this._graph = graph;
     this._assetPublicIds = assetPublicIds;
     this._publicIdByAssetId = publicIdByAssetId;
     this._bundleContentHashes = bundleContentHashes;
+    this._conditions = conditions;
   }
 
   /**
@@ -128,6 +138,8 @@ class BundleGraph {
     let assetGroupIds = new Map();
     let dependencies = new Map();
     let assetGraphNodeIdToBundleGraphNodeId = new Map();
+    let conditions = new Map();
+    let placeholderToDependency = new Map();
     let assetGraphRootNode = assetGraph.rootNodeId != null ? assetGraph.getNode(assetGraph.rootNodeId) : null;
     (0, _assert().default)(assetGraphRootNode != null && assetGraphRootNode.type === 'root');
     assetGraph.dfsFast(nodeId => {
@@ -146,6 +158,17 @@ class BundleGraph {
         }
       } else if (node != null && node.type === 'asset_group') {
         assetGroupIds.set(nodeId, assetGraph.getNodeIdsConnectedFrom(nodeId));
+      } else if ((0, _featureFlags().getFeatureFlag)('conditionalBundlingApi') && node != null && node.type === 'dependency') {
+        var _dep$meta;
+        // The dependency placeholders in the `importCond` calls that will be in the transformed
+        // code need to be mapped to the "real" dependencies, so we need access to a map of placeholders
+        // to dependencies
+        const dep = node.value;
+        // $FlowFixMe[incompatible-type] Meta is untyped
+        const placeholder = (_dep$meta = dep.meta) === null || _dep$meta === void 0 ? void 0 : _dep$meta.placeholder;
+        if (placeholder != null) {
+          placeholderToDependency.set(placeholder, dep);
+        }
       }
     });
     let walkVisited = new Set();
@@ -153,6 +176,34 @@ class BundleGraph {
       if (walkVisited.has(nodeId)) return;
       walkVisited.add(nodeId);
       let node = (0, _nullthrows().default)(assetGraph.getNode(nodeId));
+      if ((0, _featureFlags().getFeatureFlag)('conditionalBundlingApi') && node.type === 'asset') {
+        const asset = node.value;
+        if (Array.isArray(asset.meta.conditions)) {
+          // $FlowFixMe
+          for (const condition of asset.meta.conditions) {
+            // Resolve the placeholders that were attached to the asset in JSTransformer to dependencies,
+            // as well as create a public id for the condition.
+            const {
+              key,
+              ifTruePlaceholder,
+              ifFalsePlaceholder
+            } = condition;
+            const condHash = (0, _rust().hashString)(`${key}:${ifTruePlaceholder}:${ifFalsePlaceholder}`);
+            const condPublicId = (0, _utils2.getPublicId)(condHash, v => conditions.has(v));
+            if (conditions.has(condHash)) {
+              throw new Error('Unexpected duplicate asset');
+            } else {
+              conditions.set(condHash, {
+                publicId: condPublicId,
+                assets: new Set([asset]),
+                key,
+                ifTrueDependency: (0, _nullthrows().default)(placeholderToDependency.get(ifTruePlaceholder), 'ifTruePlaceholder was undefined'),
+                ifFalseDependency: (0, _nullthrows().default)(placeholderToDependency.get(ifFalsePlaceholder), 'ifFalsePlaceholder was undefined')
+              });
+            }
+          }
+        }
+      }
       if (node.type === 'dependency' && node.value.symbols != null && node.value.env.shouldScopeHoist &&
       // Disable in dev mode because this feature is at odds with safeToIncrementallyBundle
       isProduction) {
@@ -338,7 +389,8 @@ class BundleGraph {
       graph,
       assetPublicIds,
       bundleContentHashes: new Map(),
-      publicIdByAssetId
+      publicIdByAssetId,
+      conditions
     });
   }
   serialize() {
@@ -347,7 +399,8 @@ class BundleGraph {
       graph: this._graph.serialize(),
       assetPublicIds: this._assetPublicIds,
       bundleContentHashes: this._bundleContentHashes,
-      publicIdByAssetId: this._publicIdByAssetId
+      publicIdByAssetId: this._publicIdByAssetId,
+      conditions: this._conditions
     };
   }
   static deserialize(serialized) {
@@ -355,7 +408,8 @@ class BundleGraph {
       graph: _graph().ContentGraph.deserialize(serialized.graph),
       assetPublicIds: serialized.assetPublicIds,
       bundleContentHashes: serialized.bundleContentHashes,
-      publicIdByAssetId: serialized.publicIdByAssetId
+      publicIdByAssetId: serialized.publicIdByAssetId,
+      conditions: serialized.conditions
     });
   }
   createBundle(opts) {
@@ -768,7 +822,7 @@ class BundleGraph {
       return true;
     }
     let assetNodeId = (0, _nullthrows().default)(this._graph.getNodeIdByContentKey(asset.id));
-    if (this._graph.getNodeIdsConnectedTo(assetNodeId, bundleGraphEdgeTypes.references).map(id => this._graph.getNode(id)).some(node => (node === null || node === void 0 ? void 0 : node.type) === 'dependency' && node.value.priority === _types.Priority.lazy && node.value.specifierType !== _types.SpecifierType.url)) {
+    if (this._graph.getNodeIdsConnectedTo(assetNodeId, bundleGraphEdgeTypes.references).map(id => this._graph.getNode(id)).some(node => (node === null || node === void 0 ? void 0 : node.type) === 'dependency' && (node.value.priority === _types.Priority.lazy || node.value.priority === _types.Priority.conditional) && node.value.specifierType !== _types.SpecifierType.url)) {
       // If this asset is referenced by any async dependency, it's referenced.
       return true;
     }

package/lib/SymbolPropagation.js

@@ -108,7 +108,7 @@ function propagateSymbols({
       namespaceReexportedSymbols.add('*');
     } else {
       for (let incomingDep of incomingDeps) {
-        if (incomingDep.value.symbols == null) {
+        if (incomingDep.value.symbols == null || incomingDep.value.priority === _types.Priority.conditional) {
           if (incomingDep.value.sourceAssetId == null) {
             // The root dependency on non-library builds
             isEntry = true;

package/lib/atlaspack-v3/worker/worker.js

@@ -180,5 +180,6 @@ napi().registerWorker(_worker_threads().workerData.tx_worker, new AtlaspackWorke
 const PriorityMap = {
   sync: 0,
   parallel: 1,
-  lazy: 2
+  lazy: 2,
+  conditional: 3
 };

package/lib/public/BundleGraph.js

@@ -189,5 +189,73 @@ class BundleGraph {
   getEntryRoot(target) {
     return this.#graph.getEntryRoot(this.#options.projectRoot, (0, _Target.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) {
+    const conditions = new Set();
+    const depIds = deps.map(dep => dep.id);
+    for (const condition of this.#graph._conditions.values()) {
+      if (depIds.includes(condition.ifTrueDependency.id) || depIds.includes(condition.ifFalseDependency.id)) {
+        const [trueAsset, falseAsset] = [condition.ifTrueDependency, condition.ifFalseDependency].map(dep => {
+          const resolved = (0, _nullthrows().default)(this.#graph.resolveAsyncDependency(dep));
+          if (resolved.type === 'asset') {
+            return resolved.value;
+          } else {
+            return this.#graph.getAssetById(resolved.value.entryAssetId);
+          }
+        });
+        conditions.add({
+          publicId: condition.publicId,
+          key: condition.key,
+          ifTrueDependency: (0, _nullthrows().default)(deps.find(dep => dep.id === condition.ifTrueDependency.id), 'ifTrueDependency was null'),
+          ifFalseDependency: (0, _nullthrows().default)(deps.find(dep => dep.id === condition.ifFalseDependency.id), 'ifFalseDependency was null'),
+          ifTrueAssetId: this.#graph.getAssetPublicId(trueAsset),
+          ifFalseAssetId: this.#graph.getAssetPublicId(falseAsset)
+        });
+      }
+    }
+    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 this.#graph._conditions.values()) {
+      let assets = Array.from(cond.assets).map(asset => (0, _nullthrows().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().default)(assetDeps.find(assetDep => dep.id === assetDep.id));
+          const resolved = (0, _nullthrows().default)(this.resolveAsyncDependency(publicDep));
+          (0, _assert().default)(resolved.type === 'bundle_group');
+          return this.getBundlesInBundleGroup(resolved.value);
+        };
+        ifTrueBundles.push(...depToBundles(cond.ifTrueDependency));
+        ifFalseBundles.push(...depToBundles(cond.ifFalseDependency));
+      }
+      for (let bundle of bundles) {
+        const conditions = bundleConditions.get(bundle) ?? new Map();
+        conditions.set(cond.key, {
+          ifTrueBundles,
+          ifFalseBundles
+        });
+        bundleConditions.set(bundle, conditions);
+      }
+    }
+    return bundleConditions;
+  }
 }
 exports.default = BundleGraph;

package/lib/resolveOptions.js

@@ -197,6 +197,8 @@ async function resolveOptions(initialOptions) {
       outputFormat: initialOptions === null || initialOptions === void 0 || (_initialOptions$defau8 = initialOptions.defaultTargetOptions) === null || _initialOptions$defau8 === void 0 ? void 0 : _initialOptions$defau8.outputFormat,
       isLibrary: initialOptions === null || initialOptions === void 0 || (_initialOptions$defau9 = initialOptions.defaultTargetOptions) === null || _initialOptions$defau9 === void 0 ? void 0 : _initialOptions$defau9.isLibrary
     },
+    // unused, feature-flags are set above this to allow this function to use
+    // feature-flags
     featureFlags: {
       ..._featureFlags().DEFAULT_FEATURE_FLAGS,
       ...(initialOptions === null || initialOptions === void 0 ? void 0 : initialOptions.featureFlags)

package/lib/types.js

@@ -13,7 +13,8 @@ const SpecifierType = exports.SpecifierType = {
 const Priority = exports.Priority = {
   sync: 0,
   parallel: 1,
-  lazy: 2
+  lazy: 2,
+  conditional: 3
 };
 
 // Must match package_json.rs in node-resolver-rs.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/core",
-  "version": "2.12.1-canary.3432+415929ab6",
+  "version": "2.12.1-canary.3434+c61bf3cde",
   "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
     "access": "public"
@@ -20,20 +20,20 @@
     "check-ts": "tsc --noEmit index.d.ts"
   },
   "dependencies": {
-    "@atlaspack/cache": "2.12.1-canary.3432+415929ab6",
-    "@atlaspack/diagnostic": "2.12.1-canary.3432+415929ab6",
-    "@atlaspack/events": "2.12.1-canary.3432+415929ab6",
-    "@atlaspack/feature-flags": "2.12.1-canary.3432+415929ab6",
-    "@atlaspack/fs": "2.12.1-canary.3432+415929ab6",
-    "@atlaspack/graph": "3.2.1-canary.3432+415929ab6",
-    "@atlaspack/logger": "2.12.1-canary.3432+415929ab6",
-    "@atlaspack/package-manager": "2.12.1-canary.3432+415929ab6",
-    "@atlaspack/plugin": "2.12.1-canary.3432+415929ab6",
-    "@atlaspack/profiler": "2.12.1-canary.3432+415929ab6",
-    "@atlaspack/rust": "2.12.1-canary.3432+415929ab6",
-    "@atlaspack/types": "2.12.1-canary.3432+415929ab6",
-    "@atlaspack/utils": "2.12.1-canary.3432+415929ab6",
-    "@atlaspack/workers": "2.12.1-canary.3432+415929ab6",
+    "@atlaspack/cache": "2.12.1-canary.3434+c61bf3cde",
+    "@atlaspack/diagnostic": "2.12.1-canary.3434+c61bf3cde",
+    "@atlaspack/events": "2.12.1-canary.3434+c61bf3cde",
+    "@atlaspack/feature-flags": "2.12.1-canary.3434+c61bf3cde",
+    "@atlaspack/fs": "2.12.1-canary.3434+c61bf3cde",
+    "@atlaspack/graph": "3.2.1-canary.3434+c61bf3cde",
+    "@atlaspack/logger": "2.12.1-canary.3434+c61bf3cde",
+    "@atlaspack/package-manager": "2.12.1-canary.3434+c61bf3cde",
+    "@atlaspack/plugin": "2.12.1-canary.3434+c61bf3cde",
+    "@atlaspack/profiler": "2.12.1-canary.3434+c61bf3cde",
+    "@atlaspack/rust": "2.12.1-canary.3434+c61bf3cde",
+    "@atlaspack/types": "2.12.1-canary.3434+c61bf3cde",
+    "@atlaspack/utils": "2.12.1-canary.3434+c61bf3cde",
+    "@atlaspack/workers": "2.12.1-canary.3434+c61bf3cde",
     "@mischnic/json-sourcemap": "^0.1.0",
     "@parcel/source-map": "^2.1.1",
     "base-x": "^3.0.8",
@@ -57,5 +57,5 @@
   "browser": {
     "./src/serializerCore.js": "./src/serializerCore.browser.js"
   },
-  "gitHead": "415929ab63f5314913c27d3dfdb965f2e76bedf2"
+  "gitHead": "c61bf3cde53d1cdb5ae13541c644a6e3ef5521e1"
 }

package/src/Atlaspack.js

@@ -57,7 +57,7 @@ import {
   fromProjectPathRelative,
 } from './projectPath';
 import {tracer} from '@atlaspack/profiler';
-import {setFeatureFlags} from '@atlaspack/feature-flags';
+import {setFeatureFlags, DEFAULT_FEATURE_FLAGS} from '@atlaspack/feature-flags';
 import {AtlaspackV3, toFileSystemV3} from './atlaspack-v3';
 
 registerCoreWithSerializer();
@@ -105,6 +105,12 @@ export default class Atlaspack {
       return;
     }
 
+    const featureFlags = {
+      ...DEFAULT_FEATURE_FLAGS,
+      ...this.#initialOptions.featureFlags,
+    };
+    setFeatureFlags(featureFlags);
+
     await initSourcemaps;
     await initRust?.();
     try {
@@ -117,9 +123,10 @@ export default class Atlaspack {
       logger.warn(e);
     }
 
-    let resolvedOptions: AtlaspackOptions = await resolveOptions(
-      this.#initialOptions,
-    );
+    let resolvedOptions: AtlaspackOptions = await resolveOptions({
+      ...this.#initialOptions,
+      featureFlags,
+    });
     this.#resolvedOptions = resolvedOptions;
 
     let rustAtlaspack: AtlaspackV3;
@@ -152,8 +159,6 @@ export default class Atlaspack {
       });
     }
 
-    setFeatureFlags(resolvedOptions.featureFlags);
-
     let {config} = await loadAtlaspackConfig(resolvedOptions);
     this.#config = new AtlaspackConfig(config, resolvedOptions);
 

package/src/BundleGraph.js

@@ -6,6 +6,7 @@ import type {
   Symbol,
   TraversalActions,
   BundleBehavior as IBundleBehavior,
+  ConditionMeta,
 } from '@atlaspack/types';
 import type {
   ContentKey,
@@ -26,6 +27,7 @@ import type {
   Environment,
   InternalSourceLocation,
   Target,
+  Condition,
 } from './types';
 import type AssetGraph from './AssetGraph';
 import type {ProjectPath} from './projectPath';
@@ -46,6 +48,7 @@ import {getBundleGroupId, getPublicId} from './utils';
 import {ISOLATED_ENVS} from './public/Environment';
 import {fromProjectPath, fromProjectPathRelative} from './projectPath';
 import {HASH_REF_PREFIX} from './constants';
+import {getFeatureFlag} from '@atlaspack/feature-flags';
 
 export const bundleGraphEdgeTypes = {
   // A lack of an edge type indicates to follow the edge while traversing
@@ -91,6 +94,7 @@ type BundleGraphOpts = {|
   bundleContentHashes: Map<string, string>,
   assetPublicIds: Set<string>,
   publicIdByAssetId: Map<string, string>,
+  conditions: Map<string, Condition>,
 |};
 
 type SerializedBundleGraph = {|
@@ -99,6 +103,7 @@ type SerializedBundleGraph = {|
   bundleContentHashes: Map<string, string>,
   assetPublicIds: Set<string>,
   publicIdByAssetId: Map<string, string>,
+  conditions: Map<string, Condition>,
 |};
 
 function makeReadOnlySet<T>(set: Set<T>): $ReadOnlySet<T> {
@@ -139,22 +144,26 @@ export default class BundleGraph {
   /** The internal core Graph structure */
   _graph: ContentGraph<BundleGraphNode, BundleGraphEdgeType>;
   _bundlePublicIds /*: Set<string> */ = new Set<string>();
+  _conditions /*: Map<string, Condition> */ = new Map<string, Condition>();
 
   constructor({
     graph,
     publicIdByAssetId,
     assetPublicIds,
     bundleContentHashes,
+    conditions,
   }: {|
     graph: ContentGraph<BundleGraphNode, BundleGraphEdgeType>,
     publicIdByAssetId: Map<string, string>,
     assetPublicIds: Set<string>,
     bundleContentHashes: Map<string, string>,
+    conditions: Map<string, Condition>,
   |}) {
     this._graph = graph;
     this._assetPublicIds = assetPublicIds;
     this._publicIdByAssetId = publicIdByAssetId;
     this._bundleContentHashes = bundleContentHashes;
+    this._conditions = conditions;
   }
 
   /**
@@ -171,6 +180,9 @@ export default class BundleGraph {
     let assetGroupIds = new Map();
     let dependencies = new Map();
     let assetGraphNodeIdToBundleGraphNodeId = new Map<NodeId, NodeId>();
+    let conditions = new Map<string, Condition>();
+
+    let placeholderToDependency = new Map<string, Dependency>();
 
     let assetGraphRootNode =
       assetGraph.rootNodeId != null
@@ -195,6 +207,20 @@ export default class BundleGraph {
         }
       } else if (node != null && node.type === 'asset_group') {
         assetGroupIds.set(nodeId, assetGraph.getNodeIdsConnectedFrom(nodeId));
+      } else if (
+        getFeatureFlag('conditionalBundlingApi') &&
+        node != null &&
+        node.type === 'dependency'
+      ) {
+        // The dependency placeholders in the `importCond` calls that will be in the transformed
+        // code need to be mapped to the "real" dependencies, so we need access to a map of placeholders
+        // to dependencies
+        const dep = node.value;
+        // $FlowFixMe[incompatible-type] Meta is untyped
+        const placeholder: string | void = dep.meta?.placeholder;
+        if (placeholder != null) {
+          placeholderToDependency.set(placeholder, dep);
+        }
       }
     });
 
@@ -204,6 +230,51 @@ export default class BundleGraph {
       walkVisited.add(nodeId);
 
       let node = nullthrows(assetGraph.getNode(nodeId));
+
+      if (getFeatureFlag('conditionalBundlingApi') && node.type === 'asset') {
+        const asset = node.value;
+        if (Array.isArray(asset.meta.conditions)) {
+          // $FlowFixMe
+          for (const condition of (asset.meta.conditions: ConditionMeta[])) {
+            // Resolve the placeholders that were attached to the asset in JSTransformer to dependencies,
+            // as well as create a public id for the condition.
+            const {
+              key,
+              ifTruePlaceholder,
+              ifFalsePlaceholder,
+            }: {
+              key: string,
+              ifTruePlaceholder: string,
+              ifFalsePlaceholder: string,
+              ...
+            } = condition;
+
+            const condHash = hashString(
+              `${key}:${ifTruePlaceholder}:${ifFalsePlaceholder}`,
+            );
+            const condPublicId = getPublicId(condHash, v => conditions.has(v));
+
+            if (conditions.has(condHash)) {
+              throw new Error('Unexpected duplicate asset');
+            } else {
+              conditions.set(condHash, {
+                publicId: condPublicId,
+                assets: new Set([asset]),
+                key,
+                ifTrueDependency: nullthrows(
+                  placeholderToDependency.get(ifTruePlaceholder),
+                  'ifTruePlaceholder was undefined',
+                ),
+                ifFalseDependency: nullthrows(
+                  placeholderToDependency.get(ifFalsePlaceholder),
+                  'ifFalsePlaceholder was undefined',
+                ),
+              });
+            }
+          }
+        }
+      }
+
       if (
         node.type === 'dependency' &&
         node.value.symbols != null &&
@@ -440,11 +511,13 @@ export default class BundleGraph {
         );
       }
     }
+
     return new BundleGraph({
       graph,
       assetPublicIds,
       bundleContentHashes: new Map(),
       publicIdByAssetId,
+      conditions,
     });
   }
 
@@ -455,6 +528,7 @@ export default class BundleGraph {
       assetPublicIds: this._assetPublicIds,
       bundleContentHashes: this._bundleContentHashes,
       publicIdByAssetId: this._publicIdByAssetId,
+      conditions: this._conditions,
     };
   }
 
@@ -464,6 +538,7 @@ export default class BundleGraph {
       assetPublicIds: serialized.assetPublicIds,
       bundleContentHashes: serialized.bundleContentHashes,
       publicIdByAssetId: serialized.publicIdByAssetId,
+      conditions: serialized.conditions,
     });
   }
 
@@ -1215,7 +1290,8 @@ export default class BundleGraph {
         .some(
           node =>
             node?.type === 'dependency' &&
-            node.value.priority === Priority.lazy &&
+            (node.value.priority === Priority.lazy ||
+              node.value.priority === Priority.conditional) &&
             node.value.specifierType !== SpecifierType.url,
         )
     ) {

package/src/SymbolPropagation.js

@@ -16,7 +16,7 @@ import nullthrows from 'nullthrows';
 import {setEqual} from '@atlaspack/utils';
 import logger from '@atlaspack/logger';
 import {md, convertSourceLocationToHighlight} from '@atlaspack/diagnostic';
-import {BundleBehavior} from './types';
+import {BundleBehavior, Priority} from './types';
 import {fromProjectPathRelative, fromProjectPath} from './projectPath';
 
 export function propagateSymbols({
@@ -101,7 +101,10 @@ export function propagateSymbols({
         namespaceReexportedSymbols.add('*');
       } else {
         for (let incomingDep of incomingDeps) {
-          if (incomingDep.value.symbols == null) {
+          if (
+            incomingDep.value.symbols == null ||
+            incomingDep.value.priority === Priority.conditional
+          ) {
             if (incomingDep.value.sourceAssetId == null) {
               // The root dependency on non-library builds
               isEntry = true;

package/src/atlaspack-v3/worker/worker.js

@@ -217,4 +217,5 @@ const PriorityMap = {
   sync: 0,
   parallel: 1,
   lazy: 2,
+  conditional: 3,
 };

package/src/public/BundleGraph.js

@@ -332,4 +332,110 @@ export default class BundleGraph<TBundle: IBundle>
       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: Array<IDependency>): Set<{|
+    publicId: string,
+    key: string,
+    ifTrueDependency: IDependency,
+    ifFalseDependency: IDependency,
+    ifTrueAssetId: string,
+    ifFalseAssetId: string,
+  |}> {
+    const conditions = new Set();
+    const depIds = deps.map(dep => dep.id);
+    for (const condition of this.#graph._conditions.values()) {
+      if (
+        depIds.includes(condition.ifTrueDependency.id) ||
+        depIds.includes(condition.ifFalseDependency.id)
+      ) {
+        const [trueAsset, falseAsset] = [
+          condition.ifTrueDependency,
+          condition.ifFalseDependency,
+        ].map(dep => {
+          const resolved = nullthrows(this.#graph.resolveAsyncDependency(dep));
+          if (resolved.type === 'asset') {
+            return resolved.value;
+          } else {
+            return this.#graph.getAssetById(resolved.value.entryAssetId);
+          }
+        });
+
+        conditions.add({
+          publicId: condition.publicId,
+          key: condition.key,
+          ifTrueDependency: nullthrows(
+            deps.find(dep => dep.id === condition.ifTrueDependency.id),
+            'ifTrueDependency was null',
+          ),
+          ifFalseDependency: nullthrows(
+            deps.find(dep => dep.id === condition.ifFalseDependency.id),
+            'ifFalseDependency was null',
+          ),
+          ifTrueAssetId: this.#graph.getAssetPublicId(trueAsset),
+          ifFalseAssetId: this.#graph.getAssetPublicId(falseAsset),
+        });
+      }
+    }
+
+    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(): Map<
+    TBundle,
+    Map<
+      string,
+      {|
+        ifTrueBundles: Array<TBundle>,
+        ifFalseBundles: Array<TBundle>,
+      |},
+    >,
+  > {
+    let bundleConditions = new Map();
+
+    // Convert the internal references in conditions to public API references
+    for (const cond of this.#graph._conditions.values()) {
+      let assets = Array.from(cond.assets).map(asset =>
+        nullthrows(this.getAssetById(asset.id)),
+      );
+      let bundles = new Set<TBundle>();
+      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 = nullthrows(
+            assetDeps.find(assetDep => dep.id === assetDep.id),
+          );
+          const resolved = nullthrows(this.resolveAsyncDependency(publicDep));
+          invariant(resolved.type === 'bundle_group');
+          return this.getBundlesInBundleGroup(resolved.value);
+        };
+        ifTrueBundles.push(...depToBundles(cond.ifTrueDependency));
+        ifFalseBundles.push(...depToBundles(cond.ifFalseDependency));
+      }
+
+      for (let bundle of bundles) {
+        const conditions = bundleConditions.get(bundle) ?? new Map();
+
+        conditions.set(cond.key, {
+          ifTrueBundles,
+          ifFalseBundles,
+        });
+
+        bundleConditions.set(bundle, conditions);
+      }
+    }
+
+    return bundleConditions;
+  }
 }

package/src/resolveOptions.js

@@ -231,6 +231,8 @@ export default async function resolveOptions(
       outputFormat: initialOptions?.defaultTargetOptions?.outputFormat,
       isLibrary: initialOptions?.defaultTargetOptions?.isLibrary,
     },
+    // unused, feature-flags are set above this to allow this function to use
+    // feature-flags
     featureFlags: {...DEFAULT_FEATURE_FLAGS, ...initialOptions?.featureFlags},
     parcelVersion: ATLASPACK_VERSION,
   };

package/src/types.js

@@ -115,6 +115,7 @@ export const Priority = {
   sync: 0,
   parallel: 1,
   lazy: 2,
+  conditional: 3,
 };
 
 // Must match package_json.rs in node-resolver-rs.
@@ -542,6 +543,7 @@ export type Bundle = {|
   displayName: ?string,
   pipeline: ?string,
   manualSharedBundle?: ?string,
+  conditions?: Map<string, string>,
 |};
 
 export type BundleNode = {|
@@ -580,3 +582,11 @@ export type ValidationOpts = {|
 |};
 
 export type ReportFn = (event: ReporterEvent) => void | Promise<void>;
+
+export type Condition = {|
+  publicId: string,
+  assets: Set<Asset>,
+  key: string,
+  ifTrueDependency: Dependency,
+  ifFalseDependency: Dependency,
+|};

package/test/PublicBundle.test.js

@@ -42,6 +42,7 @@ describe('Public Bundle', () => {
       assetPublicIds: new Set(),
       publicIdByAssetId: new Map(),
       bundleContentHashes: new Map(),
+      conditions: new Map(),
     });
   });