@atlaspack/core 2.16.2-canary.48 → 2.16.2-canary.481

package/src/atlaspack-v3/AtlaspackV3.ts

@@ -0,0 +1,183 @@
+import {
+  atlaspackNapiCreate,
+  atlaspackNapiBuild,
+  atlaspackNapiBuildAssetGraph,
+  atlaspackNapiBuildBundleGraph,
+  atlaspackNapiRespondToFsEvents,
+  atlaspackNapiCompleteSession,
+  atlaspackNapiLoadBundleGraph,
+  atlaspackNapiPackage,
+  atlaspackNapiUpdateBundleGraph,
+  AtlaspackNapi,
+  Lmdb,
+  AtlaspackNapiOptions,
+  CacheStats,
+  PackageOptions,
+} from '@atlaspack/rust';
+import {NapiWorkerPool} from './NapiWorkerPool';
+import ThrowableDiagnostic, {Diagnostic} from '@atlaspack/diagnostic';
+import type {Event} from '@parcel/watcher';
+import type {NapiWorkerPool as INapiWorkerPool} from '@atlaspack/types';
+import type BundleGraph from '../BundleGraph';
+import {RunPackagerRunnerResult} from '../PackagerRunner';
+
+export type AtlaspackV3Options = {
+  fs?: AtlaspackNapiOptions['fs'];
+  packageManager?: AtlaspackNapiOptions['packageManager'];
+  threads?: number;
+  /**
+   * A reference to LMDB lite's rust object
+   */
+  lmdb: Lmdb;
+  featureFlags?: {
+    [key: string]: string | boolean;
+  };
+  napiWorkerPool?: INapiWorkerPool;
+} & AtlaspackNapiOptions['options'];
+
+export class AtlaspackV3 {
+  _atlaspack_napi: AtlaspackNapi;
+  _napiWorkerPool: INapiWorkerPool;
+  _isDefaultNapiWorkerPool: boolean;
+
+  constructor(
+    atlaspack_napi: AtlaspackNapi,
+    napiWorkerPool: INapiWorkerPool,
+    isDefaultNapiWorkerPool: boolean,
+  ) {
+    this._atlaspack_napi = atlaspack_napi;
+    this._napiWorkerPool = napiWorkerPool;
+    this._isDefaultNapiWorkerPool = isDefaultNapiWorkerPool;
+  }
+
+  static async create({
+    fs,
+    packageManager,
+    threads,
+    lmdb,
+    napiWorkerPool,
+    ...options
+  }: AtlaspackV3Options): Promise<AtlaspackV3> {
+    // @ts-expect-error TS2339
+    options.logLevel = options.logLevel || 'error';
+    // @ts-expect-error TS2339
+    options.defaultTargetOptions = options.defaultTargetOptions || {};
+    // @ts-expect-error TS2339
+    options.defaultTargetOptions.engines =
+      // @ts-expect-error TS2339
+      options.defaultTargetOptions.engines || {};
+
+    let isDefaultNapiWorkerPool = false;
+    if (!napiWorkerPool) {
+      napiWorkerPool = new NapiWorkerPool();
+      isDefaultNapiWorkerPool = true;
+    }
+
+    // @ts-expect-error TS2488
+    const [internal, error] = await atlaspackNapiCreate(
+      {
+        fs,
+        packageManager,
+        threads,
+        options,
+        napiWorkerPool,
+      },
+      lmdb,
+    );
+
+    if (error !== null) {
+      throw new ThrowableDiagnostic({
+        diagnostic: error,
+      });
+    }
+
+    return new AtlaspackV3(internal, napiWorkerPool, isDefaultNapiWorkerPool);
+  }
+
+  end(): void {
+    // If the worker pool was provided to us, don't shut it down, it's up to the provider.
+    if (this._isDefaultNapiWorkerPool) {
+      this._napiWorkerPool.shutdown();
+    }
+  }
+
+  buildAssetGraph(
+    progressCallback?: (eventJson: string) => void,
+  ): Promise<any> {
+    return atlaspackNapiBuildAssetGraph(
+      this._atlaspack_napi,
+      progressCallback,
+    ) 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> {
+    const {nodesJson, edges, publicIdByAssetId, environmentsJson} =
+      bundleGraph.serializeForNative();
+
+    return atlaspackNapiLoadBundleGraph(
+      this._atlaspack_napi,
+      nodesJson,
+      edges,
+      publicIdByAssetId,
+      environmentsJson,
+    ) as Promise<void>;
+  }
+
+  updateBundleGraph(
+    bundleGraph: BundleGraph,
+    changedAssetIds: string[],
+  ): Promise<void> {
+    const nodesJson = bundleGraph.serializeAssetNodesForNative(changedAssetIds);
+    return atlaspackNapiUpdateBundleGraph(
+      this._atlaspack_napi,
+      nodesJson,
+    ) as Promise<void>;
+  }
+
+  package(
+    bundleId: string,
+    options?: PackageOptions,
+  ): Promise<[RunPackagerRunnerResult, Diagnostic | null]> {
+    return atlaspackNapiPackage(
+      this._atlaspack_napi,
+      bundleId,
+      options,
+    ) as Promise<[RunPackagerRunnerResult, Diagnostic | null]>;
+  }
+
+  async respondToFsEvents(events: Array<Event>): Promise<boolean> {
+    // @ts-expect-error TS2488
+    let [needsRebuild, error] = await atlaspackNapiRespondToFsEvents(
+      this._atlaspack_napi,
+      events,
+    );
+
+    if (error) {
+      throw new Error(error);
+    }
+
+    return needsRebuild;
+  }
+
+  async completeCacheSession(): Promise<CacheStats> {
+    return (await atlaspackNapiCompleteSession(
+      this._atlaspack_napi,
+    )) as CacheStats;
+  }
+}

package/src/atlaspack-v3/NapiWorkerPool.ts

@@ -0,0 +1,129 @@
+import type {NapiWorkerPool as INapiWorkerPool} from '@atlaspack/types';
+import {Worker} from 'worker_threads';
+import path from 'path';
+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 =
+  process.env.ATLASPACK_NAPI_WORKERS &&
+  parseInt(process.env.ATLASPACK_NAPI_WORKERS, 10);
+
+export type NapiWorkerPoolOptions = {
+  workerCount?: number;
+};
+
+export class NapiWorkerPool implements INapiWorkerPool {
+  #workers: Worker[];
+  #napiWorkers: Array<Promise<Transferable>>;
+  #workerCount: number;
+
+  constructor({workerCount}: NapiWorkerPoolOptions = {workerCount: undefined}) {
+    // @ts-expect-error TS2322
+    this.#workerCount =
+      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
+    }
+
+    this.#workers = [];
+    this.#napiWorkers = [];
+
+    for (let i = 0; i < this.#workerCount; i++) {
+      let worker = new Worker(WORKER_PATH);
+      this.#workers.push(worker);
+      this.#napiWorkers.push(
+        new Promise((res: (result: Promise<never>) => void) =>
+          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;
+          }
+        }
+      });
+    }
+  }
+
+  clearAllWorkerState(): Promise<void[]> {
+    return Promise.all(
+      this.#workers.map(
+        (worker) =>
+          new Promise<void>((res) => {
+            worker.postMessage('clearState');
+
+            // Set up a message handler that only resolves on 'stateCleared'
+            // and ignores all other messages (like the initial napiWorker Transferable)
+            const messageHandler = (message: unknown) => {
+              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
+                console.warn(
+                  `[NapiWorkerPool] Received unexpected message during clearAllWorkerState: ${JSON.stringify(message)} (type: ${typeof message})`,
+                );
+                // Keep listening for 'stateCleared' - don't remove the listener
+              }
+            };
+
+            worker.on('message', messageHandler);
+          }),
+      ),
+    );
+  }
+
+  workerCount(): number {
+    return this.#workerCount;
+  }
+
+  getWorkers(): Promise<Array<Transferable>> {
+    return Promise.all(this.#napiWorkers);
+  }
+
+  shutdown(): void {
+    for (const worker of this.#workers) {
+      worker.terminate();
+    }
+  }
+}

