@atlaspack/core 2.12.1-canary.3508 → 2.12.1-canary.3510

package/lib/RequestTracker.js

@@ -960,9 +960,7 @@ class RequestTracker {
       let node = serialisedGraph.nodes[i];
       let resultCacheKey = node === null || node === void 0 ? void 0 : node.resultCacheKey;
       if ((node === null || node === void 0 ? void 0 : node.type) === REQUEST && resultCacheKey != null && (node === null || node === void 0 ? void 0 : node.result) != null) {
-        queue.add(() => serialiseAndSet(resultCacheKey, node.result)).catch(() => {
-          // Handle promise rejection
-        });
+        queue.add(() => serialiseAndSet(resultCacheKey, node.result));
 
         // eslint-disable-next-line no-unused-vars
         let {
@@ -985,9 +983,7 @@ class RequestTracker {
         queue.add(() => serialiseAndSet(getRequestGraphNodeKey(i, cacheKey), nodesToCache).then(() => {
           // Succeeded in writing to disk, save that we have completed this chunk
           this.graph.setCachedRequestChunk(i);
-        })).catch(() => {
-          // Handle promise rejection
-        });
+        }));
       }
     }
     try {

package/lib/public/BundleGraph.js

@@ -193,17 +193,24 @@ class BundleGraph {
   // 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) {
+  getConditionsForDependencies(deps, bundle) {
     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;
+        const [[trueAsset, ifTrueBundles], [falseAsset, ifFalseBundles]] = [condition.ifTrueDependency, condition.ifFalseDependency].map(dep => {
+          const asset = this.#graph.getResolvedAsset(dep, (0, _Bundle.bundleToInternalBundle)(bundle));
+          if (asset && this.#graph.bundleHasAsset((0, _Bundle.bundleToInternalBundle)(bundle), asset)) {
+            // Asset is in the same bundle
+            return [asset, []];
+          }
+          const resolvedAsync = (0, _nullthrows().default)(this.#graph.resolveAsyncDependency(dep, (0, _Bundle.bundleToInternalBundle)(bundle)));
+          if ((resolvedAsync === null || resolvedAsync === void 0 ? void 0 : resolvedAsync.type) === 'asset') {
+            // Single bundle to load dynamically
+            return [resolvedAsync.value, [this.#createBundle((0, _nullthrows().default)(this.#graph.getReferencedBundle(dep, (0, _Bundle.bundleToInternalBundle)(bundle))), this.#graph, this.#options)]];
           } else {
-            return this.#graph.getAssetById(resolved.value.entryAssetId);
+            // Bundle group means we have multiple bundles to load first
+            return [this.#graph.getAssetById(resolvedAsync.value.entryAssetId), this.#graph.getBundlesInBundleGroup(resolvedAsync.value).map(b => this.#createBundle(b, this.#graph, this.#options))];
           }
         });
         conditions.add({
@@ -211,6 +218,8 @@ class BundleGraph {
           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'),
+          ifTrueBundles,
+          ifFalseBundles,
           ifTrueAssetId: this.#graph.getAssetPublicId(trueAsset),
           ifFalseAssetId: this.#graph.getAssetPublicId(falseAsset)
         });
@@ -239,7 +248,11 @@ class BundleGraph {
         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));
+          const resolved = this.resolveAsyncDependency(publicDep);
+          if (!resolved) {
+            // If there's no async dependency, don't list it as required
+            return [];
+          }
           (0, _assert().default)(resolved.type === 'bundle_group');
           return this.getBundlesInBundleGroup(resolved.value);
         };

package/lib/requests/AssetGraphRequest.js

@@ -279,7 +279,8 @@ class AssetGraphBuilder {
           node.requested = true;
         } else if (!node.requested) {
           let isAsyncChild = this.assetGraph.getIncomingDependencies(node.value).every(dep => dep.isEntry || dep.priority !== _types.Priority.sync);
-          if (isAsyncChild) {
+          if (isAsyncChild && childNode.value.priority !== _types.Priority.conditional) {
+            // Skip if we're on a conditional import
             node.requested = !isNodeLazy;
           } else {
             delete node.requested;
@@ -337,7 +338,11 @@ class AssetGraphBuilder {
       default:
         throw new Error(`Can not queue corresponding request of node with type ${node.type}`);
     }
-    return this.queue.add(() => promise.then(null, error => errors.push(error)));
+    return new Promise(resolve => {
+      this.queue.add(() => promise.then(() => {
+        resolve(null);
+      }, error => errors.push(error)));
+    });
   }
   async runEntryRequest(input) {
     let prevEntries = this.assetGraph.safeToIncrementallyBundle ? this.assetGraph.getEntryAssets().map(asset => asset.id).sort() : [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/core",
-  "version": "2.12.1-canary.3508+28f5e00cf",
+  "version": "2.12.1-canary.3510+ee6ecd192",
   "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
     "access": "public"
@@ -20,21 +20,21 @@
     "check-ts": "tsc --noEmit index.d.ts"
   },
   "dependencies": {
-    "@atlaspack/build-cache": "2.12.1-canary.3508+28f5e00cf",
-    "@atlaspack/cache": "2.12.1-canary.3508+28f5e00cf",
-    "@atlaspack/diagnostic": "2.12.1-canary.3508+28f5e00cf",
-    "@atlaspack/events": "2.12.1-canary.3508+28f5e00cf",
-    "@atlaspack/feature-flags": "2.12.1-canary.3508+28f5e00cf",
-    "@atlaspack/fs": "2.12.1-canary.3508+28f5e00cf",
-    "@atlaspack/graph": "3.2.1-canary.3508+28f5e00cf",
-    "@atlaspack/logger": "2.12.1-canary.3508+28f5e00cf",
-    "@atlaspack/package-manager": "2.12.1-canary.3508+28f5e00cf",
-    "@atlaspack/plugin": "2.12.1-canary.3508+28f5e00cf",
-    "@atlaspack/profiler": "2.12.1-canary.3508+28f5e00cf",
-    "@atlaspack/rust": "2.12.1-canary.3508+28f5e00cf",
-    "@atlaspack/types": "2.12.1-canary.3508+28f5e00cf",
-    "@atlaspack/utils": "2.12.1-canary.3508+28f5e00cf",
-    "@atlaspack/workers": "2.12.1-canary.3508+28f5e00cf",
+    "@atlaspack/build-cache": "2.12.1-canary.3510+ee6ecd192",
+    "@atlaspack/cache": "2.12.1-canary.3510+ee6ecd192",
+    "@atlaspack/diagnostic": "2.12.1-canary.3510+ee6ecd192",
+    "@atlaspack/events": "2.12.1-canary.3510+ee6ecd192",
+    "@atlaspack/feature-flags": "2.12.1-canary.3510+ee6ecd192",
+    "@atlaspack/fs": "2.12.1-canary.3510+ee6ecd192",
+    "@atlaspack/graph": "3.2.1-canary.3510+ee6ecd192",
+    "@atlaspack/logger": "2.12.1-canary.3510+ee6ecd192",
+    "@atlaspack/package-manager": "2.12.1-canary.3510+ee6ecd192",
+    "@atlaspack/plugin": "2.12.1-canary.3510+ee6ecd192",
+    "@atlaspack/profiler": "2.12.1-canary.3510+ee6ecd192",
+    "@atlaspack/rust": "2.12.1-canary.3510+ee6ecd192",
+    "@atlaspack/types": "2.12.1-canary.3510+ee6ecd192",
+    "@atlaspack/utils": "2.12.1-canary.3510+ee6ecd192",
+    "@atlaspack/workers": "2.12.1-canary.3510+ee6ecd192",
     "@mischnic/json-sourcemap": "^0.1.0",
     "@parcel/source-map": "^2.1.1",
     "base-x": "^3.0.8",
@@ -66,5 +66,5 @@
   "browser": {
     "./src/serializerCore.js": "./src/serializerCore.browser.js"
   },
-  "gitHead": "28f5e00cfb76c7706a08cfb72046d3b9307ea073"
+  "gitHead": "ee6ecd19279313160e412378436fd2bbd502dfa0"
 }

package/src/RequestTracker.js

@@ -1514,11 +1514,7 @@ export default class RequestTracker {
         resultCacheKey != null &&
         node?.result != null
       ) {
-        queue
-          .add(() => serialiseAndSet(resultCacheKey, node.result))
-          .catch(() => {
-            // Handle promise rejection
-          });
+        queue.add(() => serialiseAndSet(resultCacheKey, node.result));
 
         // eslint-disable-next-line no-unused-vars
         let {result: _, ...newNode} = node;
@@ -1547,19 +1543,15 @@ export default class RequestTracker {
         // We assume the request graph nodes are immutable and won't change
         let nodesToCache = cacheableNodes.slice(nodesStartIndex, nodesEndIndex);
 
-        queue
-          .add(() =>
-            serialiseAndSet(
-              getRequestGraphNodeKey(i, cacheKey),
-              nodesToCache,
-            ).then(() => {
-              // Succeeded in writing to disk, save that we have completed this chunk
-              this.graph.setCachedRequestChunk(i);
-            }),
-          )
-          .catch(() => {
-            // Handle promise rejection
-          });
+        queue.add(() =>
+          serialiseAndSet(
+            getRequestGraphNodeKey(i, cacheKey),
+            nodesToCache,
+          ).then(() => {
+            // Succeeded in writing to disk, save that we have completed this chunk
+            this.graph.setCachedRequestChunk(i);
+          }),
+        );
       }
     }
 

package/src/public/BundleGraph.js

@@ -11,6 +11,7 @@ import type {
   FilePath,
   GraphVisitor,
   Symbol,
+  NamedBundle,
   SymbolResolution,
   Target,
 } from '@atlaspack/types';
@@ -336,11 +337,16 @@ export default class BundleGraph<TBundle: IBundle>
   // 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<{|
+  getConditionsForDependencies(
+    deps: Array<IDependency>,
+    bundle: NamedBundle,
+  ): Set<{|
     publicId: string,
     key: string,
     ifTrueDependency: IDependency,
     ifFalseDependency: IDependency,
+    ifTrueBundles: Array<TBundle>,
+    ifFalseBundles: Array<TBundle>,
     ifTrueAssetId: string,
     ifFalseAssetId: string,
   |}> {
@@ -351,15 +357,53 @@ export default class BundleGraph<TBundle: IBundle>
         depIds.includes(condition.ifTrueDependency.id) ||
         depIds.includes(condition.ifFalseDependency.id)
       ) {
-        const [trueAsset, falseAsset] = [
+        const [[trueAsset, ifTrueBundles], [falseAsset, ifFalseBundles]] = [
           condition.ifTrueDependency,
           condition.ifFalseDependency,
         ].map((dep) => {
-          const resolved = nullthrows(this.#graph.resolveAsyncDependency(dep));
-          if (resolved.type === 'asset') {
-            return resolved.value;
+          const asset = this.#graph.getResolvedAsset(
+            dep,
+            bundleToInternalBundle(bundle),
+          );
+          if (
+            asset &&
+            this.#graph.bundleHasAsset(bundleToInternalBundle(bundle), asset)
+          ) {
+            // Asset is in the same bundle
+            return [asset, []];
+          }
+
+          const resolvedAsync = nullthrows(
+            this.#graph.resolveAsyncDependency(
+              dep,
+              bundleToInternalBundle(bundle),
+            ),
+          );
+          if (resolvedAsync?.type === 'asset') {
+            // Single bundle to load dynamically
+            return [
+              resolvedAsync.value,
+              [
+                this.#createBundle(
+                  nullthrows(
+                    this.#graph.getReferencedBundle(
+                      dep,
+                      bundleToInternalBundle(bundle),
+                    ),
+                  ),
+                  this.#graph,
+                  this.#options,
+                ),
+              ],
+            ];
           } else {
-            return this.#graph.getAssetById(resolved.value.entryAssetId);
+            // Bundle group means we have multiple bundles to load first
+            return [
+              this.#graph.getAssetById(resolvedAsync.value.entryAssetId),
+              this.#graph
+                .getBundlesInBundleGroup(resolvedAsync.value)
+                .map((b) => this.#createBundle(b, this.#graph, this.#options)),
+            ];
           }
         });
 
@@ -374,6 +418,8 @@ export default class BundleGraph<TBundle: IBundle>
             deps.find((dep) => dep.id === condition.ifFalseDependency.id),
             'ifFalseDependency was null',
           ),
+          ifTrueBundles,
+          ifFalseBundles,
           ifTrueAssetId: this.#graph.getAssetPublicId(trueAsset),
           ifFalseAssetId: this.#graph.getAssetPublicId(falseAsset),
         });
@@ -416,7 +462,11 @@ export default class BundleGraph<TBundle: IBundle>
           const publicDep = nullthrows(
             assetDeps.find((assetDep) => dep.id === assetDep.id),
           );
-          const resolved = nullthrows(this.resolveAsyncDependency(publicDep));
+          const resolved = this.resolveAsyncDependency(publicDep);
+          if (!resolved) {
+            // If there's no async dependency, don't list it as required
+            return [];
+          }
           invariant(resolved.type === 'bundle_group');
           return this.getBundlesInBundleGroup(resolved.value);
         };

package/src/requests/AssetGraphRequest.js

@@ -382,7 +382,11 @@ export class AssetGraphBuilder {
           let isAsyncChild = this.assetGraph
             .getIncomingDependencies(node.value)
             .every((dep) => dep.isEntry || dep.priority !== Priority.sync);
-          if (isAsyncChild) {
+          if (
+            isAsyncChild &&
+            childNode.value.priority !== Priority.conditional
+          ) {
+            // Skip if we're on a conditional import
             node.requested = !isNodeLazy;
           } else {
             delete node.requested;
@@ -434,7 +438,7 @@ export class AssetGraphBuilder {
   queueCorrespondingRequest(
     nodeId: NodeId,
     errors: Array<Error>,
-  ): Promise<mixed> {
+  ): Promise<null> {
     let promise;
     let node = nullthrows(this.assetGraph.getNode(nodeId));
     switch (node.type) {
@@ -455,9 +459,16 @@ export class AssetGraphBuilder {
           `Can not queue corresponding request of node with type ${node.type}`,
         );
     }
-    return this.queue.add(() =>
-      promise.then(null, (error) => errors.push(error)),
-    );
+    return new Promise((resolve) => {
+      this.queue.add(() =>
+        promise.then(
+          () => {
+            resolve(null);
+          },
+          (error) => errors.push(error),
+        ),
+      );
+    });
   }
 
   async runEntryRequest(input: ProjectPath) {