@atlaspack/core 2.16.2-canary.13 → 2.16.2-canary.131

package/src/SymbolPropagation.js

@@ -3,6 +3,7 @@
 import type {ContentKey, NodeId} from '@atlaspack/graph';
 import type {Meta, Symbol} from '@atlaspack/types';
 import type {Diagnostic} from '@atlaspack/diagnostic';
+import {getFeatureFlag} from '@atlaspack/feature-flags';
 import type {
   AssetNode,
   DependencyNode,
@@ -17,7 +18,7 @@ import {setEqual} from '@atlaspack/utils';
 import logger from '@atlaspack/logger';
 import {md, convertSourceLocationToHighlight} from '@atlaspack/diagnostic';
 import {instrument} from '@atlaspack/logger';
-import {BundleBehavior, Priority} from './types';
+import {BundleBehavior, Priority, SpecifierType} from './types';
 import {fromProjectPathRelative, fromProjectPath} from './projectPath';
 
 export function propagateSymbols({
@@ -62,6 +63,17 @@ export function propagateSymbols({
       changedAssets,
       assetGroupsWithRemovedParents,
       (assetNode, incomingDeps, outgoingDeps) => {
+        if (getFeatureFlag('emptyFileStarRexportFix')) {
+          if (
+            assetNode.value.meta.emptyFileStarReexport &&
+            incomingDeps.every(
+              (d) => d.value.specifierType === SpecifierType.esm,
+            )
+          ) {
+            assetNode.value.symbols?.delete('*');
+          }
+        }
+
         // exportSymbol -> identifier
         let assetSymbols: ?$ReadOnlyMap<
           Symbol,

package/src/UncommittedAsset.js

@@ -30,7 +30,13 @@ import {ATLASPACK_VERSION} from './constants';
 import {createAsset, createAssetIdFromOptions} from './assetUtils';
 import {BundleBehaviorNames} from './types';
 import {invalidateOnFileCreateToInternal, createInvalidations} from './utils';
-import {type ProjectPath, fromProjectPath} from './projectPath';
+import {
+  type ProjectPath,
+  fromProjectPath,
+  fromProjectPathRelative,
+} from './projectPath';
+import {getFeatureFlag} from '@atlaspack/feature-flags';
+import {fromEnvironmentId} from './EnvironmentManager';
 
 type UncommittedAssetOptions = {|
   value: Asset,
@@ -153,7 +159,9 @@ export default class UncommittedAsset {
       size = content.length;
     }
 
+    // Maybe we should just store this in a file instead of LMDB
     await this.options.cache.setBlob(contentKey, content);
+
     return {size, hash};
   }
 
@@ -214,6 +222,9 @@ export default class UncommittedAsset {
     this.clearAST();
   }
 
+  /**
+   * @deprecated This has been broken on any cache other than FSCache for a long time.
+   */
   setStream(stream: Readable) {
     this.content = stream;
     this.clearAST();
@@ -296,6 +307,11 @@ export default class UncommittedAsset {
   }
 
   getCacheKey(key: string): string {
+    if (getFeatureFlag('cachePerformanceImprovements')) {
+      const filePath = fromProjectPathRelative(this.value.filePath);
+      return `Asset/${ATLASPACK_VERSION}/${filePath}/${this.value.id}/${key}`;
+    }
+
     return hashString(ATLASPACK_VERSION + key + this.value.id);
   }
 
@@ -306,7 +322,11 @@ export default class UncommittedAsset {
       ...rest,
       // $FlowFixMe "convert" the $ReadOnlyMaps to the interal mutable one
       symbols,
-      env: mergeEnvironments(this.options.projectRoot, this.value.env, env),
+      env: mergeEnvironments(
+        this.options.projectRoot,
+        fromEnvironmentId(this.value.env),
+        env,
+      ),
       sourceAssetId: this.value.id,
       sourcePath: fromProjectPath(
         this.options.projectRoot,
@@ -371,7 +391,7 @@ export default class UncommittedAsset {
         isSource: this.value.isSource,
         env: mergeEnvironments(
           this.options.projectRoot,
-          this.value.env,
+          fromEnvironmentId(this.value.env),
           result.env,
         ),
         dependencies:

package/src/applyRuntimes.js

@@ -34,6 +34,7 @@ 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,
@@ -159,7 +160,11 @@ export default async function applyRuntimes<TResult: RequestResult>({
             let assetGroup = {
               code,
               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,

package/src/assetUtils.js

@@ -16,7 +16,6 @@ import type {
   Asset,
   RequestInvalidation,
   Dependency,
-  Environment,
   AtlaspackOptions,
 } from './types';
 
@@ -40,6 +39,8 @@ 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,
@@ -56,7 +57,7 @@ export type AssetOptions = {|
   bundleBehavior?: ?BundleBehavior,
   isBundleSplittable?: ?boolean,
   isSource: boolean,
-  env: Environment,
+  env: EnvironmentRef,
   meta?: Meta,
   outputHash?: ?string,
   pipeline?: ?string,
@@ -71,7 +72,7 @@ export type AssetOptions = {|
 
 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,

package/src/atlaspack-v3/AtlaspackV3.js

@@ -28,9 +28,17 @@ export type AtlaspackV3Options = {|
 
 export class AtlaspackV3 {
   _atlaspack_napi: AtlaspackNapi;
+  _napiWorkerPool: INapiWorkerPool;
+  _isDefaultNapiWorkerPool: boolean;
 
-  constructor(atlaspack_napi: AtlaspackNapi) {
+  constructor(
+    atlaspack_napi: AtlaspackNapi,
+    napiWorkerPool: INapiWorkerPool,
+    isDefaultNapiWorkerPool: boolean,
+  ) {
     this._atlaspack_napi = atlaspack_napi;
+    this._napiWorkerPool = napiWorkerPool;
+    this._isDefaultNapiWorkerPool = isDefaultNapiWorkerPool;
   }
 
   static async create({
@@ -38,7 +46,7 @@ export class AtlaspackV3 {
     packageManager,
     threads,
     lmdb,
-    napiWorkerPool = new NapiWorkerPool(),
+    napiWorkerPool,
     ...options
   }: AtlaspackV3Options): Promise<AtlaspackV3> {
     options.logLevel = options.logLevel || 'error';
@@ -47,6 +55,12 @@ export class AtlaspackV3 {
     options.defaultTargetOptions.engines =
       options.defaultTargetOptions.engines || {};
 
+    let isDefaultNapiWorkerPool = false;
+    if (!napiWorkerPool) {
+      napiWorkerPool = new NapiWorkerPool();
+      isDefaultNapiWorkerPool = true;
+    }
+
     const [internal, error] = await atlaspackNapiCreate(
       {
         fs,
@@ -64,7 +78,14 @@ export class AtlaspackV3 {
       });
     }
 
-    return new AtlaspackV3(internal);
+    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> {

package/src/atlaspack-v3/worker/compat/plugin-config.js

@@ -100,11 +100,15 @@ export class PluginConfig implements IPluginConfig {
     // eslint-disable-next-line no-unused-vars
     filePaths: Array<FilePath>,
     // eslint-disable-next-line no-unused-vars
-    options?: {|
-      packageKey?: string,
-      parse?: boolean,
-      exclude?: boolean,
-    |},
+    options?:
+      | {|
+          packageKey?: string,
+          parse?: boolean,
+          exclude?: boolean,
+        |}
+      | {|
+          readTracking?: boolean,
+        |},
   ): Promise<?ConfigResultWithFilePath<T>> {
     return this.#inner.getConfigFrom(searchPath, filePaths, options);
   }

package/src/atlaspack-v3/worker/index.js

@@ -1,5 +1,6 @@
 if (
-  process.env.ATLASPACK_BUILD_ENV !== 'production' ||
+  process.env.ATLASPACK_SOURCES === 'true' ||
+  process.env.ATLASPACK_BUILD_ENV === 'test' ||
   process.env.ATLASPACK_SELF_BUILD
 ) {
   require('@atlaspack/babel-register');

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

@@ -141,6 +141,13 @@ export class AtlaspackWorker {
         };
       }
 
+      if (result.isExcluded) {
+        return {
+          invalidations: [],
+          resolution: {type: 'excluded'},
+        };
+      }
+
       return {
         invalidations: [],
         resolution: {

package/src/index.js

@@ -1,4 +1,5 @@
 // @flow
+import * as EnvironmentManager from './EnvironmentManager';
 
 export {
   default,
@@ -8,6 +9,9 @@ export {
   createWorkerFarm,
   INTERNAL_RESOLVE,
   INTERNAL_TRANSFORM,
+  WORKER_PATH,
 } from './Atlaspack';
-
+export {ATLASPACK_VERSION} from './constants';
+export {default as resolveOptions} from './resolveOptions';
 export * from './atlaspack-v3';
+export {EnvironmentManager};

package/src/public/Asset.js

@@ -36,6 +36,7 @@ import {
   BundleBehaviorNames,
 } from '../types';
 import {toInternalSourceLocation} from '../utils';
+import {fromEnvironmentId} from '../EnvironmentManager';
 
 const inspect = Symbol.for('nodejs.util.inspect.custom');
 
@@ -80,7 +81,7 @@ export function assetFromValue(
 
 class BaseAsset {
   #asset: CommittedAsset | UncommittedAsset;
-  #query /*: ?URLSearchParams */;
+  #query: ?URLSearchParams;
 
   constructor(asset: CommittedAsset | UncommittedAsset) {
     this.#asset = asset;
@@ -101,7 +102,10 @@ class BaseAsset {
   }
 
   get env(): IEnvironment {
-    return new Environment(this.#asset.value.env, this.#asset.options);
+    return new Environment(
+      fromEnvironmentId(this.#asset.value.env),
+      this.#asset.options,
+    );
   }
 
   get fs(): FileSystem {
@@ -191,8 +195,8 @@ class BaseAsset {
 }
 
 export class Asset extends BaseAsset implements IAsset {
-  #asset /*: CommittedAsset | UncommittedAsset */;
-  #env /*: ?Environment */;
+  #asset: CommittedAsset | UncommittedAsset;
+  #env: ?Environment;
 
   constructor(asset: CommittedAsset | UncommittedAsset): Asset {
     let assetValueToAsset = asset.value.committed
@@ -210,7 +214,10 @@ export class Asset extends BaseAsset implements IAsset {
   }
 
   get env(): IEnvironment {
-    this.#env ??= new Environment(this.#asset.value.env, this.#asset.options);
+    this.#env ??= new Environment(
+      fromEnvironmentId(this.#asset.value.env),
+      this.#asset.options,
+    );
     return this.#env;
   }
 
@@ -220,7 +227,7 @@ export class Asset extends BaseAsset implements IAsset {
 }
 
 export class MutableAsset extends BaseAsset implements IMutableAsset {
-  #asset /*: UncommittedAsset */;
+  #asset: UncommittedAsset;
 
   constructor(asset: UncommittedAsset): MutableAsset {
     let existing = assetValueToMutableAsset.get(asset.value);

package/src/public/Bundle.js

@@ -34,6 +34,7 @@ import {
 import Target from './Target';
 import {BundleBehaviorNames} from '../types';
 import {fromProjectPath} from '../projectPath';
+import {fromEnvironmentId} from '../EnvironmentManager';
 
 const inspect = Symbol.for('nodejs.util.inspect.custom');
 
@@ -67,9 +68,9 @@ export function bundleToInternalBundleGraph(bundle: IBundle): BundleGraph {
 let _private = {};
 
 export class Bundle implements IBundle {
-  #bundle /*: InternalBundle */;
-  #bundleGraph /*: BundleGraph */;
-  #options /*: AtlaspackOptions */;
+  #bundle: InternalBundle;
+  #bundleGraph: BundleGraph;
+  #options: AtlaspackOptions;
 
   // $FlowFixMe
   [inspect]() {
@@ -123,7 +124,7 @@ export class Bundle implements IBundle {
   }
 
   get env(): IEnvironment {
-    return new Environment(this.#bundle.env, this.#options);
+    return new Environment(fromEnvironmentId(this.#bundle.env), this.#options);
   }
 
   get needsStableName(): ?boolean {
@@ -213,9 +214,9 @@ export class Bundle implements IBundle {
 }
 
 export class NamedBundle extends Bundle implements INamedBundle {
-  #bundle /*: InternalBundle */;
-  #bundleGraph /*: BundleGraph */;
-  #options /*: AtlaspackOptions */;
+  #bundle: InternalBundle;
+  #bundleGraph: BundleGraph;
+  #options: AtlaspackOptions;
 
   constructor(
     sentinel: mixed,
@@ -267,10 +268,10 @@ export class NamedBundle extends Bundle implements INamedBundle {
 }
 
 export class PackagedBundle extends NamedBundle implements IPackagedBundle {
-  #bundle /*: InternalBundle */;
-  #bundleGraph /*: BundleGraph */;
-  #options /*: AtlaspackOptions */;
-  #bundleInfo /*: ?PackagedBundleInfo */;
+  #bundle: InternalBundle;
+  #bundleGraph: BundleGraph;
+  #options: AtlaspackOptions;
+  #bundleInfo: ?PackagedBundleInfo;
 
   constructor(
     sentinel: mixed,

package/src/public/BundleGraph.js

@@ -489,10 +489,18 @@ export default class BundleGraph<TBundle: IBundle>
       for (let bundle of bundles) {
         const conditions = bundleConditions.get(bundle.id) ?? new Map();
 
+        const currentCondition = conditions.get(cond.key);
+
         conditions.set(cond.key, {
           bundle,
-          ifTrueBundles,
-          ifFalseBundles,
+          ifTrueBundles: [
+            ...(currentCondition?.ifTrueBundles ?? []),
+            ...ifTrueBundles,
+          ],
+          ifFalseBundles: [
+            ...(currentCondition?.ifFalseBundles ?? []),
+            ...ifFalseBundles,
+          ],
         });
 
         bundleConditions.set(bundle.id, conditions);

package/src/public/BundleGroup.js

@@ -28,8 +28,8 @@ export function bundleGroupToInternalBundleGroup(
 const inspect = Symbol.for('nodejs.util.inspect.custom');
 
 export default class BundleGroup implements IBundleGroup {
-  #bundleGroup /*: InternalBundleGroup */;
-  #options /*: AtlaspackOptions */;
+  #bundleGroup: InternalBundleGroup;
+  #options: AtlaspackOptions;
 
   constructor(
     bundleGroup: InternalBundleGroup,

package/src/public/Config.js

@@ -20,17 +20,94 @@ import {
 } from '@atlaspack/utils';
 import Environment from './Environment';
 import {fromProjectPath, toProjectPath} from '../projectPath';
+import {fromEnvironmentId} from '../EnvironmentManager';
 
 const internalConfigToConfig: DefaultWeakMap<
   AtlaspackOptions,
   WeakMap<Config, PublicConfig>,
 > = new DefaultWeakMap(() => new WeakMap());
 
+/**
+ * Implements read tracking over an object.
+ *
+ * Calling this function with a non-trivial object like a class instance will fail to work.
+ *
+ * We track reads to fields that resolve to:
+ *
+ * - primitive values
+ * - arrays
+ *
+ * That is, reading a nested field `a.b.c` will make a single call to `onRead` with the path
+ * `['a', 'b', 'c']`.
+ *
+ * In case the value is null or an array, we will track the read as well.
+ *
+ * Iterating over `Object.keys(obj.field)` will register a read for the `['field']` path.
+ * Other reads work normally.
+ *
+ * @example
+ *
+ *     const usedPaths = new Set();
+ *     const onRead = (path) => {
+ *        usedPaths.add(path);
+ *     };
+ *
+ *     const config = makeConfigProxy(onRead, {a: {b: {c: 'd'}}})
+ *     console.log(config.a.b.c);
+ *     console.log(Array.from(usedPaths));
+ *     // We get a single read for the path
+ *     // ['a', 'b', 'c']
+ *
+ */
+export function makeConfigProxy<T>(
+  onRead: (path: string[]) => void,
+  config: T,
+): T {
+  const reportedPaths = new Set();
+  const reportPath = (path) => {
+    if (reportedPaths.has(path)) {
+      return;
+    }
+    reportedPaths.add(path);
+    onRead(path);
+  };
+
+  const makeProxy = (target, path) => {
+    return new Proxy(target, {
+      ownKeys(target) {
+        reportPath(path);
+
+        // $FlowFixMe
+        return Object.getOwnPropertyNames(target);
+      },
+      get(target, prop) {
+        // $FlowFixMe
+        const value = target[prop];
+
+        if (
+          typeof value === 'object' &&
+          value != null &&
+          !Array.isArray(value)
+        ) {
+          return makeProxy(value, [...path, prop]);
+        }
+
+        reportPath([...path, prop]);
+
+        return value;
+      },
+    });
+  };
+
+  // $FlowFixMe
+  return makeProxy(config, []);
+}
+
 export default class PublicConfig implements IConfig {
-  #config /*: Config */;
-  #pkg /*: ?PackageJSON */;
-  #pkgFilePath /*: ?FilePath */;
-  #options /*: AtlaspackOptions */;
+  #config: Config;
+  #pkg: ?PackageJSON;
+  #pkgFilePath: ?FilePath;
+  #options: AtlaspackOptions;
 
   constructor(config: Config, options: AtlaspackOptions): PublicConfig {
     let existing = internalConfigToConfig.get(options).get(config);
@@ -45,7 +122,7 @@ export default class PublicConfig implements IConfig {
   }
 
   get env(): Environment {
-    return new Environment(this.#config.env, this.#options);
+    return new Environment(fromEnvironmentId(this.#config.env), this.#options);
   }
 
   get searchPath(): FilePath {
@@ -75,7 +152,7 @@ export default class PublicConfig implements IConfig {
     );
   }
 
-  invalidateOnConfigKeyChange(filePath: FilePath, configKey: string) {
+  invalidateOnConfigKeyChange(filePath: FilePath, configKey: string[]) {
     this.#config.invalidateOnConfigKeyChange.push({
       filePath: toProjectPath(this.#options.projectRoot, filePath),
       configKey,
@@ -132,11 +209,22 @@ export default class PublicConfig implements IConfig {
   async getConfigFrom<T>(
     searchPath: FilePath,
     fileNames: Array<string>,
-    options: ?{|
-      packageKey?: string,
-      parse?: boolean,
-      exclude?: boolean,
-    |},
+    options:
+      | ?{|
+          /**
+           * @deprecated Use `configKey` instead.
+           */
+          packageKey?: string,
+          parse?: boolean,
+          exclude?: boolean,
+        |}
+      | ?{|
+          /**
+           * If specified, this function will return a proxy object that will track reads to
+           * config fields and only register invalidations for when those keys change.
+           */
+          readTracking?: boolean,
+        |},
   ): Promise<?ConfigResultWithFilePath<T>> {
     let packageKey = options?.packageKey;
     if (packageKey != null) {
@@ -146,7 +234,7 @@ export default class PublicConfig implements IConfig {
 
       if (pkg && pkg.contents[packageKey]) {
         // Invalidate only when the package key changes
-        this.invalidateOnConfigKeyChange(pkg.filePath, packageKey);
+        this.invalidateOnConfigKeyChange(pkg.filePath, [packageKey]);
 
         return {
           contents: pkg.contents[packageKey],
@@ -155,6 +243,26 @@ export default class PublicConfig implements IConfig {
       }
     }
 
+    const readTracking = options?.readTracking;
+    if (readTracking === true) {
+      for (let fileName of fileNames) {
+        const config = await this.getConfigFrom(searchPath, [fileName], {
+          exclude: true,
+        });
+
+        if (config != null) {
+          return Promise.resolve({
+            contents: makeConfigProxy((keyPath) => {
+              this.invalidateOnConfigKeyChange(config.filePath, keyPath);
+            }, config.contents),
+            filePath: config.filePath,
+          });
+        }
+      }
+
+      // fall through so that file above invalidations are registered
+    }
+
     if (fileNames.length === 0) {
       return null;
     }
@@ -234,11 +342,15 @@ export default class PublicConfig implements IConfig {
 
   getConfig<T>(
     filePaths: Array<FilePath>,
-    options: ?{|
-      packageKey?: string,
-      parse?: boolean,
-      exclude?: boolean,
-    |},
+    options:
+      | ?{|
+          packageKey?: string,
+          parse?: boolean,
+          exclude?: boolean,
+        |}
+      | {|
+          readTracking?: boolean,
+        |},
   ): Promise<?ConfigResultWithFilePath<T>> {
     return this.getConfigFrom(this.searchPath, filePaths, options);
   }
@@ -248,7 +360,9 @@ export default class PublicConfig implements IConfig {
       return this.#pkg;
     }
 
-    let pkgConfig = await this.getConfig<PackageJSON>(['package.json']);
+    let pkgConfig = await this.getConfig<PackageJSON>(['package.json'], {
+      readTracking: true,
+    });
     if (!pkgConfig) {
       return null;
     }

package/src/public/Dependency.js

@@ -27,6 +27,7 @@ import {
 } from '../types';
 import {fromProjectPath} from '../projectPath';
 import {fromInternalSourceLocation} from '../utils';
+import {fromEnvironmentId} from '../EnvironmentManager';
 
 const SpecifierTypeNames = Object.keys(SpecifierTypeMap);
 const PriorityNames = Object.keys(Priority);
@@ -58,8 +59,8 @@ export function getPublicDependency(
 }
 
 export default class Dependency implements IDependency {
-  #dep /*: InternalDependency */;
-  #options /*: AtlaspackOptions */;
+  #dep: InternalDependency;
+  #options: AtlaspackOptions;
 
   constructor(dep: InternalDependency, options: AtlaspackOptions): Dependency {
     this.#dep = dep;
@@ -112,7 +113,7 @@ export default class Dependency implements IDependency {
   }
 
   get env(): IEnvironment {
-    return new Environment(this.#dep.env, this.#options);
+    return new Environment(fromEnvironmentId(this.#dep.env), this.#options);
   }
 
   get packageConditions(): ?Array<string> {

package/src/public/Environment.js

@@ -156,8 +156,8 @@ export function environmentToInternalEnvironment(
 }
 
 export default class Environment implements IEnvironment {
-  #environment /*: InternalEnvironment */;
-  #options /*: AtlaspackOptions */;
+  #environment: InternalEnvironment;
+  #options: AtlaspackOptions;
 
   constructor(
     env: InternalEnvironment,