package/src/atlaspack-v3/{fs.js → fs.ts}

@@ -1,5 +1,4 @@
-// @flow strict-local
-
+// @ts-expect-error TS2305
 import type {FileSystem, JsCallable} from '@atlaspack/rust';
 import type {
   Encoding,
@@ -9,6 +8,7 @@ import type {
 
 import {jsCallable} from './jsCallable';
 
+// @ts-expect-error TS2420
 export class FileSystemV3 implements FileSystem {
   #fs: IFileSystem;
 
@@ -20,7 +20,7 @@ export class FileSystemV3 implements FileSystem {
     (path: FilePath) => this.#fs.realpathSync(path),
   );
 
-  createDirectory: JsCallable<[FilePath], Promise<void>> = jsCallable(
+  createDirectory: JsCallable<[FilePath], Promise<undefined>> = jsCallable(
     (path: FilePath) => this.#fs.mkdirp(path),
   );
 
@@ -45,11 +45,15 @@ export class FileSystemV3 implements FileSystem {
   readFile: JsCallable<[FilePath, Encoding], string> = jsCallable(
     (path: string, encoding?: Encoding) => {
       if (!encoding) {
-        // $FlowFixMe
         return [...this.#fs.readFileSync(path)];
       } else {
         return this.#fs.readFileSync(path, encoding);
       }
     },
   );
+
+  writeFile: JsCallable<[FilePath, number[]], Promise<void>> = jsCallable(
+    (path: FilePath, contents: number[]) =>
+      this.#fs.writeFile(path, Buffer.from(contents)),
+  );
 }

package/src/atlaspack-v3/{index.js → index.ts}

@@ -1,7 +1,6 @@
-// @flow
-
 export {FileSystemV3} from './fs';
 export {AtlaspackV3} from './AtlaspackV3';
 export {NapiWorkerPool} from './NapiWorkerPool';
-export type * from './AtlaspackV3';
-export type * from './NapiWorkerPool';
+export * from './AtlaspackV3';
+export * from './NapiWorkerPool';
+export type {CacheStats} from '@atlaspack/rust';

package/src/atlaspack-v3/jsCallable.ts

@@ -0,0 +1,14 @@
+export function jsCallable<Args extends ReadonlyArray<unknown>, Return>(
+  fn: (...rest: Args) => Return | Promise<Return>,
+): (...rest: Args) => Promise<Return> {
+  return async (...args: Args): Promise<Return> => {
+    try {
+      // Promises and is safe to use on non-promises
+      return await fn(...args);
+    } catch (error: any) {
+      // eslint-disable-next-line no-console
+      console.error(error);
+      throw error;
+    }
+  };
+}

package/src/atlaspack-v3/worker/compat/{asset-symbols.js → asset-symbols.ts}

@@ -1,5 +1,3 @@
-// @flow
-
 import type {Symbol as NapiSymbol} from '@atlaspack/rust';
 import type {
   AssetSymbols as IAssetSymbols,
@@ -18,7 +16,7 @@ export class MutableDependencySymbols implements IMutableDependencySymbols {
     return this.#symbols.size === 0;
   }
 
-  constructor(inner: ?(NapiSymbol[]) | null) {
+  constructor(inner: NapiSymbol[] | null | undefined | null) {
     this.#symbols = new Map();
     this.#locals = new Set();
     for (const {exported, local, loc, isWeak} of inner || []) {
@@ -30,7 +28,7 @@ export class MutableDependencySymbols implements IMutableDependencySymbols {
     throw new Error('MutableDependencySymbols.ensure()');
   }
 
-  get(exportSymbol: Symbol): ?DependencyAssetSymbol {
+  get(exportSymbol: Symbol): DependencyAssetSymbol | null | undefined {
     return this.#symbols.get(exportSymbol);
   }
 
@@ -49,8 +47,8 @@ export class MutableDependencySymbols implements IMutableDependencySymbols {
   set(
     exportSymbol: Symbol,
     local: Symbol,
-    loc: ?SourceLocation,
-    isWeak: ?boolean,
+    loc?: SourceLocation | null,
+    isWeak?: boolean | null,
   ): void {
     this.#locals.add(local);
     this.#symbols.set(exportSymbol, {
@@ -69,7 +67,7 @@ export class MutableDependencySymbols implements IMutableDependencySymbols {
   }
 
   /*::  @@iterator(): Iterator<[Symbol, DependencyAssetSymbol]> { return ({}: any); } */
-  // $FlowFixMe Flow can't do computed properties
+  // @ts-expect-error TS2416
   [Symbol.iterator]() {
     return this.#symbols.values();
   }
@@ -83,7 +81,7 @@ export class AssetSymbols implements IAssetSymbols {
     return this.#symbols.size === 0;
   }
 
-  constructor(inner: ?(NapiSymbol[]) | null) {
+  constructor(inner: NapiSymbol[] | null | undefined | null) {
     this.#symbols = new Map();
     this.#locals = new Set();
     for (const {exported, local, loc} of inner || []) {
@@ -91,7 +89,11 @@ export class AssetSymbols implements IAssetSymbols {
     }
   }
 
-  #set(exportSymbol: Symbol, local: Symbol, loc: ?SourceLocation): void {
+  #set(
+    exportSymbol: Symbol,
+    local: Symbol,
+    loc?: SourceLocation | null,
+  ): undefined {
     this.#locals.add(local);
     this.#symbols.set(exportSymbol, {
       local,
@@ -100,7 +102,7 @@ export class AssetSymbols implements IAssetSymbols {
     });
   }
 
-  get(exportSymbol: Symbol): ?AssetSymbol {
+  get(exportSymbol: Symbol): AssetSymbol | null | undefined {
     return this.#symbols.get(exportSymbol);
   }
 
@@ -121,7 +123,7 @@ export class AssetSymbols implements IAssetSymbols {
   }
 
   /*::  @@iterator(): Iterator<[Symbol, AssetSymbol]> { return ({}: any); } */
-  // $FlowFixMe Flow can't do computed properties
+  // @ts-expect-error TS2416
   [Symbol.iterator]() {
     return this.#symbols.values();
   }
@@ -135,13 +137,20 @@ export class MutableAssetSymbols implements IMutableAssetSymbols {
     return this.#symbols.size === 0;
   }
 
-  constructor(inner: ?(NapiSymbol[]) | null) {
+  constructor(inner: NapiSymbol[] | null | undefined | null) {
     this.#symbols = new Map();
     this.#locals = new Set();
-    for (const {exported, loc, local, isEsmExport, selfReferenced} of inner ||
-      []) {
+    for (const {
+      exported,
+      loc,
+      local,
+      isEsmExport,
+      selfReferenced,
+      isStaticBindingSafe,
+    } of inner || []) {
       this.set(exported, local, loc, {
         isEsm: isEsmExport,
+        isStaticBindingSafe,
         selfReferenced,
       });
     }
@@ -167,6 +176,7 @@ export class MutableAssetSymbols implements IMutableAssetSymbols {
             }
           : undefined,
         isEsmExport: Boolean(meta?.isEsm),
+        isStaticBindingSafe: Boolean(meta?.isStaticBindingSafe),
         isWeak: false,
         selfReferenced: Boolean(meta?.selfReferenced),
       });
@@ -181,8 +191,8 @@ export class MutableAssetSymbols implements IMutableAssetSymbols {
   set(
     exportSymbol: Symbol,
     local: Symbol,
-    loc: ?SourceLocation,
-    meta: ?Meta,
+    loc?: SourceLocation | null,
+    meta?: Meta | null,
   ): void {
     this.#locals.add(local);
     this.#symbols.set(exportSymbol, {
@@ -192,7 +202,7 @@ export class MutableAssetSymbols implements IMutableAssetSymbols {
     });
   }
 
-  get(exportSymbol: Symbol): ?AssetSymbol {
+  get(exportSymbol: Symbol): AssetSymbol | null | undefined {
     return this.#symbols.get(exportSymbol);
   }
 
@@ -216,21 +226,21 @@ export class MutableAssetSymbols implements IMutableAssetSymbols {
   }
 
   /*::  @@iterator(): Iterator<[Symbol, AssetSymbol]> { return ({}: any); } */
-  // $FlowFixMe Flow can't do computed properties
+  // @ts-expect-error TS2416
   [Symbol.iterator]() {
     return this.#symbols.values();
   }
 }
 
-export type AssetSymbol = {|
-  local: Symbol,
-  loc: ?SourceLocation,
-  meta?: ?Meta,
-|};
-
-export type DependencyAssetSymbol = {|
-  local: Symbol,
-  loc: ?SourceLocation,
-  meta?: ?Meta,
-  isWeak: boolean,
-|};
+export type AssetSymbol = {
+  local: Symbol;
+  loc: SourceLocation | null | undefined;
+  meta?: Meta | null | undefined;
+};
+
+export type DependencyAssetSymbol = {
+  local: Symbol;
+  loc: SourceLocation | null | undefined;
+  meta?: Meta | null | undefined;
+  isWeak: boolean;
+};

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

@@ -0,0 +1,102 @@
+import type {
+  BundleBehavior,
+  DependencyPriority,
+  SpecifierType,
+} from '@atlaspack/types';
+
+/// BitFlags is used to map number/string types from napi types
+export class BitFlags<K> {
+  // @ts-expect-error TS2344
+  #kv: Partial<Record<K, number>>;
+  #vk: Partial<Record<number, K>>;
+
+  // @ts-expect-error TS2344
+  constructor(source: Partial<Record<K, number>>) {
+    this.#kv = source;
+    this.#vk = Object.fromEntries(
+      Object.entries(source).map((a) => a.reverse()),
+    );
+  }
+
+  into(key: K): number {
+    const found = this.#kv[key];
+    if (found === undefined) {
+      throw new Error(`Invalid BundleBehavior(${key})`);
+    }
+    return found;
+  }
+
+  intoNullable(key?: K | null): number | null | undefined {
+    if (key === undefined || key === null) {
+      return undefined;
+    }
+    return this.into(key);
+  }
+
+  from(key: number): K {
+    const found = this.#vk[key];
+    if (found === undefined) {
+      throw new Error(`Invalid BundleBehavior(${key})`);
+    }
+    return found;
+  }
+
+  fromNullable(key?: number | null): K | null | undefined {
+    if (key === undefined || key === null) {
+      return undefined;
+    }
+    return this.from(key);
+  }
+
+  toArray(keys: number): K[] {
+    let values = [];
+    for (let [key, value] of Object.entries(this.#kv) as [K, number][]) {
+      if ((keys & value) !== 0) {
+        values.push(key);
+      }
+    }
+
+    return values;
+  }
+}
+
+export const bundleBehaviorMap: BitFlags<BundleBehavior> = new BitFlags({
+  inline: 0,
+  isolated: 1,
+  inlineIsolated: 2,
+});
+
+export const dependencyPriorityMap: BitFlags<DependencyPriority> = new BitFlags(
+  {
+    sync: 0,
+    parallel: 1,
+    lazy: 2,
+    conditional: 3,
+  },
+);
+
+// Note: The bitflags must match the bitflags in the Rust code.
+// crates/atlaspack_core/src/types/package_json.rs
+export const packageConditionsMap: BitFlags<string> = new BitFlags({
+  import: 1 << 0,
+  require: 1 << 1,
+  module: 1 << 2,
+  node: 1 << 3,
+  browser: 1 << 4,
+  worker: 1 << 5,
+  worklet: 1 << 6,
+  electron: 1 << 7,
+  development: 1 << 8,
+  production: 1 << 9,
+  types: 1 << 10,
+  default: 1 << 11,
+  style: 1 << 12,
+  sass: 1 << 13,
+});
+
+export const specifierTypeMap: BitFlags<SpecifierType> = new BitFlags({
+  esm: 0,
+  commonjs: 1,
+  url: 2,
+  custom: 3,
+});