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

package/src/public/{BundleGraph.js → BundleGraph.ts}

@@ -1,5 +1,3 @@
-// @flow strict-local
-
 import type {
   Asset as IAsset,
   Bundle as IBundle,
@@ -10,9 +8,9 @@ import type {
   ExportSymbolResolution,
   FilePath,
   GraphVisitor,
-  Symbol,
   NamedBundle,
   SymbolResolution,
+  Symbol,
   Target,
 } from '@atlaspack/types';
 import type {Bundle as InternalBundle, AtlaspackOptions} from '../types';
@@ -36,7 +34,7 @@ import BundleGroup, {bundleGroupToInternalBundleGroup} from './BundleGroup';
 // to the internal bundle.
 const _bundleGraphToInternalBundleGraph: WeakMap<
   IBundleGraph<IBundle>,
-  InternalBundleGraph,
+  InternalBundleGraph
 > = new WeakMap();
 export function bundleGraphToInternalBundleGraph(
   bundleGraph: IBundleGraph<IBundle>,
@@ -44,13 +42,13 @@ export function bundleGraphToInternalBundleGraph(
   return nullthrows(_bundleGraphToInternalBundleGraph.get(bundleGraph));
 }
 
-type BundleFactory<TBundle: IBundle> = (
-  InternalBundle,
-  InternalBundleGraph,
-  AtlaspackOptions,
+type BundleFactory<TBundle extends IBundle> = (
+  arg1: InternalBundle,
+  arg2: InternalBundleGraph,
+  arg3: AtlaspackOptions,
 ) => TBundle;
 
-export default class BundleGraph<TBundle: IBundle>
+export default class BundleGraph<TBundle extends IBundle>
   implements IBundleGraph<TBundle>
 {
   #graph: InternalBundleGraph;
@@ -65,7 +63,6 @@ export default class BundleGraph<TBundle: IBundle>
     this.#graph = graph;
     this.#options = options;
     this.#createBundle = createBundle;
-    // $FlowFixMe
     _bundleGraphToInternalBundleGraph.set(this, graph);
   }
 
@@ -81,7 +78,10 @@ export default class BundleGraph<TBundle: IBundle>
     return this.#graph.isDependencySkipped(dependencyToInternalDependency(dep));
   }
 
-  getResolvedAsset(dep: IDependency, bundle: ?IBundle): ?IAsset {
+  getResolvedAsset(
+    dep: IDependency,
+    bundle?: IBundle | null,
+  ): IAsset | null | undefined {
     let resolution = this.#graph.getResolvedAsset(
       dependencyToInternalDependency(dep),
       bundle && bundleToInternalBundle(bundle),
@@ -97,7 +97,7 @@ export default class BundleGraph<TBundle: IBundle>
       .map((dep) => getPublicDependency(dep, this.#options));
   }
 
-  getAssetWithDependency(dep: IDependency): ?IAsset {
+  getAssetWithDependency(dep: IDependency): IAsset | null | undefined {
     let asset = this.#graph.getAssetWithDependency(
       dependencyToInternalDependency(dep),
     );
@@ -114,7 +114,10 @@ export default class BundleGraph<TBundle: IBundle>
 
   getReferencedBundles(
     bundle: IBundle,
-    opts?: {|recursive?: boolean, includeInline?: boolean|},
+    opts?: {
+      recursive?: boolean;
+      includeInline?: boolean;
+    },
   ): Array<TBundle> {
     return this.#graph
       .getReferencedBundles(bundleToInternalBundle(bundle), opts)
@@ -129,11 +132,18 @@ export default class BundleGraph<TBundle: IBundle>
 
   resolveAsyncDependency(
     dependency: IDependency,
-    bundle: ?IBundle,
-  ): ?(
-    | {|type: 'bundle_group', value: IBundleGroup|}
-    | {|type: 'asset', value: IAsset|}
-  ) {
+    bundle?: IBundle | null,
+  ):
+    | {
+        type: 'bundle_group';
+        value: IBundleGroup;
+      }
+    | {
+        type: 'asset';
+        value: IAsset;
+      }
+    | null
+    | undefined {
     let resolved = this.#graph.resolveAsyncDependency(
       dependencyToInternalDependency(dependency),
       bundle && bundleToInternalBundle(bundle),
@@ -154,7 +164,10 @@ export default class BundleGraph<TBundle: IBundle>
     };
   }
 
-  getReferencedBundle(dependency: IDependency, bundle: IBundle): ?TBundle {
+  getReferencedBundle(
+    dependency: IDependency,
+    bundle: IBundle,
+  ): TBundle | null | undefined {
     let result = this.#graph.getReferencedBundle(
       dependencyToInternalDependency(dependency),
       bundleToInternalBundle(bundle),
@@ -194,7 +207,9 @@ export default class BundleGraph<TBundle: IBundle>
 
   getBundlesInBundleGroup(
     bundleGroup: IBundleGroup,
-    opts?: {|includeInline: boolean|},
+    opts?: {
+      includeInline: boolean;
+    },
   ): Array<TBundle> {
     return this.#graph
       .getBundlesInBundleGroup(
@@ -204,7 +219,7 @@ export default class BundleGraph<TBundle: IBundle>
       .map((bundle) => this.#createBundle(bundle, this.#graph, this.#options));
   }
 
-  getBundles(opts?: {|includeInline: boolean|}): Array<TBundle> {
+  getBundles(opts?: {includeInline: boolean}): Array<TBundle> {
     return this.#graph
       .getBundles(opts)
       .map((bundle) => this.#createBundle(bundle, this.#graph, this.#options));
@@ -231,7 +246,7 @@ export default class BundleGraph<TBundle: IBundle>
   getSymbolResolution(
     asset: IAsset,
     symbol: Symbol,
-    boundary: ?IBundle,
+    boundary?: IBundle | null,
   ): SymbolResolution {
     let res = this.#graph.getSymbolResolution(
       assetToAssetValue(asset),
@@ -248,7 +263,7 @@ export default class BundleGraph<TBundle: IBundle>
 
   getExportedSymbols(
     asset: IAsset,
-    boundary: ?IBundle,
+    boundary?: IBundle | null,
   ): Array<ExportSymbolResolution> {
     let res = this.#graph.getExportedSymbols(
       assetToAssetValue(asset),
@@ -265,10 +280,13 @@ export default class BundleGraph<TBundle: IBundle>
 
   traverse<TContext>(
     visit: GraphVisitor<BundleGraphTraversable, TContext>,
-    start?: ?IAsset,
-    opts?: ?{|skipUnusedDependencies?: boolean|},
-  ): ?TContext {
+    start?: IAsset | null,
+    opts?: {
+      skipUnusedDependencies?: boolean;
+    } | null,
+  ): TContext | null | undefined {
     return this.#graph.traverse(
+      // @ts-expect-error TS2345
       mapVisitor((node, actions) => {
         // Skipping unused dependencies here is faster than doing an isDependencySkipped check inside the visitor
         // because the node needs to be re-looked up by id from the hashmap.
@@ -293,8 +311,8 @@ export default class BundleGraph<TBundle: IBundle>
 
   traverseBundles<TContext>(
     visit: GraphVisitor<TBundle, TContext>,
-    startBundle: ?IBundle,
-  ): ?TContext {
+    startBundle?: IBundle | null,
+  ): TContext | null | undefined {
     return this.#graph.traverseBundles(
       mapVisitor(
         (bundle) => this.#createBundle(bundle, this.#graph, this.#options),
@@ -316,7 +334,9 @@ export default class BundleGraph<TBundle: IBundle>
       .map((bundle) => this.#createBundle(bundle, this.#graph, this.#options));
   }
 
-  getUsedSymbols(v: IAsset | IDependency): ?$ReadOnlySet<Symbol> {
+  getUsedSymbols(
+    v: IAsset | IDependency,
+  ): ReadonlySet<Symbol> | null | undefined {
     if (v instanceof Asset) {
       return this.#graph.getUsedSymbolsAsset(assetToAssetValue(v));
     } else {
@@ -340,16 +360,16 @@ export default class BundleGraph<TBundle: IBundle>
   getConditionsForDependencies(
     deps: Array<IDependency>,
     bundle: NamedBundle,
-  ): Set<{|
-    publicId: string,
-    key: string,
-    ifTrueDependency: IDependency,
-    ifFalseDependency: IDependency,
-    ifTrueBundles: Array<TBundle>,
-    ifFalseBundles: Array<TBundle>,
-    ifTrueAssetId: string,
-    ifFalseAssetId: string,
-  |}> {
+  ): Set<{
+    publicId: string;
+    key: string;
+    ifTrueDependency: IDependency;
+    ifFalseDependency: IDependency;
+    ifTrueBundles: Array<TBundle>;
+    ifFalseBundles: Array<TBundle>;
+    ifTrueAssetId: string;
+    ifFalseAssetId: string;
+  }> {
     const conditions = new Set();
     const depIds = deps.map((dep) => dep.id);
     for (const condition of this.#graph._conditions.values()) {
@@ -437,6 +457,7 @@ export default class BundleGraph<TBundle: IBundle>
       }
     }
 
+    // @ts-expect-error TS2322
     return conditions;
   }
 
@@ -447,12 +468,12 @@ export default class BundleGraph<TBundle: IBundle>
     string,
     Map<
       string,
-      {|
-        bundle: TBundle,
-        ifTrueBundles: Array<TBundle>,
-        ifFalseBundles: Array<TBundle>,
-      |},
-    >,
+      {
+        bundle: TBundle;
+        ifTrueBundles: Array<TBundle>;
+        ifFalseBundles: Array<TBundle>;
+      }
+    >
   > {
     let bundleConditions = new Map();
 
@@ -462,15 +483,15 @@ export default class BundleGraph<TBundle: IBundle>
         nullthrows(this.getAssetById(asset.id)),
       );
       let bundles = new Set<TBundle>();
-      let ifTrueBundles = [];
-      let ifFalseBundles = [];
+      let ifTrueBundles: Array<TBundle> = [];
+      let ifFalseBundles: Array<TBundle> = [];
       for (const asset of assets) {
         const bundlesWithAsset = this.getBundlesWithAsset(asset);
         for (const bundle of bundlesWithAsset) {
           bundles.add(bundle);
         }
         const assetDeps = this.getDependencies(asset);
-        const depToBundles = (dep) => {
+        const depToBundles = (dep: Dependency) => {
           const publicDep = nullthrows(
             assetDeps.find((assetDep) => dep.id === assetDep.id),
           );
@@ -482,17 +503,27 @@ export default class BundleGraph<TBundle: IBundle>
           invariant(resolved.type === 'bundle_group');
           return this.getBundlesInBundleGroup(resolved.value);
         };
+        // @ts-expect-error TS2345
         ifTrueBundles.push(...depToBundles(cond.ifTrueDependency));
+        // @ts-expect-error TS2345
         ifFalseBundles.push(...depToBundles(cond.ifFalseDependency));
       }
 
       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 → BundleGroup.ts}

@@ -1,4 +1,3 @@
-// @flow
 import type {
   BundleGroup as IBundleGroup,
   Target as ITarget,
@@ -13,11 +12,11 @@ import Target from './Target';
 
 const internalBundleGroupToBundleGroup: WeakMap<
   InternalBundleGroup,
-  BundleGroup,
+  BundleGroup
 > = new WeakMap();
 const _bundleGroupToInternalBundleGroup: WeakMap<
   IBundleGroup,
-  InternalBundleGroup,
+  InternalBundleGroup
 > = new WeakMap();
 export function bundleGroupToInternalBundleGroup(
   target: IBundleGroup,
@@ -28,13 +27,12 @@ export function bundleGroupToInternalBundleGroup(
 const inspect = Symbol.for('nodejs.util.inspect.custom');
 
 export default class BundleGroup implements IBundleGroup {
-  #bundleGroup /*: InternalBundleGroup */;
-  #options /*: AtlaspackOptions */;
+  // @ts-expect-error TS2564
+  #bundleGroup: InternalBundleGroup;
+  // @ts-expect-error TS2564
+  #options: AtlaspackOptions;
 
-  constructor(
-    bundleGroup: InternalBundleGroup,
-    options: AtlaspackOptions,
-  ): BundleGroup {
+  constructor(bundleGroup: InternalBundleGroup, options: AtlaspackOptions) {
     let existing = internalBundleGroupToBundleGroup.get(bundleGroup);
     if (existing != null) {
       return existing;
@@ -55,7 +53,6 @@ export default class BundleGroup implements IBundleGroup {
     return this.#bundleGroup.entryAssetId;
   }
 
-  // $FlowFixMe
   [inspect]() {
     return `BundleGroup(${this.entryAssetId})`;
   }

package/src/public/{Config.js → Config.ts}

@@ -1,4 +1,3 @@
-// @flow strict-local
 import type {
   Config as IConfig,
   ConfigResult,
@@ -20,19 +19,98 @@ import {
 } from '@atlaspack/utils';
 import Environment from './Environment';
 import {fromProjectPath, toProjectPath} from '../projectPath';
+import {fromEnvironmentId} from '../EnvironmentManager';
 
 const internalConfigToConfig: DefaultWeakMap<
   AtlaspackOptions,
-  WeakMap<Config, PublicConfig>,
+  WeakMap<Config, PublicConfig>
 > = new DefaultWeakMap(() => new WeakMap());
 
-export default class PublicConfig implements IConfig {
-  #config /*: Config */;
-  #pkg /*: ?PackageJSON */;
-  #pkgFilePath /*: ?FilePath */;
-  #options /*: AtlaspackOptions */;
+/**
+ * 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: Array<string>) => {
+    if (reportedPaths.has(path)) {
+      return;
+    }
+    reportedPaths.add(path);
+    onRead(path);
+  };
+
+  const makeProxy = (target: T, path: Array<string>) => {
+    // @ts-expect-error TS2345
+    return new Proxy(target, {
+      ownKeys(target: T) {
+        reportPath(path);
+
+        return Object.getOwnPropertyNames(target);
+      },
+      get(target: T, prop: string) {
+        // @ts-expect-error TS7053
+        const value = target[prop];
+
+        if (
+          typeof value === 'object' &&
+          value != null &&
+          !Array.isArray(value)
+        ) {
+          return makeProxy(value, [...path, prop]);
+        }
+
+        reportPath([...path, prop]);
+
+        return value;
+      },
+    });
+  };
 
-  constructor(config: Config, options: AtlaspackOptions): PublicConfig {
+  // @ts-expect-error TS2322
+  return makeProxy(config, []);
+}
+
+export default class PublicConfig implements IConfig {
+  // @ts-expect-error TS2564
+  #config: Config;
+  #pkg: PackageJSON | null | undefined;
+  #pkgFilePath: FilePath | null | undefined;
+  // @ts-expect-error TS2564
+  #options: AtlaspackOptions;
+
+  constructor(config: Config, options: AtlaspackOptions) {
     let existing = internalConfigToConfig.get(options).get(config);
     if (existing != null) {
       return existing;
@@ -45,7 +123,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 {
@@ -60,7 +138,6 @@ export default class PublicConfig implements IConfig {
     return this.#config.isSource;
   }
 
-  // $FlowFixMe
   setResult(result: any): void {
     this.#config.result = result;
   }
@@ -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,
@@ -86,31 +163,43 @@ export default class PublicConfig implements IConfig {
     this.#config.devDeps.push({
       ...devDep,
       resolveFrom: toProjectPath(this.#options.projectRoot, devDep.resolveFrom),
-      additionalInvalidations: devDep.additionalInvalidations?.map((i) => ({
-        ...i,
-        resolveFrom: toProjectPath(this.#options.projectRoot, i.resolveFrom),
-      })),
+      additionalInvalidations: devDep.additionalInvalidations?.map(
+        (i: {
+          // @ts-expect-error TS2304
+          range?: SemverRange | null | undefined;
+          resolveFrom: FilePath;
+          // @ts-expect-error TS2304
+          specifier: DependencySpecifier;
+        }) => ({
+          ...i,
+          resolveFrom: toProjectPath(this.#options.projectRoot, i.resolveFrom),
+        }),
+      ),
     });
   }
 
   invalidateOnFileCreate(invalidation: FileCreateInvalidation) {
+    // @ts-expect-error TS2339
     if (invalidation.glob != null) {
-      // $FlowFixMe
       this.#config.invalidateOnFileCreate.push(invalidation);
+      // @ts-expect-error TS2339
     } else if (invalidation.filePath != null) {
       this.#config.invalidateOnFileCreate.push({
         filePath: toProjectPath(
           this.#options.projectRoot,
+          // @ts-expect-error TS2339
           invalidation.filePath,
         ),
       });
     } else {
+      // @ts-expect-error TS2339
       invariant(invalidation.aboveFilePath != null);
       this.#config.invalidateOnFileCreate.push({
-        // $FlowFixMe
+        // @ts-expect-error TS2339
         fileName: invalidation.fileName,
         aboveFilePath: toProjectPath(
           this.#options.projectRoot,
+          // @ts-expect-error TS2339
           invalidation.aboveFilePath,
         ),
       });
@@ -132,29 +221,69 @@ export default class PublicConfig implements IConfig {
   async getConfigFrom<T>(
     searchPath: FilePath,
     fileNames: Array<string>,
-    options: ?{|
-      packageKey?: string,
-      parse?: boolean,
-      exclude?: boolean,
-    |},
-  ): Promise<?ConfigResultWithFilePath<T>> {
+    options:
+      | {
+          /**
+           * @deprecated Use `configKey` instead.
+           */
+          packageKey?: string;
+          parse?: boolean;
+          exclude?: boolean;
+        }
+      | null
+      | undefined
+      | {
+          /**
+           * 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;
+        }
+      | null
+      | undefined,
+  ): Promise<ConfigResultWithFilePath<T> | null | undefined> {
+    // @ts-expect-error TS2339
     let packageKey = options?.packageKey;
     if (packageKey != null) {
       let pkg = await this.getConfigFrom(searchPath, ['package.json'], {
         exclude: true,
       });
 
+      // @ts-expect-error TS18046
       if (pkg && pkg.contents[packageKey]) {
         // Invalidate only when the package key changes
-        this.invalidateOnConfigKeyChange(pkg.filePath, packageKey);
+        this.invalidateOnConfigKeyChange(pkg.filePath, [packageKey]);
 
         return {
+          // @ts-expect-error TS18046
           contents: pkg.contents[packageKey],
           filePath: pkg.filePath,
         };
       }
     }
 
+    // @ts-expect-error TS2339
+    const readTracking = options?.readTracking;
+    if (readTracking === true) {
+      for (let fileName of fileNames) {
+        const config = await this.getConfigFrom(searchPath, [fileName], {
+          exclude: true,
+        });
+
+        if (config != null) {
+          // @ts-expect-error TS2322
+          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;
     }
@@ -167,6 +296,7 @@ export default class PublicConfig implements IConfig {
       });
     }
 
+    // @ts-expect-error TS2339
     let parse = options && options.parse;
     let configFilePath = await resolveConfig(
       this.#options.inputFS,
@@ -178,6 +308,7 @@ export default class PublicConfig implements IConfig {
       return null;
     }
 
+    // @ts-expect-error TS2339
     if (!options || !options.exclude) {
       this.invalidateOnFileChange(configFilePath);
     }
@@ -203,7 +334,6 @@ export default class PublicConfig implements IConfig {
       );
 
       if (
-        // $FlowFixMe
         Object.prototype.toString.call(config) === '[object Module]' &&
         config.default != null
       ) {
@@ -234,21 +364,29 @@ export default class PublicConfig implements IConfig {
 
   getConfig<T>(
     filePaths: Array<FilePath>,
-    options: ?{|
-      packageKey?: string,
-      parse?: boolean,
-      exclude?: boolean,
-    |},
-  ): Promise<?ConfigResultWithFilePath<T>> {
+    options:
+      | {
+          packageKey?: string;
+          parse?: boolean;
+          exclude?: boolean;
+        }
+      | null
+      | undefined
+      | {
+          readTracking?: boolean;
+        },
+  ): Promise<ConfigResultWithFilePath<T> | null | undefined> {
     return this.getConfigFrom(this.searchPath, filePaths, options);
   }
 
-  async getPackage(): Promise<?PackageJSON> {
+  async getPackage(): Promise<PackageJSON | null | undefined> {
     if (this.#pkg) {
       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;
     }