@atlaspack/core 2.16.2-canary.27 → 2.16.2-canary.270

package/src/{applyRuntimes.js → applyRuntimes.ts}

@@ -1,5 +1,3 @@
-// @flow strict-local
-
 import type {ContentKey} from '@atlaspack/graph';
 import type {Dependency, NamedBundle as INamedBundle} from '@atlaspack/types';
 import type {SharedReference} from '@atlaspack/workers';
@@ -34,13 +32,14 @@ import {createDevDependency, runDevDepRequest} from './requests/DevDepRequest';
 import {toProjectPath, fromProjectPathRelative} from './projectPath';
 import {tracer, PluginTracer} from '@atlaspack/profiler';
 import {DefaultMap} from '@atlaspack/utils';
+import {fromEnvironmentId} from './EnvironmentManager';
 
-type RuntimeConnection = {|
-  bundle: InternalBundle,
-  assetGroup: AssetGroup,
-  dependency: ?Dependency,
-  isEntry: ?boolean,
-|};
+type RuntimeConnection = {
+  bundle: InternalBundle;
+  assetGroup: AssetGroup;
+  dependency: Dependency | null | undefined;
+  isEntry: boolean | null | undefined;
+};
 
 function nameRuntimeBundle(
   bundle: InternalBundle,
@@ -70,7 +69,7 @@ function nameRuntimeBundle(
  * Introduction of manifest bundles: https://github.com/parcel-bundler/parcel/pull/8837
  * Introduction of reverse topology: https://github.com/parcel-bundler/parcel/pull/8981
  */
-export default async function applyRuntimes<TResult: RequestResult>({
+export default async function applyRuntimes<TResult extends RequestResult>({
   bundleGraph,
   config,
   options,
@@ -80,17 +79,17 @@ export default async function applyRuntimes<TResult: RequestResult>({
   previousDevDeps,
   devDepRequests,
   configs,
-}: {|
-  bundleGraph: InternalBundleGraph,
-  config: AtlaspackConfig,
-  options: AtlaspackOptions,
-  optionsRef: SharedReference,
-  pluginOptions: PluginOptions,
-  api: RunAPI<TResult>,
-  previousDevDeps: Map<string, string>,
-  devDepRequests: Map<string, DevDepRequest | DevDepRequestRef>,
-  configs: Map<string, Config>,
-|}): Promise<Map<string, Asset>> {
+}: {
+  bundleGraph: InternalBundleGraph;
+  config: AtlaspackConfig;
+  options: AtlaspackOptions;
+  optionsRef: SharedReference;
+  pluginOptions: PluginOptions;
+  api: RunAPI<TResult>;
+  previousDevDeps: Map<string, string>;
+  devDepRequests: Map<string, DevDepRequest | DevDepRequestRef>;
+  configs: Map<string, Config>;
+}): Promise<Map<string, Asset>> {
   let runtimes = await config.getRuntimes();
 
   /**
@@ -106,9 +105,11 @@ export default async function applyRuntimes<TResult: RequestResult>({
    * order), so that children will always be available when parents try to reference
    * them.
    */
-  let bundles = [];
+  // @ts-expect-error TS2304
+  let bundles: Array<Bundle> = [];
   bundleGraph.traverseBundles({
-    exit(bundle) {
+    // @ts-expect-error TS2304
+    exit(bundle: Bundle) {
       bundles.push(bundle);
     },
   });
@@ -149,6 +150,7 @@ export default async function applyRuntimes<TResult: RequestResult>({
             filePath,
             isEntry,
             env,
+            runtimeAssetRequiringExecutionOnLoad,
             priority,
           } of runtimeAssets) {
             let sourceName = path.join(
@@ -158,8 +160,13 @@ export default async function applyRuntimes<TResult: RequestResult>({
 
             let assetGroup = {
               code,
+              runtimeAssetRequiringExecutionOnLoad,
               filePath: toProjectPath(options.projectRoot, sourceName),
-              env: mergeEnvironments(options.projectRoot, bundle.env, env),
+              env: mergeEnvironments(
+                options.projectRoot,
+                fromEnvironmentId(bundle.env),
+                env,
+              ),
               // Runtime assets should be considered source, as they should be
               // e.g. compiled to run in the target environment
               isSource: true,
@@ -200,6 +207,7 @@ export default async function applyRuntimes<TResult: RequestResult>({
               nameRuntimeBundle(connectionBundle, bundle);
             }
 
+            // @ts-expect-error TS2345
             connectionMap.get(connectionBundle).push({
               bundle: connectionBundle,
               assetGroup,
@@ -208,7 +216,7 @@ export default async function applyRuntimes<TResult: RequestResult>({
             });
           }
         }
-      } catch (e) {
+      } catch (e: any) {
         throw new ThrowableDiagnostic({
           diagnostic: errorToDiagnostic(e, {
             origin: runtime.name,
@@ -238,7 +246,8 @@ export default async function applyRuntimes<TResult: RequestResult>({
    */
   let connections: Array<RuntimeConnection> = [];
   bundleGraph.traverseBundles({
-    enter(bundle) {
+    // @ts-expect-error TS2304
+    enter(bundle: Bundle) {
       connections.push(...connectionMap.get(bundle));
     },
   });
@@ -389,7 +398,7 @@ export default async function applyRuntimes<TResult: RequestResult>({
   return changedAssets;
 }
 
-function reconcileNewRuntimes<TResult: RequestResult>(
+function reconcileNewRuntimes<TResult extends RequestResult>(
   api: RunAPI<TResult>,
   connections: Array<RuntimeConnection>,
   optionsRef: SharedReference,

package/src/{assetUtils.js → assetUtils.ts}

@@ -1,5 +1,3 @@
-// @flow strict-local
-
 import type {
   ASTGenerator,
   BundleBehavior,
@@ -16,7 +14,6 @@ import type {
   Asset,
   RequestInvalidation,
   Dependency,
-  Environment,
   AtlaspackOptions,
 } from './types';
 
@@ -32,7 +29,7 @@ import PluginOptions from './public/PluginOptions';
 import {blobToStream, hashFile} from '@atlaspack/utils';
 import {hashFromOption, toInternalSourceLocation} from './utils';
 import {
-  type ProjectPath,
+  ProjectPath,
   fromProjectPath,
   fromProjectPathRelative,
 } from './projectPath';
@@ -40,45 +37,57 @@ import {hashString, createAssetId as createAssetIdRust} from '@atlaspack/rust';
 import {BundleBehavior as BundleBehaviorMap} from './types';
 import {PluginTracer} from '@atlaspack/profiler';
 import {identifierRegistry} from './IdentifierRegistry';
+import type {EnvironmentRef} from './EnvironmentManager';
+import {toEnvironmentId} from './EnvironmentManager';
 
-export type AssetOptions = {|
-  id?: string,
-  committed?: boolean,
-  code: string | void | null,
-  filePath: ProjectPath,
-  query?: ?string,
-  type: string,
-  contentKey?: ?string,
-  mapKey?: ?string,
-  astKey?: ?string,
-  astGenerator?: ?ASTGenerator,
-  dependencies?: Map<string, Dependency>,
-  bundleBehavior?: ?BundleBehavior,
-  isBundleSplittable?: ?boolean,
-  isSource: boolean,
-  env: Environment,
-  meta?: Meta,
-  outputHash?: ?string,
-  pipeline?: ?string,
-  stats: Stats,
-  symbols?: ?Map<Symbol, {|local: Symbol, loc: ?SourceLocation, meta?: ?Meta|}>,
-  sideEffects?: boolean,
-  uniqueKey?: ?string,
-  plugin?: PackageName,
-  configPath?: ProjectPath,
-  configKeyPath?: string,
-|};
+export type AssetOptions = {
+  id?: string;
+  committed?: boolean;
+  code: string | undefined | null;
+  filePath: ProjectPath;
+  query?: string | null | undefined;
+  type: string;
+  contentKey?: string | null | undefined;
+  mapKey?: string | null | undefined;
+  astKey?: string | null | undefined;
+  astGenerator?: ASTGenerator | null | undefined;
+  dependencies?: Map<string, Dependency>;
+  bundleBehavior?: BundleBehavior | null | undefined;
+  isBundleSplittable?: boolean | null | undefined;
+  isSource: boolean;
+  env: EnvironmentRef;
+  meta?: Meta;
+  outputHash?: string | null | undefined;
+  pipeline?: string | null | undefined;
+  stats: Stats;
+  symbols?:
+    | Map<
+        symbol,
+        {
+          local: symbol;
+          loc: SourceLocation | null | undefined;
+          meta?: Meta | null | undefined;
+        }
+      >
+    | null
+    | undefined;
+  sideEffects?: boolean;
+  uniqueKey?: string | null | undefined;
+  plugin?: PackageName;
+  configPath?: ProjectPath;
+  configKeyPath?: string;
+};
 
 export function createAssetIdFromOptions(options: AssetOptions): string {
   const data = {
-    environmentId: options.env.id,
+    environmentId: toEnvironmentId(options.env),
     filePath: options.filePath,
     code: options.code,
     pipeline: options.pipeline,
     query: options.query,
     uniqueKey: options.uniqueKey,
     fileType: options.type,
-  };
+  } as const;
   const id = createAssetIdRust(data);
   identifierRegistry.addIdentifier('asset', id, data);
   return id;
@@ -112,7 +121,7 @@ export function createAsset(
     symbols:
       options.symbols &&
       new Map(
-        [...options.symbols].map(([k, v]) => [
+        [...options.symbols].map(([k, v]: [any, any]) => [
           k,
           {
             local: v.local,
@@ -149,7 +158,7 @@ async function _generateFromAST(asset: CommittedAsset | UncommittedAsset) {
   }
 
   let pluginName = nullthrows(asset.value.plugin);
-  let {plugin} = await loadPlugin<Transformer<mixed>>(
+  let {plugin} = await loadPlugin<Transformer<unknown>>(
     pluginName,
     fromProjectPath(
       asset.options.projectRoot,
@@ -200,6 +209,7 @@ export function getInvalidationId(invalidation: RequestInvalidation): string {
     case 'option':
       return 'option:' + invalidation.key;
     default:
+      // @ts-expect-error TS2339
       throw new Error('Unknown invalidation type: ' + invalidation.type);
   }
 }
@@ -240,9 +250,11 @@ export async function getInvalidationHash(
         break;
       case 'option':
         hashes +=
+          // @ts-expect-error TS7053
           invalidation.key + ':' + hashFromOption(options[invalidation.key]);
         break;
       default:
+        // @ts-expect-error TS2339
         throw new Error('Unknown invalidation type: ' + invalidation.type);
     }
   }

package/src/atlaspack-v3/AtlaspackV3.ts

@@ -0,0 +1,122 @@
+import {
+  atlaspackNapiCreate,
+  atlaspackNapiBuildAssetGraph,
+  atlaspackNapiRespondToFsEvents,
+  AtlaspackNapi,
+  Lmdb,
+  AtlaspackNapiOptions,
+} 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';
+
+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();
+    }
+  }
+
+  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;
+  }
+
+  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;
+  }
+}

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

@@ -1,8 +1,8 @@
-// @flow
 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';
 
@@ -11,9 +11,9 @@ const ATLASPACK_NAPI_WORKERS =
   process.env.ATLASPACK_NAPI_WORKERS &&
   parseInt(process.env.ATLASPACK_NAPI_WORKERS, 10);
 
-export type NapiWorkerPoolOptions = {|
-  workerCount?: number,
-|};
+export type NapiWorkerPoolOptions = {
+  workerCount?: number;
+};
 
 export class NapiWorkerPool implements INapiWorkerPool {
   #workers: Worker[];
@@ -21,6 +21,7 @@ export class NapiWorkerPool implements INapiWorkerPool {
   #workerCount: number;
 
   constructor({workerCount}: NapiWorkerPoolOptions = {workerCount: undefined}) {
+    // @ts-expect-error TS2322
     this.#workerCount =
       workerCount ?? ATLASPACK_NAPI_WORKERS ?? getAvailableThreads();
     if (!this.#workerCount) {
@@ -33,7 +34,11 @@ export class NapiWorkerPool implements INapiWorkerPool {
     for (let i = 0; i < this.#workerCount; i++) {
       let worker = new Worker(WORKER_PATH);
       this.#workers.push(worker);
-      this.#napiWorkers.push(new Promise((res) => worker.once('message', res)));
+      this.#napiWorkers.push(
+        new Promise((res: (result: Promise<never>) => void) =>
+          worker.once('message', res),
+        ),
+      );
     }
   }
 

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,5 @@
-// @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';

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