@atlaspack/core 2.36.0 → 2.38.0

package/src/atlaspack-v3/AtlaspackV3.ts

@@ -1,5 +1,6 @@
 import {
   atlaspackNapiCreate,
+  atlaspackNapiBuild,
   atlaspackNapiBuildAssetGraph,
   atlaspackNapiBuildBundleGraph,
   atlaspackNapiRespondToFsEvents,
@@ -100,12 +101,29 @@ export class AtlaspackV3 {
     }
   }
 
-  buildAssetGraph(): Promise<any> {
-    return atlaspackNapiBuildAssetGraph(this._atlaspack_napi) as Promise<any>;
+  buildAssetGraph(
+    progressCallback?: (eventJson: string) => void,
+  ): Promise<any> {
+    return atlaspackNapiBuildAssetGraph(
+      this._atlaspack_napi,
+      progressCallback,
+    ) as Promise<any>;
   }
 
-  buildBundleGraph(): Promise<any> {
-    return atlaspackNapiBuildBundleGraph(this._atlaspack_napi) as Promise<any>;
+  buildBundleGraph(
+    progressCallback?: (eventJson: string) => void,
+  ): Promise<any> {
+    return atlaspackNapiBuildBundleGraph(
+      this._atlaspack_napi,
+      progressCallback,
+    ) as Promise<any>;
+  }
+
+  build(progressCallback: (eventJson: string) => void): Promise<any> {
+    return atlaspackNapiBuild(
+      this._atlaspack_napi,
+      progressCallback,
+    ) as Promise<any>;
   }
 
   loadBundleGraph(bundleGraph: BundleGraph): Promise<void> {

package/src/atlaspack-v3/fs.ts

@@ -51,4 +51,9 @@ export class FileSystemV3 implements FileSystem {
       }
     },
   );
+
+  writeFile: JsCallable<[FilePath, number[]], Promise<void>> = jsCallable(
+    (path: FilePath, contents: number[]) =>
+      this.#fs.writeFile(path, Buffer.from(contents)),
+  );
 }

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

@@ -173,15 +173,24 @@ export class AtlaspackWorker {
           resolution: {type: 'excluded'},
         };
       }
+      // A resolver may return a result without filePath to indicate it didn't
+      // resolve the dependency (equivalent to returning null). The JS-side
+      // PathRequest treats this as "try the next resolver".
+      if (!result.filePath) {
+        return {
+          invalidations: [],
+          resolution: {type: 'unresolved'},
+        };
+      }
 
       return {
         invalidations: [],
         resolution: {
           type: 'resolved',
-          filePath: result.filePath || '',
+          filePath: result.filePath,
           canDefer: result.canDefer || false,
           sideEffects: result.sideEffects ?? true,
-          code: result.code || undefined,
+          code: result.code ?? undefined,
           meta: result.meta || undefined,
           pipeline: result.pipeline || undefined,
           priority: dependencyPriorityMap.intoNullable(result.priority),

package/src/requests/AssetGraphRequestRust.ts

@@ -7,6 +7,7 @@ import {getFeatureFlag} from '@atlaspack/feature-flags';
 
 import AssetGraph from '../AssetGraph';
 import type {AtlaspackV3} from '../atlaspack-v3';
+import {report} from '../ReporterRunner';
 import {requestTypes, StaticRunOpts} from '../RequestTracker';
 import {propagateSymbols} from '../SymbolPropagation';
 import type {
@@ -54,7 +55,10 @@ export function createAssetGraphRequestRust(
     run: async (runInput) => {
       let options = runInput.options;
       let {assetGraphPromise, commitPromise} =
-        await rustAtlaspack.buildAssetGraph();
+        await rustAtlaspack.buildAssetGraph((eventJson: string) => {
+          let event = JSON.parse(eventJson);
+          report(event);
+        });
 
       let [serializedAssetGraph, assetGraphError] =
         (await assetGraphPromise) as [SerializedAssetGraphDelta, Error | null];

package/src/requests/AtlaspackBuildRequest.ts

@@ -23,6 +23,7 @@ import {tracer} from '@atlaspack/profiler';
 import {requestTypes} from '../RequestTracker';
 import {getFeatureFlag} from '@atlaspack/feature-flags';
 import {fromEnvironmentId} from '../EnvironmentManager';
+import {tracer as atlaspackTracer} from '@atlaspack/logger';
 
 type AtlaspackBuildRequestInput = {
   optionsRef: SharedReference;
@@ -144,6 +145,8 @@ async function run({
   });
 
   let packagingMeasurement = tracer.createMeasurement('packaging');
+  const span = atlaspackTracer.enter('writeBundles');
+
   let writeBundlesRequest = createWriteBundlesRequest({
     bundleGraph,
     optionsRef,
@@ -152,6 +155,7 @@ async function run({
   let {bundleInfo, scopeHoistingStats} =
     await api.runRequest(writeBundlesRequest);
   packagingMeasurement && packagingMeasurement.end();
+  atlaspackTracer.exit(span);
   assertSignalNotAborted(signal);
 
   return {

package/src/requests/BundleGraphRequestRust.ts

@@ -7,6 +7,7 @@ import {instrument, instrumentAsync, PluginLogger} from '@atlaspack/logger';
 import {getFeatureFlag} from '@atlaspack/feature-flags';
 
 import InternalBundleGraph, {bundleGraphEdgeTypes} from '../BundleGraph';
+import {report} from '../ReporterRunner';
 import dumpGraphToGraphViz from '../dumpGraphToGraphViz';
 import nullthrows from 'nullthrows';
 import {hashString} from '@atlaspack/rust';
@@ -96,7 +97,10 @@ export default function createBundleGraphRequestRust(
       invariant(rustAtlaspack, 'BundleGraphRequestRust requires rustAtlaspack');
 
       let {bundleGraphPromise, commitPromise} =
-        await rustAtlaspack.buildBundleGraph();
+        await rustAtlaspack.buildBundleGraph((eventJson: string) => {
+          let event = JSON.parse(eventJson);
+          report(event);
+        });
       let [serializedBundleGraph, bundleGraphError] =
         (await bundleGraphPromise) as [SerializedBundleGraph, Error | null];