@atlaspack/core 2.36.0 → 2.38.2

package/lib/atlaspack-v3/worker/worker.js

@@ -40,6 +40,13 @@ function _worker_threads() {
   };
   return data;
 }
+function _logger() {
+  const data = _interopRequireWildcard(require("@atlaspack/logger"));
+  _logger = function () {
+    return data;
+  };
+  return data;
+}
 function _module() {
   const data = _interopRequireWildcard(require("module"));
   _module = function () {
@@ -144,7 +151,9 @@ class AtlaspackWorker {
     const env = new _compat.Environment(napiDependency.env);
     const dependency = new _compat.Dependency(napiDependency, env);
     const defaultOptions = {
-      logger: new _compat.PluginLogger(),
+      logger: new (_logger().PluginLogger)({
+        origin: key
+      }),
       tracer: new _compat.PluginTracer(),
       options: new _compat.PluginOptions(this.options)
     };
@@ -186,14 +195,25 @@ class AtlaspackWorker {
         }
       };
     }
+    // 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: _compat.dependencyPriorityMap.intoNullable(result.priority),
@@ -229,7 +249,9 @@ class AtlaspackWorker {
     contents, env, this.#fs, map, this.options.projectRoot);
     const pluginOptions = new _compat.PluginOptions(this.options);
     const defaultOptions = {
-      logger: new _compat.PluginLogger(),
+      logger: new (_logger().PluginLogger)({
+        origin: key
+      }),
       tracer: new _compat.PluginTracer(),
       options: pluginOptions
     };
@@ -358,7 +380,9 @@ class AtlaspackWorker {
     if (transformer.setup) {
       var _setupResult$env;
       let setupResult = await transformer.setup({
-        logger: new _compat.PluginLogger(),
+        logger: new (_logger().PluginLogger)({
+          origin: specifier
+        }),
         options: new _compat.PluginOptions({
           ...this.options,
           shouldAutoInstall: false,
@@ -395,8 +419,17 @@ class AtlaspackWorker {
   }
 }
 
-// Create napi worker and send it back to main thread
+// Forward all logger events from this worker thread to the main thread so
+// they are re-emitted into the main-thread logger and reach reporters.
 exports.AtlaspackWorker = AtlaspackWorker;
+_logger().default.onLog(event => {
+  _worker_threads().parentPort === null || _worker_threads().parentPort === void 0 || _worker_threads().parentPort.postMessage({
+    type: 'logEvent',
+    event
+  });
+});
+
+// Create napi worker and send it back to main thread
 const worker = new AtlaspackWorker();
 const napiWorker = napi().newNodejsWorker(worker);
 _worker_threads().parentPort === null || _worker_threads().parentPort === void 0 || _worker_threads().parentPort.postMessage(napiWorker);

package/lib/requests/AssetGraphRequestRust.js

@@ -34,6 +34,7 @@ function _featureFlags() {
   return data;
 }
 var _AssetGraph = _interopRequireDefault(require("../AssetGraph"));
+var _ReporterRunner = require("../ReporterRunner");
 var _RequestTracker = require("../RequestTracker");
 var _SymbolPropagation = require("../SymbolPropagation");
 var _EnvironmentManager = require("../EnvironmentManager");
@@ -51,7 +52,10 @@ function createAssetGraphRequestRust(rustAtlaspack) {
       let {
         assetGraphPromise,
         commitPromise
-      } = await rustAtlaspack.buildAssetGraph();
+      } = await rustAtlaspack.buildAssetGraph(eventJson => {
+        let event = JSON.parse(eventJson);
+        (0, _ReporterRunner.report)(event);
+      });
       let [serializedAssetGraph, assetGraphError] = await assetGraphPromise;
       if (assetGraphError) {
         throw new (_diagnostic().default)({

package/lib/requests/AtlaspackBuildRequest.js

@@ -30,6 +30,13 @@ function _featureFlags() {
   return data;
 }
 var _EnvironmentManager = require("../EnvironmentManager");
+function _logger() {
+  const data = require("@atlaspack/logger");
+  _logger = function () {
+    return data;
+  };
+  return data;
+}
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 function createAtlaspackBuildRequest(input) {
   return {
@@ -96,6 +103,7 @@ async function run({
     changedAssets: new Map(Array.from(changedAssets).map(([id, asset]) => [id, (0, _Asset.assetFromValue)(asset, options)]))
   });
   let packagingMeasurement = _profiler().tracer.createMeasurement('packaging');
+  const span = _logger().tracer.enter('writeBundles');
   let writeBundlesRequest = (0, _WriteBundlesRequest.default)({
     bundleGraph,
     optionsRef
@@ -105,6 +113,7 @@ async function run({
     scopeHoistingStats
   } = await api.runRequest(writeBundlesRequest);
   packagingMeasurement && packagingMeasurement.end();
+  _logger().tracer.exit(span);
   (0, _utils.assertSignalNotAborted)(signal);
   return {
     bundleGraph,

package/lib/requests/BundleGraphRequestRust.js

@@ -41,6 +41,7 @@ function _featureFlags() {
   return data;
 }
 var _BundleGraph = _interopRequireWildcard(require("../BundleGraph"));
+var _ReporterRunner = require("../ReporterRunner");
 var _dumpGraphToGraphViz = _interopRequireDefault(require("../dumpGraphToGraphViz"));
 function _nullthrows() {
   const data = _interopRequireDefault(require("nullthrows"));
@@ -83,7 +84,10 @@ function createBundleGraphRequestRust(input) {
       let {
         bundleGraphPromise,
         commitPromise
-      } = await rustAtlaspack.buildBundleGraph();
+      } = await rustAtlaspack.buildBundleGraph(eventJson => {
+        let event = JSON.parse(eventJson);
+        (0, _ReporterRunner.report)(event);
+      });
       let [serializedBundleGraph, bundleGraphError] = await bundleGraphPromise;
       if (bundleGraphError) {
         throw new (_diagnostic().default)({

package/lib/types/atlaspack-v3/AtlaspackV3.d.ts

@@ -24,8 +24,9 @@ export declare class AtlaspackV3 {
     constructor(atlaspack_napi: AtlaspackNapi, napiWorkerPool: INapiWorkerPool, isDefaultNapiWorkerPool: boolean);
     static create({ fs, packageManager, threads, lmdb, napiWorkerPool, ...options }: AtlaspackV3Options): Promise<AtlaspackV3>;
     end(): void;
-    buildAssetGraph(): Promise<any>;
-    buildBundleGraph(): Promise<any>;
+    buildAssetGraph(progressCallback?: (eventJson: string) => void): Promise<any>;
+    buildBundleGraph(progressCallback?: (eventJson: string) => void): Promise<any>;
+    build(progressCallback: (eventJson: string) => void): Promise<any>;
     loadBundleGraph(bundleGraph: BundleGraph): Promise<void>;
     updateBundleGraph(bundleGraph: BundleGraph, changedAssetIds: string[]): Promise<void>;
     package(bundleId: string, options?: PackageOptions): Promise<[RunPackagerRunnerResult, Diagnostic | null]>;

package/lib/types/atlaspack-v3/fs.d.ts

@@ -9,4 +9,5 @@ export declare class FileSystemV3 implements FileSystem {
     isFile: JsCallable<[FilePath], boolean>;
     isDir: JsCallable<[FilePath], boolean>;
     readFile: JsCallable<[FilePath, Encoding], string>;
+    writeFile: JsCallable<[FilePath, number[]], Promise<void>>;
 }

package/lib/types/atlaspack-v3/worker/compat/index.d.ts

@@ -4,6 +4,5 @@ export * from './environment';
 export * from './target';
 export * from './plugin-config';
 export * from './plugin-tracer';
-export * from './plugin-logger';
 export * from './plugin-options';
 export * from './mutable-asset';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/core",
-  "version": "2.36.0",
+  "version": "2.38.2",
   "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
     "access": "public"
@@ -23,22 +23,22 @@
   },
   "dependencies": {
     "@mischnic/json-sourcemap": "^0.1.0",
-    "@atlaspack/build-cache": "2.13.13",
-    "@atlaspack/cache": "3.2.51",
+    "@atlaspack/build-cache": "2.13.14",
+    "@atlaspack/cache": "3.2.55",
     "@atlaspack/diagnostic": "2.14.4",
     "@atlaspack/events": "2.14.4",
-    "@atlaspack/feature-flags": "2.30.1",
-    "@atlaspack/fs": "2.15.51",
-    "@atlaspack/graph": "3.6.18",
-    "@atlaspack/logger": "2.14.48",
-    "@atlaspack/package-manager": "2.14.56",
-    "@atlaspack/plugin": "2.14.56",
-    "@atlaspack/profiler": "2.15.17",
-    "@atlaspack/rust": "3.24.1",
-    "@atlaspack/types": "2.15.46",
-    "@atlaspack/utils": "3.3.8",
-    "@atlaspack/workers": "2.14.56",
-    "@atlaspack/source-map": "3.3.0",
+    "@atlaspack/feature-flags": "2.31.0",
+    "@atlaspack/fs": "2.15.55",
+    "@atlaspack/graph": "3.6.22",
+    "@atlaspack/logger": "2.14.52",
+    "@atlaspack/package-manager": "2.14.60",
+    "@atlaspack/plugin": "2.14.60",
+    "@atlaspack/profiler": "2.15.21",
+    "@atlaspack/rust": "3.28.0",
+    "@atlaspack/types": "2.15.50",
+    "@atlaspack/utils": "3.4.2",
+    "@atlaspack/workers": "2.14.60",
+    "@atlaspack/source-map": "3.3.4",
     "base-x": "^3.0.8",
     "browserslist": "^4.6.6",
     "clone": "^2.1.1",

package/src/Atlaspack.ts

@@ -67,6 +67,7 @@ import {AtlaspackV3, FileSystemV3} from './atlaspack-v3';
 import createAssetGraphRequestJS from './requests/AssetGraphRequest';
 import {createAssetGraphRequestRust} from './requests/AssetGraphRequestRust';
 import type {AssetGraphRequestResult} from './requests/AssetGraphRequest';
+import {getBundleGraph} from './requests/BundleGraphRequestRust';
 import {loadRustWorkerThreadDylibHack} from './rustWorkerThreadDylibHack';
 
 registerCoreWithSerializer();
@@ -171,6 +172,7 @@ export default class Atlaspack {
     let rustAtlaspack: AtlaspackV3;
     if (
       resolvedOptions.featureFlags.atlaspackV3 ||
+      resolvedOptions.featureFlags.fullNative ||
       resolvedOptions.featureFlags.nativePackager
     ) {
       // eslint-disable-next-line no-unused-vars
@@ -433,19 +435,59 @@ export default class Atlaspack {
 
       this.#requestTracker.graph.invalidateOnBuildNodes();
 
-      let request = createAtlaspackBuildRequest({
-        optionsRef: this.#optionsRef,
-        requestedAssetIds: this.#requestedAssetIds,
-        signal,
-      });
+      let bundleGraph: any;
+      let bundleInfo: Map<any, any>;
+      let changedAssets: Map<any, any>;
+      let assetRequests: Array<any>;
+      let scopeHoistingStats: any;
+
+      if (getFeatureFlag('fullNative') && this.rustAtlaspack) {
+        let [result, error] = await this.rustAtlaspack.build(
+          (eventJson: string) => {
+            let event = JSON.parse(eventJson);
+            this.#reporterRunner.report(event);
+          },
+        );
+
+        if (error) {
+          throw new ThrowableDiagnostic({diagnostic: error});
+        }
+        ({bundleGraph, changedAssets} = getBundleGraph(result));
+        bundleInfo = new Map(
+          (result.bundleInfo ?? []).map(
+            (info: {
+              bundleId: string;
+              filePath: string;
+              type: string;
+              size: number;
+              time: number;
+            }) => [
+              info.bundleId,
+              {
+                filePath: toProjectPath(options.projectRoot, info.filePath),
+                bundleId: info.bundleId,
+                type: info.type,
+                stats: {size: info.size, time: info.time},
+              },
+            ],
+          ),
+        );
+        assetRequests = result.assetRequests ?? [];
+      } else {
+        let request = createAtlaspackBuildRequest({
+          optionsRef: this.#optionsRef,
+          requestedAssetIds: this.#requestedAssetIds,
+          signal,
+        });
 
-      let {
-        bundleGraph,
-        bundleInfo,
-        changedAssets,
-        assetRequests,
-        scopeHoistingStats,
-      } = await this.#requestTracker.runRequest(request, {force: true});
+        ({
+          bundleGraph,
+          bundleInfo,
+          changedAssets,
+          assetRequests,
+          scopeHoistingStats,
+        } = await this.#requestTracker.runRequest(request, {force: true}));
+      }
 
       this.#requestedAssetIds.clear();
 

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/NapiWorkerPool.ts

@@ -5,6 +5,8 @@ import process from 'process';
 // @ts-expect-error TS2724
 import type {Transferable} from '@atlaspack/rust';
 import {getAvailableThreads} from '@atlaspack/rust';
+import logger from '@atlaspack/logger';
+import type {LogEvent} from '@atlaspack/types-internal';
 
 const WORKER_PATH = path.join(__dirname, 'worker', 'index.js');
 const ATLASPACK_NAPI_WORKERS =
@@ -43,6 +45,35 @@ export class NapiWorkerPool implements INapiWorkerPool {
           worker.once('message', res),
         ),
       );
+
+      // Re-emit log events from the worker thread into the main-thread logger
+      // so they reach reporters and are subject to log-level filtering.
+      worker.on('message', (message: unknown) => {
+        if (
+          message != null &&
+          typeof message === 'object' &&
+          (message as {type?: unknown}).type === 'logEvent'
+        ) {
+          const event = (message as {type: string; event: LogEvent}).event;
+          switch (event.level) {
+            case 'verbose':
+              logger.verbose(event.diagnostics);
+              break;
+            case 'info':
+              logger.info(event.diagnostics);
+              break;
+            case 'warn':
+              logger.warn(event.diagnostics);
+              break;
+            case 'error':
+              logger.error(event.diagnostics);
+              break;
+            case 'progress':
+              logger.progress(event.message);
+              break;
+          }
+        }
+      });
     }
   }
 
@@ -59,6 +90,13 @@ export class NapiWorkerPool implements INapiWorkerPool {
               if (message === 'stateCleared') {
                 worker.removeListener('message', messageHandler);
                 res();
+              } else if (
+                message != null &&
+                typeof message === 'object' &&
+                (message as {type?: unknown}).type === 'logEvent'
+              ) {
+                // logEvent messages are forwarded asynchronously from the worker
+                // logger bridge and are expected at any time; ignore them here.
               } else {
                 // Log unexpected messages for debugging
                 // eslint-disable-next-line no-console

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/compat/index.ts

@@ -4,6 +4,5 @@ export * from './environment';
 export * from './target';
 export * from './plugin-config';
 export * from './plugin-tracer';
-export * from './plugin-logger';
 export * from './plugin-options';
 export * from './mutable-asset';

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

@@ -19,14 +19,15 @@ import type {
 } from '@atlaspack/types';
 import type {FeatureFlags} from '@atlaspack/feature-flags';
 import {parentPort} from 'worker_threads';
+import logger from '@atlaspack/logger';
 import * as module from 'module';
 
 import {jsCallable} from '../jsCallable';
+import {PluginLogger} from '@atlaspack/logger';
 import {
   Environment,
   Dependency,
   PluginConfig,
-  PluginLogger,
   PluginTracer,
   PluginOptions,
   MutableAsset,
@@ -130,7 +131,7 @@ export class AtlaspackWorker {
       const dependency = new Dependency(napiDependency, env);
 
       const defaultOptions = {
-        logger: new PluginLogger(),
+        logger: new PluginLogger({origin: key}),
         tracer: new PluginTracer(),
         options: new PluginOptions(this.options),
       } as const;
@@ -173,15 +174,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),
@@ -227,7 +237,7 @@ export class AtlaspackWorker {
 
     const pluginOptions = new PluginOptions(this.options);
     const defaultOptions = {
-      logger: new PluginLogger(),
+      logger: new PluginLogger({origin: key}),
       tracer: new PluginTracer(),
       options: pluginOptions,
     } as const;
@@ -394,7 +404,7 @@ export class AtlaspackWorker {
 
     if (transformer.setup) {
       let setupResult = await transformer.setup({
-        logger: new PluginLogger(),
+        logger: new PluginLogger({origin: specifier}),
         options: new PluginOptions({
           ...this.options,
           shouldAutoInstall: false,
@@ -439,6 +449,12 @@ export class AtlaspackWorker {
   }
 }
 
+// Forward all logger events from this worker thread to the main thread so
+// they are re-emitted into the main-thread logger and reach reporters.
+logger.onLog((event) => {
+  parentPort?.postMessage({type: 'logEvent', event});
+});
+
 // Create napi worker and send it back to main thread
 const worker = new AtlaspackWorker();
 const napiWorker = napi.newNodejsWorker(worker);

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];