@atlaspack/core 2.16.2-canary.37 → 2.16.2-canary.371

package/src/atlaspack-v3/AtlaspackV3.ts

@@ -0,0 +1,143 @@
+import {
+  atlaspackNapiCreate,
+  atlaspackNapiBuildAssetGraph,
+  atlaspackNapiRespondToFsEvents,
+  atlaspackNapiCompleteSession,
+  atlaspackNapiLoadBundleGraph,
+  atlaspackNapiPackage,
+  AtlaspackNapi,
+  Lmdb,
+  AtlaspackNapiOptions,
+  CacheStats,
+} from '@atlaspack/rust';
+import {NapiWorkerPool} from './NapiWorkerPool';
+import ThrowableDiagnostic from '@atlaspack/diagnostic';
+import type {Event} from '@parcel/watcher';
+import type {NapiWorkerPool as INapiWorkerPool} from '@atlaspack/types';
+import {BundleGraphNode} from '../types';
+import invariant from 'assert';
+import {BundleGraphEdgeType} from '../BundleGraph';
+
+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(): Promise<any> {
+    return atlaspackNapiBuildAssetGraph(this._atlaspack_napi) as Promise<any>;
+  }
+
+  loadBundleGraph({
+    nodes,
+    edges,
+  }: {
+    nodes: BundleGraphNode[];
+    edges: [number, number, BundleGraphEdgeType][];
+  }): Promise<any> {
+    invariant(nodes.length > 0, 'Bundle graph must have at least one node');
+    return atlaspackNapiLoadBundleGraph(
+      this._atlaspack_napi,
+      nodes,
+      edges,
+    ) as Promise<any>;
+  }
+
+  package(): Promise<any> {
+    return atlaspackNapiPackage(this._atlaspack_napi) as Promise<any>;
+  }
+
+  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,91 @@
+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';
+
+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),
+        ),
+      );
+    }
+  }
+
+  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 {
+                // 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,7 +45,6 @@ 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);

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,
+});

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

@@ -1,5 +1,4 @@
-// @flow
-
+// @ts-expect-error TS2305
 import type {Dependency as NapiDependency} from '@atlaspack/rust';
 import type {
   Dependency as IDependency,
@@ -27,23 +26,23 @@ import {
 export class Dependency implements IDependency {
   env: IEnvironment;
   meta: Meta;
-  target: ?ITarget;
+  target: ITarget | null | undefined;
   symbols: IMutableDependencySymbols;
   specifier: DependencySpecifier;
   specifierType: SpecifierType;
   priority: DependencyPriority;
-  bundleBehavior: ?BundleBehavior;
+  bundleBehavior: BundleBehavior | null | undefined;
   needsStableName: boolean;
   isOptional: boolean;
   isEntry: boolean;
-  loc: ?SourceLocation;
-  packageConditions: ?Array<string>;
-  sourceAssetId: ?string;
-  sourcePath: ?FilePath;
-  sourceAssetType: ?string;
-  resolveFrom: ?FilePath;
-  range: ?SemverRange;
-  pipeline: ?string;
+  loc: SourceLocation | null | undefined;
+  packageConditions: Array<string> | null | undefined;
+  sourceAssetId: string | null | undefined;
+  sourcePath: FilePath | null | undefined;
+  sourceAssetType: string | null | undefined;
+  resolveFrom: FilePath | null | undefined;
+  range: SemverRange | null | undefined;
+  pipeline: string | null | undefined;
 
   get id(): string {
     throw new Error('Dependency.id');
@@ -62,6 +61,7 @@ export class Dependency implements IDependency {
       this.bundleBehavior = bundleBehaviorMap.from(inner.bundleBehavior);
     }
     this.bundleBehavior = undefined;
+    // @ts-expect-error TS2322
     this.symbols = new MutableDependencySymbols(inner.symbols || []);
     this.specifier = inner.specifier;
     this.specifierType = specifierTypeMap.from(inner.specifierType);
@@ -70,7 +70,7 @@ export class Dependency implements IDependency {
     this.isOptional = inner.isOptional;
     this.isEntry = inner.isEntry;
     this.loc = inner.loc;
-    this.packageConditions = packageConditionsMap.fromArray(
+    this.packageConditions = packageConditionsMap.toArray(
       inner.packageConditions || [],
     );
     this.sourceAssetId = inner.sourceAssetId;

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

@@ -1,5 +1,4 @@
-// @flow
-
+// @ts-expect-error TS2724
 import type {Environment as NapiEnvironment} from '@atlaspack/rust';
 import type {
   Environment as IEnvironment,
@@ -12,6 +11,7 @@ import type {
   SourceLocation,
   VersionMap,
   EnvironmentFeature,
+  EnvMap,
 } from '@atlaspack/types';
 
 export class Environment implements IEnvironment {
@@ -19,7 +19,7 @@ export class Environment implements IEnvironment {
   includeNodeModules:
     | boolean
     | Array<PackageName>
-    | {[PackageName]: boolean, ...};
+    | Partial<Record<PackageName, boolean>>;
   context: EnvironmentContext;
   engines: Engines;
   outputFormat: OutputFormat;
@@ -27,20 +27,18 @@ export class Environment implements IEnvironment {
   isLibrary: boolean;
   shouldOptimize: boolean;
   shouldScopeHoist: boolean;
-  sourceMap: ?TargetSourceMapOptions;
-  loc: ?SourceLocation;
+  sourceMap: TargetSourceMapOptions | null | undefined;
+  loc: SourceLocation | null | undefined;
   unstableSingleFileOutput: boolean;
+  customEnv: EnvMap | null | undefined;
 
   constructor(inner: NapiEnvironment) {
     // TODO
     this.id = '';
     this.includeNodeModules = inner.includeNodeModules;
-    // $FlowFixMe
     this.context = inner.context;
     this.engines = inner.engines;
-    // $FlowFixMe
     this.outputFormat = inner.outputFormat;
-    // $FlowFixMe
     this.sourceType = inner.sourceType;
     this.isLibrary = inner.isLibrary;
     this.shouldOptimize = inner.shouldOptimize;
@@ -48,12 +46,14 @@ export class Environment implements IEnvironment {
     this.sourceMap = inner.sourceMap;
     this.loc = inner.loc;
     this.unstableSingleFileOutput = false;
+    this.customEnv = inner.customEnv;
   }
 
   isBrowser(): boolean {
     return (
       this.context === 'browser' ||
       this.isWorker() ||
+      this.isTesseract() ||
       this.isWorklet() ||
       this.context === 'electron-renderer'
     );
@@ -77,8 +77,12 @@ export class Environment implements IEnvironment {
     return this.context === 'worklet';
   }
 
+  isTesseract(): boolean {
+    return this.context === 'tesseract';
+  }
+
   isIsolated(): boolean {
-    return this.isWorker() || this.isWorklet();
+    return this.isWorker() || this.isTesseract() || this.isWorklet();
   }
 
   // TODO