@atlaspack/core 2.16.2-canary.9 → 2.16.2-dev.14

package/CHANGELOG.md

@@ -1,5 +1,31 @@
 # @atlaspack/core
 
+## 2.17.0
+
+### Minor Changes
+
+- [#541](https://github.com/atlassian-labs/atlaspack/pull/541) [`e2ba0f6`](https://github.com/atlassian-labs/atlaspack/commit/e2ba0f69702656f3d1ce95ab1454e35062b13b39) Thanks [@yamadapc](https://github.com/yamadapc)! - Add database compaction debug command
+
+### Patch Changes
+
+- [#530](https://github.com/atlassian-labs/atlaspack/pull/530) [`2e90c9b`](https://github.com/atlassian-labs/atlaspack/commit/2e90c9bd07d7eb52645f9d84ccbb7f82685cbc8c) Thanks [@yamadapc](https://github.com/yamadapc)! - Write metadata about the cache in a new entry
+
+- [#511](https://github.com/atlassian-labs/atlaspack/pull/511) [`11d6f16`](https://github.com/atlassian-labs/atlaspack/commit/11d6f16b6397dee2f217167e5c98b39edb63f7a7) Thanks [@yamadapc](https://github.com/yamadapc)! - Clean-up dylib worker threads segmentation fault bug fix feature-flag
+
+- Updated dependencies [[`11d6f16`](https://github.com/atlassian-labs/atlaspack/commit/11d6f16b6397dee2f217167e5c98b39edb63f7a7), [`e2ba0f6`](https://github.com/atlassian-labs/atlaspack/commit/e2ba0f69702656f3d1ce95ab1454e35062b13b39), [`d2c50c2`](https://github.com/atlassian-labs/atlaspack/commit/d2c50c2c020888b33bb25b8690d9320c2b69e2a6), [`46a90dc`](https://github.com/atlassian-labs/atlaspack/commit/46a90dccd019a26b222c878a92d23acc75dc67c5), [`4c17141`](https://github.com/atlassian-labs/atlaspack/commit/4c1714103dab2aa9039c488f381551d2b65d1d01)]:
+  - @atlaspack/feature-flags@2.14.3
+  - @atlaspack/rust@3.3.0
+  - @atlaspack/cache@3.2.0
+  - @atlaspack/fs@2.15.0
+  - @atlaspack/graph@3.4.3
+  - @atlaspack/utils@2.14.5
+  - @atlaspack/logger@2.14.5
+  - @atlaspack/package-manager@2.14.5
+  - @atlaspack/profiler@2.14.3
+  - @atlaspack/types@2.14.5
+  - @atlaspack/workers@2.14.5
+  - @atlaspack/plugin@2.14.5
+
 ## 2.16.1
 
 ### Patch Changes

package/lib/Atlaspack.js

@@ -601,6 +601,19 @@ class Atlaspack {
     }
     return result;
   }
+
+  /**
+   * Copy the cache to a new directory and compact it.
+   */
+  async unstable_compactCache() {
+    await this._init();
+    const cache = (0, _nullthrows().default)(this.#resolvedOptions).cache;
+    if (cache instanceof _cache().LMDBLiteCache) {
+      await cache.compact('parcel-cache-compacted');
+    } else {
+      throw new Error('Cache is not an LMDBLiteCache');
+    }
+  }
   async unstable_transform(options) {
     var _options$env;
     if (!this.#initialized) {

package/lib/BundleGraph.js

@@ -822,6 +822,86 @@ class BundleGraph {
   traverseAssets(bundle, visit, startAsset) {
     return this.traverseBundle(bundle, (0, _graph().mapVisitor)(node => node.type === 'asset' ? node.value : null, visit), startAsset);
   }
+  getReferencedAssets(bundle, cache) {
+    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 = (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.priority === _types.Priority.conditional) && node.value.specifierType !== _types.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 => (0, _nullthrows().default)(this._graph.getNode(id))).filter(node => node.type === 'dependency').map(node => {
+        (0, _assert().default)(node.type === 'dependency');
+        return node.value;
+      });
+      candidates.set(asset.id, {
+        asset,
+        dependencies,
+        bundlesWithAsset
+      });
+    });
+    const visitedBundles = 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, cache) {
+    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 = (0, _nullthrows().default)(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, asset) {
     // If the asset is available in multiple bundles in the same target, it's referenced.
     if (this.getBundlesWithAsset(asset).filter(b => b.target.name === bundle.target.name && b.target.distDir === bundle.target.distDir).length > 1) {
@@ -1140,6 +1220,26 @@ class BundleGraph {
     let dependencyNodeId = this._graph.getNodeIdByContentKey(dependency.id);
     return this._graph.hasEdge(bundleNodeId, dependencyNodeId, bundleGraphEdgeTypes.contains);
   }
+  getBundleContainedAssets(bundle) {
+    const assets = new Set();
+    this._graph.forEachNodeIdConnectedFrom(this._graph.getNodeIdByContentKey(bundle.id), nodeId => {
+      const node = (0, _nullthrows().default)(this._graph.getNode(nodeId));
+      if (node.type === 'asset') {
+        assets.add(node.value.id);
+      }
+    }, bundleGraphEdgeTypes.contains);
+    return assets;
+  }
+  getBundleContainedDependencies(bundle) {
+    const dependencies = new Set();
+    this._graph.forEachNodeIdConnectedFrom(this._graph.getNodeIdByContentKey(bundle.id), nodeId => {
+      const node = (0, _nullthrows().default)(this._graph.getNode(nodeId));
+      if (node.type === 'dependency') {
+        dependencies.add(node.value.id);
+      }
+    }, bundleGraphEdgeTypes.contains);
+    return dependencies;
+  }
   filteredTraverse(bundleNodeId, filter, visit) {
     return this._graph.filteredTraverse(filter, visit, bundleNodeId);
   }

package/lib/public/BundleGraph.js

@@ -115,6 +115,9 @@ class BundleGraph {
   isAssetReferenced(bundle, asset) {
     return this.#graph.isAssetReferenced((0, _Bundle.bundleToInternalBundle)(bundle), (0, _Asset.assetToAssetValue)(asset));
   }
+  getReferencedAssets(bundle, cache) {
+    return this.#graph.getReferencedAssets((0, _Bundle.bundleToInternalBundle)(bundle), cache);
+  }
   hasParentBundleOfType(bundle, type) {
     return this.#graph.hasParentBundleOfType((0, _Bundle.bundleToInternalBundle)(bundle), type);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/core",
-  "version": "2.16.2-canary.9+4c1714103",
+  "version": "2.16.2-dev.14+8c369e38c",
   "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.13.3-canary.77+4c1714103",
-    "@atlaspack/cache": "3.1.1-canary.9+4c1714103",
-    "@atlaspack/diagnostic": "2.14.1-canary.77+4c1714103",
-    "@atlaspack/events": "2.14.1-canary.77+4c1714103",
-    "@atlaspack/feature-flags": "2.14.1-canary.77+4c1714103",
-    "@atlaspack/fs": "2.14.5-canary.9+4c1714103",
-    "@atlaspack/graph": "3.4.1-canary.77+4c1714103",
-    "@atlaspack/logger": "2.14.5-canary.9+4c1714103",
-    "@atlaspack/package-manager": "2.14.5-canary.9+4c1714103",
-    "@atlaspack/plugin": "2.14.5-canary.9+4c1714103",
-    "@atlaspack/profiler": "2.14.1-canary.77+4c1714103",
-    "@atlaspack/rust": "3.2.1-canary.9+4c1714103",
-    "@atlaspack/types": "2.14.5-canary.9+4c1714103",
-    "@atlaspack/utils": "2.14.5-canary.9+4c1714103",
-    "@atlaspack/workers": "2.14.5-canary.9+4c1714103",
+    "@atlaspack/build-cache": "2.13.3-dev.82+8c369e38c",
+    "@atlaspack/cache": "3.1.1-dev.14+8c369e38c",
+    "@atlaspack/diagnostic": "2.14.1-dev.82+8c369e38c",
+    "@atlaspack/events": "2.14.1-dev.82+8c369e38c",
+    "@atlaspack/feature-flags": "2.14.1-dev.82+8c369e38c",
+    "@atlaspack/fs": "2.14.5-dev.14+8c369e38c",
+    "@atlaspack/graph": "3.4.1-dev.82+8c369e38c",
+    "@atlaspack/logger": "2.14.5-dev.14+8c369e38c",
+    "@atlaspack/package-manager": "2.14.5-dev.14+8c369e38c",
+    "@atlaspack/plugin": "2.14.5-dev.14+8c369e38c",
+    "@atlaspack/profiler": "2.14.1-dev.82+8c369e38c",
+    "@atlaspack/rust": "3.2.1-dev.14+8c369e38c",
+    "@atlaspack/types": "2.14.5-dev.14+8c369e38c",
+    "@atlaspack/utils": "2.14.5-dev.14+8c369e38c",
+    "@atlaspack/workers": "2.14.5-dev.14+8c369e38c",
     "@mischnic/json-sourcemap": "^0.1.0",
     "@parcel/source-map": "^2.1.1",
     "base-x": "^3.0.8",
@@ -67,5 +67,5 @@
     "./src/serializerCore.js": "./src/serializerCore.browser.js"
   },
   "type": "commonjs",
-  "gitHead": "4c1714103dab2aa9039c488f381551d2b65d1d01"
+  "gitHead": "8c369e38ccd428409811114aebd6044c27f90705"
 }

package/src/Atlaspack.js

@@ -639,6 +639,20 @@ export default class Atlaspack {
     return result;
   }
 
+  /**
+   * Copy the cache to a new directory and compact it.
+   */
+  async unstable_compactCache(): Promise<void> {
+    await this._init();
+
+    const cache = nullthrows(this.#resolvedOptions).cache;
+    if (cache instanceof LMDBLiteCache) {
+      await cache.compact('parcel-cache-compacted');
+    } else {
+      throw new Error('Cache is not an LMDBLiteCache');
+    }
+  }
+
   async unstable_transform(
     options: AtlaspackTransformOptions,
   ): Promise<Array<Asset>> {

package/src/BundleGraph.js

@@ -1284,6 +1284,143 @@ 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 (
@@ -1815,6 +1952,36 @@ 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/public/BundleGraph.js

@@ -185,6 +185,16 @@ export default class BundleGraph<TBundle: IBundle>
     );
   }
 
+  getReferencedAssets(
+    bundle: IBundle,
+    cache: Map<Bundle, Set<string>>,
+  ): Set<string> {
+    return this.#graph.getReferencedAssets(
+      bundleToInternalBundle(bundle),
+      cache,
+    );
+  }
+
   hasParentBundleOfType(bundle: IBundle, type: string): boolean {
     return this.#graph.hasParentBundleOfType(
       bundleToInternalBundle(bundle),