@atlaspack/core 2.16.2-dev.14 → 2.16.2-dev.55

package/src/BundleGraph.js

@@ -1284,143 +1284,6 @@ export default class BundleGraph {
     );
   }
 
-  getReferencedAssets(
-    bundle: Bundle,
-    cache: Map<Bundle, Set<string>>,
-  ): Set<string> {
-    const result = new Set();
-
-    const siblingBundles = new Set(
-      this.getBundleGroupsContainingBundle(bundle).flatMap((bundleGroup) =>
-        this.getBundlesInBundleGroup(bundleGroup, {includeInline: true}),
-      ),
-    );
-
-    const candidates = new Map();
-
-    this.traverseAssets(bundle, (asset) => {
-      // If the asset is available in multiple bundles in the same target, it's referenced.
-      const bundlesWithAsset = this.getBundlesWithAsset(asset);
-      if (
-        bundlesWithAsset.filter(
-          (b) =>
-            b.target.name === bundle.target.name &&
-            b.target.distDir === bundle.target.distDir,
-        ).length > 1
-      ) {
-        result.add(asset.id);
-        return;
-      }
-
-      const assetNodeId = nullthrows(
-        this._graph.getNodeIdByContentKey(asset.id),
-      );
-
-      if (
-        this._graph
-          .getNodeIdsConnectedTo(assetNodeId, bundleGraphEdgeTypes.references)
-          .map((id) => this._graph.getNode(id))
-          .some(
-            (node) =>
-              node?.type === 'dependency' &&
-              (node.value.priority === Priority.lazy ||
-                node.value.priority === Priority.conditional) &&
-              node.value.specifierType !== SpecifierType.url,
-          )
-      ) {
-        // If this asset is referenced by any async dependency, it's referenced.
-        result.add(asset.id);
-        return;
-      }
-
-      const dependencies = this._graph
-        .getNodeIdsConnectedTo(assetNodeId)
-        .map((id) => nullthrows(this._graph.getNode(id)))
-        .filter((node) => node.type === 'dependency')
-        .map((node) => {
-          invariant(node.type === 'dependency');
-          return node.value;
-        });
-
-      candidates.set(asset.id, {
-        asset,
-        dependencies,
-        bundlesWithAsset,
-      });
-    });
-
-    const visitedBundles: Set<Bundle> = new Set();
-
-    // Check if any of this bundle's descendants, referencers, bundles referenced
-    // by referencers, or descendants of its referencers use the asset without
-    // an explicit reference edge. This can happen if e.g. the asset has been
-    // deduplicated.
-    [...siblingBundles].forEach((referencer) => {
-      this.traverseBundles((descendant, _, actions) => {
-        if (descendant.id === bundle.id) {
-          return;
-        }
-
-        if (visitedBundles.has(descendant)) {
-          actions.skipChildren();
-          return;
-        }
-
-        visitedBundles.add(descendant);
-
-        if (
-          descendant.type !== bundle.type ||
-          descendant.env.context !== bundle.env.context
-        ) {
-          actions.skipChildren();
-          return;
-        }
-
-        for (let assetId of this.getBundleDirectReferences(descendant, cache)) {
-          if (candidates.has(assetId)) {
-            result.add(assetId);
-          }
-        }
-      }, referencer);
-    });
-
-    return result;
-  }
-
-  getBundleDirectReferences(
-    bundle: Bundle,
-    cache: Map<Bundle, Set<string>>,
-  ): Set<string> {
-    const cachedResult = cache.get(bundle);
-    if (cachedResult != null) {
-      return cachedResult;
-    }
-
-    const directReferences = new Set();
-    const bundleAssets = this.getBundleContainedAssets(bundle);
-    const bundleDependencies = this.getBundleContainedDependencies(bundle);
-
-    for (const dependency of bundleDependencies) {
-      this._graph.forEachNodeIdConnectedFrom(
-        this._graph.getNodeIdByContentKey(dependency),
-        (assetId) => {
-          const asset = nullthrows(this._graph.getNode(assetId));
-          if (asset.type !== 'asset') {
-            return;
-          }
-
-          if (!bundleAssets.has(asset.id)) {
-            directReferences.add(asset.id);
-          }
-        },
-      );
-    }
-
-    cache.set(bundle, directReferences);
-
-    return directReferences;
-  }
-
   isAssetReferenced(bundle: Bundle, asset: Asset): boolean {
     // If the asset is available in multiple bundles in the same target, it's referenced.
     if (
@@ -1952,36 +1815,6 @@ export default class BundleGraph {
     );
   }
 
-  getBundleContainedAssets(bundle: Bundle): Set<string> {
-    const assets = new Set();
-    this._graph.forEachNodeIdConnectedFrom(
-      this._graph.getNodeIdByContentKey(bundle.id),
-      (nodeId) => {
-        const node = nullthrows(this._graph.getNode(nodeId));
-        if (node.type === 'asset') {
-          assets.add(node.value.id);
-        }
-      },
-      bundleGraphEdgeTypes.contains,
-    );
-    return assets;
-  }
-
-  getBundleContainedDependencies(bundle: Bundle): Set<string> {
-    const dependencies = new Set();
-    this._graph.forEachNodeIdConnectedFrom(
-      this._graph.getNodeIdByContentKey(bundle.id),
-      (nodeId) => {
-        const node = nullthrows(this._graph.getNode(nodeId));
-        if (node.type === 'dependency') {
-          dependencies.add(node.value.id);
-        }
-      },
-      bundleGraphEdgeTypes.contains,
-    );
-    return dependencies;
-  }
-
   filteredTraverse<TValue, TContext>(
     bundleNodeId: NodeId,
     filter: (NodeId, TraversalActions) => ?TValue,

package/src/PackagerRunner.js

@@ -63,6 +63,7 @@ import {getInvalidationId, getInvalidationHash} from './assetUtils';
 import {optionsProxy} from './utils';
 import {invalidateDevDeps} from './requests/DevDepRequest';
 import {tracer, PluginTracer} from '@atlaspack/profiler';
+import {getFeatureFlag} from '@atlaspack/feature-flags';
 
 type Opts = {|
   config: AtlaspackConfig,
@@ -658,6 +659,21 @@ export default class PackagerRunner {
       this.options,
     );
 
+    if (getFeatureFlag('cachePerformanceImprovements')) {
+      const hash = hashString(
+        ATLASPACK_VERSION +
+          devDepHashes +
+          invalidationHash +
+          bundle.target.publicUrl +
+          bundleGraph.getHash(bundle) +
+          JSON.stringify(configResults) +
+          JSON.stringify(globalInfoResults) +
+          this.options.mode +
+          (this.options.shouldBuildLazily ? 'lazy' : 'eager'),
+      );
+      return path.join(bundle.displayName ?? bundle.name ?? bundle.id, hash);
+    }
+
     return hashString(
       ATLASPACK_VERSION +
         devDepHashes +
@@ -700,20 +716,27 @@ export default class PackagerRunner {
     let mapKey = PackagerRunner.getMapKey(cacheKey);
 
     let isLargeBlob = await this.options.cache.hasLargeBlob(contentKey);
-    let contentExists =
-      isLargeBlob || (await this.options.cache.has(contentKey));
+    let contentExists = getFeatureFlag('cachePerformanceImprovements')
+      ? isLargeBlob
+      : isLargeBlob || (await this.options.cache.has(contentKey));
     if (!contentExists) {
       return null;
     }
 
-    let mapExists = await this.options.cache.has(mapKey);
+    let mapExists = getFeatureFlag('cachePerformanceImprovements')
+      ? await this.options.cache.hasLargeBlob(mapKey)
+      : await this.options.cache.has(mapKey);
 
     return {
       contents: isLargeBlob
         ? this.options.cache.getStream(contentKey)
         : blobToStream(await this.options.cache.getBlob(contentKey)),
       map: mapExists
-        ? blobToStream(await this.options.cache.getBlob(mapKey))
+        ? blobToStream(
+            getFeatureFlag('cachePerformanceImprovements')
+              ? await this.options.cache.getLargeBlob(mapKey)
+              : await this.options.cache.getBlob(mapKey),
+          )
         : null,
     };
   }
@@ -727,11 +750,14 @@ export default class PackagerRunner {
     let size = 0;
     let hash;
     let hashReferences = [];
-    let isLargeBlob = false;
+    let isLargeBlob = getFeatureFlag('cachePerformanceImprovements');
 
     // TODO: don't replace hash references in binary files??
     if (contents instanceof Readable) {
-      isLargeBlob = true;
+      if (!getFeatureFlag('cachePerformanceImprovements')) {
+        isLargeBlob = true;
+      }
+
       let boundaryStr = '';
       let h = new Hash();
       await this.options.cache.setStream(
@@ -754,17 +780,32 @@ export default class PackagerRunner {
       size = buffer.byteLength;
       hash = hashBuffer(buffer);
       hashReferences = contents.match(HASH_REF_REGEX) ?? [];
-      await this.options.cache.setBlob(cacheKeys.content, buffer);
+
+      if (getFeatureFlag('cachePerformanceImprovements')) {
+        await this.options.cache.setLargeBlob(cacheKeys.content, buffer);
+      } else {
+        await this.options.cache.setBlob(cacheKeys.content, buffer);
+      }
     } else {
       size = contents.length;
       hash = hashBuffer(contents);
       hashReferences = contents.toString().match(HASH_REF_REGEX) ?? [];
-      await this.options.cache.setBlob(cacheKeys.content, contents);
+
+      if (getFeatureFlag('cachePerformanceImprovements')) {
+        await this.options.cache.setLargeBlob(cacheKeys.content, contents);
+      } else {
+        await this.options.cache.setBlob(cacheKeys.content, contents);
+      }
     }
 
     if (map != null) {
-      await this.options.cache.setBlob(cacheKeys.map, map);
+      if (getFeatureFlag('cachePerformanceImprovements')) {
+        await this.options.cache.setLargeBlob(cacheKeys.map, map);
+      } else {
+        await this.options.cache.setBlob(cacheKeys.map, map);
+      }
     }
+
     let info = {
       type,
       size,
@@ -773,19 +814,29 @@ export default class PackagerRunner {
       cacheKeys,
       isLargeBlob,
     };
+
     await this.options.cache.set(cacheKeys.info, info);
     return info;
   }
 
   static getContentKey(cacheKey: string): string {
+    if (getFeatureFlag('cachePerformanceImprovements')) {
+      return `PackagerRunner/${ATLASPACK_VERSION}/${cacheKey}/content`;
+    }
     return hashString(`${cacheKey}:content`);
   }
 
   static getMapKey(cacheKey: string): string {
+    if (getFeatureFlag('cachePerformanceImprovements')) {
+      return `PackagerRunner/${ATLASPACK_VERSION}/${cacheKey}/map`;
+    }
     return hashString(`${cacheKey}:map`);
   }
 
   static getInfoKey(cacheKey: string): string {
+    if (getFeatureFlag('cachePerformanceImprovements')) {
+      return `PackagerRunner/${ATLASPACK_VERSION}/${cacheKey}/info`;
+    }
     return hashString(`${cacheKey}:info`);
   }
 }