@atlaspack/core 2.27.0 → 2.29.0

package/src/UncommittedAsset.ts

@@ -11,7 +11,7 @@ import type {Asset, Dependency, AtlaspackOptions, Invalidations} from './types';
 
 import invariant from 'assert';
 import {Readable} from 'stream';
-import SourceMap from '@parcel/source-map';
+import SourceMap from '@atlaspack/source-map';
 import {serializeRaw} from '@atlaspack/build-cache';
 import {
   blobToStream,
@@ -249,7 +249,7 @@ export default class UncommittedAsset {
 
     if (map) {
       this.map = map;
-      this.mapBuffer = map.toBuffer();
+      this.mapBuffer = SourceMap.safeToBuffer(map);
       this.setCode(code.replace(SOURCEMAP_RE, ''));
     }
 
@@ -425,7 +425,7 @@ export default class UncommittedAsset {
       content,
       ast: result.ast,
       isASTDirty: result.ast === this.ast ? this.isASTDirty : true,
-      mapBuffer: result.map ? result.map.toBuffer() : null,
+      mapBuffer: SourceMap.safeToBuffer(result.map),
       code: this.code,
       invalidations: this.invalidations,
     });

package/src/assetUtils.ts

@@ -39,6 +39,7 @@ import {PluginTracer} from '@atlaspack/profiler';
 import {identifierRegistry} from './IdentifierRegistry';
 import type {EnvironmentRef} from './EnvironmentManager';
 import {toEnvironmentId} from './EnvironmentManager';
+import SourceMap from '@atlaspack/source-map';
 
 export type AssetOptions = {
   id?: string;
@@ -180,7 +181,7 @@ async function _generateFromAST(asset: CommittedAsset | UncommittedAsset) {
     tracer: new PluginTracer({origin: pluginName, category: 'asset-generate'}),
   });
 
-  let mapBuffer = map?.toBuffer();
+  let mapBuffer = SourceMap.safeToBuffer(map);
   // Store the results in the cache so we can avoid generating again next time
   await Promise.all([
     asset.options.cache.setStream(

package/src/atlaspack-v3/AtlaspackV3.ts

@@ -91,19 +91,8 @@ export class AtlaspackV3 {
     }
   }
 
-  async buildAssetGraph(): Promise<any> {
-    // @ts-expect-error TS2488
-    let [graph, error] = await atlaspackNapiBuildAssetGraph(
-      this._atlaspack_napi,
-    );
-
-    if (error !== null) {
-      throw new ThrowableDiagnostic({
-        diagnostic: error,
-      });
-    }
-
-    return graph;
+  buildAssetGraph(): Promise<any> {
+    return atlaspackNapiBuildAssetGraph(this._atlaspack_napi) as Promise<any>;
   }
 
   async respondToFsEvents(events: Array<Event>): Promise<boolean> {

package/src/atlaspack-v3/NapiWorkerPool.ts

@@ -23,7 +23,11 @@ export class NapiWorkerPool implements INapiWorkerPool {
   constructor({workerCount}: NapiWorkerPoolOptions = {workerCount: undefined}) {
     // @ts-expect-error TS2322
     this.#workerCount =
-      workerCount ?? ATLASPACK_NAPI_WORKERS ?? getAvailableThreads();
+      workerCount ??
+      ATLASPACK_NAPI_WORKERS ??
+      // Default to a maximum of 4 workers as performance worsens beyond that
+      // point in most cases
+      Math.min(getAvailableThreads(), 4);
     if (!this.#workerCount) {
       // TODO use main thread if workerCount is 0
     }

package/src/atlaspack-v3/worker/compat/mutable-asset.ts

@@ -1,4 +1,4 @@
-import SourceMap from '@parcel/source-map';
+import SourceMap from '@atlaspack/source-map';
 import * as napi from '@atlaspack/rust';
 import {Readable} from 'stream';
 import type {

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

@@ -171,7 +171,7 @@ export class AtlaspackWorker {
           type: 'resolved',
           filePath: result.filePath || '',
           canDefer: result.canDefer || false,
-          sideEffects: result.sideEffects || false,
+          sideEffects: result.sideEffects ?? true,
           code: result.code || undefined,
           meta: result.meta || undefined,
           pipeline: result.pipeline || undefined,

package/src/public/Asset.ts

@@ -1,4 +1,4 @@
-import type SourceMap from '@parcel/source-map';
+import type SourceMap from '@atlaspack/source-map';
 import type {Readable} from 'stream';
 import type {FileSystem} from '@atlaspack/fs';
 

package/src/public/BundleGraph.ts

@@ -198,6 +198,27 @@ export default class BundleGraph<TBundle extends IBundle>
     );
   }
 
+  isAssetReferencedFastCheck(bundle: IBundle, asset: IAsset): boolean | null {
+    return this.#graph.isAssetReferencedFastCheck(
+      bundleToInternalBundle(bundle),
+      assetToAssetValue(asset),
+    );
+  }
+
+  getReferencedAssets(bundle: IBundle): Set<IAsset> {
+    let internalReferencedAssets = this.#graph.getReferencedAssets(
+      bundleToInternalBundle(bundle),
+    );
+
+    // Convert internal assets to public assets
+    let publicReferencedAssets = new Set<IAsset>();
+    for (let internalAsset of internalReferencedAssets) {
+      publicReferencedAssets.add(assetFromValue(internalAsset, this.#options));
+    }
+
+    return publicReferencedAssets;
+  }
+
   hasParentBundleOfType(bundle: IBundle, type: string): boolean {
     return this.#graph.hasParentBundleOfType(
       bundleToInternalBundle(bundle),

package/src/requests/AssetGraphRequestRust.ts

@@ -53,18 +53,17 @@ export function createAssetGraphRequestRust(
     id: input.name,
     run: async (input) => {
       let options = input.options;
-      let serializedAssetGraph =
-        (await rustAtlaspack.buildAssetGraph()) as SerializedAssetGraphDelta;
+      let {assetGraphPromise, commitPromise} =
+        await rustAtlaspack.buildAssetGraph();
 
-      // Newly created nodes
-      serializedAssetGraph.nodes = serializedAssetGraph.nodes.map((node) =>
-        JSON.parse(node),
-      );
+      let [serializedAssetGraph, assetGraphError] =
+        (await assetGraphPromise) as [SerializedAssetGraphDelta, Error | null];
 
-      // Updated existing nodes
-      serializedAssetGraph.updates = serializedAssetGraph.updates.map((node) =>
-        JSON.parse(node),
-      );
+      if (assetGraphError) {
+        throw new ThrowableDiagnostic({
+          diagnostic: assetGraphError,
+        });
+      }
 
       // Don't reuse a previous asset graph result if Rust didn't have one too
       let prevResult = null;
@@ -106,6 +105,17 @@ export function createAssetGraphRequestRust(
         previousSymbolPropagationErrors: undefined,
       };
 
+      let [_commitResult, commitError] = await commitPromise;
+
+      if (commitError) {
+        throw new ThrowableDiagnostic({
+          diagnostic: {
+            message:
+              'Error committing asset graph in Rust: ' + commitError.message,
+          },
+        });
+      }
+
       await input.api.storeResult(result);
       input.api.invalidateOnBuild();
 
@@ -213,7 +223,7 @@ export function getAssetGraph(
 
     let envId = envs.get(envKey);
     if (envId == null) {
-      envId = envs.size.toString();
+      envId = getEnvironmentHash(env);
       envs.set(envKey, envId);
     }
 
@@ -242,6 +252,8 @@ export function getAssetGraph(
       ? serializedGraph.updates[index - nodeTypeSwitchoverIndex]
       : serializedGraph.nodes[index];
 
+    node = JSON.parse(node);
+
     if (node.type === 'entry') {
       let id = 'entry:' + ++entry;
 

package/src/requests/BundleGraphRequest.ts

@@ -17,7 +17,7 @@ import fs from 'fs';
 import invariant from 'assert';
 import assert from 'assert';
 import nullthrows from 'nullthrows';
-import {PluginLogger} from '@atlaspack/logger';
+import {instrumentAsync, PluginLogger} from '@atlaspack/logger';
 import {getFeatureFlag} from '@atlaspack/feature-flags';
 import ThrowableDiagnostic, {errorToDiagnostic} from '@atlaspack/diagnostic';
 import AssetGraph from '../AssetGraph';
@@ -155,12 +155,14 @@ export default function createBundleGraphRequest(
         requestedAssetIds,
       });
 
-      let {assetGraph, changedAssets, assetRequests} = await api.runRequest(
-        request,
-        {
-          force:
-            Boolean(input.rustAtlaspack) ||
-            (options.shouldBuildLazily && requestedAssetIds.size > 0),
+      let {assetGraph, changedAssets, assetRequests} = await instrumentAsync(
+        'asset-graph-request',
+        () => {
+          return api.runRequest(request, {
+            force:
+              Boolean(input.rustAtlaspack) ||
+              (options.shouldBuildLazily && requestedAssetIds.size > 0),
+          });
         },
       );
 

package/src/resolveOptions.ts

@@ -269,6 +269,7 @@ export default async function resolveOptions(
       : false,
     shouldDisableCache: initialOptions.shouldDisableCache ?? false,
     shouldProfile: initialOptions.shouldProfile ?? false,
+    nativeProfiler: initialOptions.nativeProfiler,
     shouldTrace: initialOptions.shouldTrace ?? false,
     cacheDir,
     watchDir,

package/src/types.ts

@@ -335,6 +335,7 @@ export type AtlaspackOptions = {
   logLevel: LogLevel;
   projectRoot: FilePath;
   shouldProfile: boolean;
+  nativeProfiler: 'instruments' | 'samply' | undefined;
   shouldTrace: boolean;
   shouldPatchConsole: boolean;
   detailedReport?: DetailedReportOptions | null | undefined;

package/src/worker.ts

@@ -21,7 +21,7 @@ import Validation, {ValidationOpts} from './Validation';
 import {AtlaspackConfig} from './AtlaspackConfig';
 import {registerCoreWithSerializer} from './registerCoreWithSerializer';
 import {clearBuildCaches} from '@atlaspack/build-cache';
-import {init as initSourcemaps} from '@parcel/source-map';
+import {init as initSourcemaps} from '@atlaspack/source-map';
 // @ts-expect-error TS2305
 import {init as initRust} from '@atlaspack/rust';
 import WorkerFarm from '@atlaspack/workers';

package/test/AtlaspackConfigRequest.test.ts

@@ -133,7 +133,7 @@ describe('AtlaspackConfigRequest', () => {
         (e: any) => {
           assert.strictEqual(
             e.diagnostics[0].codeFrames[0].codeHighlights[0].message,
-            `Possible values: "$schema", "bundler", "resolvers", "transformers", "validators", "namers", "packagers", "optimizers", "compressors", "reporters", "runtimes", "filePath", "resolveFrom"`,
+            `Possible values: "$schema", "bundler", "resolvers", "transformers", "validators", "namers", "packagers", "optimizers", "compressors", "reporters", "runtimes", "unstable\\_alias", "filePath", "resolveFrom"`,
           );
           return true;
         },