@atlaspack/core 2.16.2-canary.21 → 2.16.2-canary.211

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

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

@@ -1,4 +1,3 @@
-// @flow
 import type {
   Dependency as IDependency,
   Environment as IEnvironment,
@@ -27,6 +26,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);
@@ -37,7 +37,7 @@ const internalDependencyToDependency: WeakMap<InternalDependency, Dependency> =
   new WeakMap();
 const _dependencyToInternalDependency: WeakMap<
   IDependency,
-  InternalDependency,
+  InternalDependency
 > = new WeakMap();
 export function dependencyToInternalDependency(
   dependency: IDependency,
@@ -58,10 +58,10 @@ export function getPublicDependency(
 }
 
 export default class Dependency implements IDependency {
-  #dep /*: InternalDependency */;
-  #options /*: AtlaspackOptions */;
+  #dep: InternalDependency;
+  #options: AtlaspackOptions;
 
-  constructor(dep: InternalDependency, options: AtlaspackOptions): Dependency {
+  constructor(dep: InternalDependency, options: AtlaspackOptions) {
     this.#dep = dep;
     this.#options = options;
     _dependencyToInternalDependency.set(this, dep);
@@ -69,7 +69,6 @@ export default class Dependency implements IDependency {
     return this;
   }
 
-  // $FlowFixMe
   [inspect](): string {
     return `Dependency(${String(this.sourcePath)} -> ${this.specifier})`;
   }
@@ -83,10 +82,12 @@ export default class Dependency implements IDependency {
   }
 
   get specifierType(): SpecifierType {
+    // @ts-expect-error TS2322
     return SpecifierTypeNames[this.#dep.specifierType];
   }
 
   get priority(): DependencyPriority {
+    // @ts-expect-error TS2322
     return PriorityNames[this.#dep.priority];
   }
 
@@ -94,7 +95,7 @@ export default class Dependency implements IDependency {
     return this.#dep.needsStableName;
   }
 
-  get bundleBehavior(): ?BundleBehavior {
+  get bundleBehavior(): BundleBehavior | null | undefined {
     let bundleBehavior = this.#dep.bundleBehavior;
     return bundleBehavior == null ? null : BundleBehaviorNames[bundleBehavior];
   }
@@ -107,15 +108,15 @@ export default class Dependency implements IDependency {
     return this.#dep.isOptional;
   }
 
-  get loc(): ?SourceLocation {
+  get loc(): SourceLocation | null | undefined {
     return fromInternalSourceLocation(this.#options.projectRoot, this.#dep.loc);
   }
 
   get env(): IEnvironment {
-    return new Environment(this.#dep.env, this.#options);
+    return new Environment(fromEnvironmentId(this.#dep.env), this.#options);
   }
 
-  get packageConditions(): ?Array<string> {
+  get packageConditions(): Array<string> | null | undefined {
     // Merge custom conditions with conditions stored as bitflags.
     // Order is not important because exports conditions are resolved
     // in the order they are declared in the package.json.
@@ -123,6 +124,7 @@ export default class Dependency implements IDependency {
     if (this.#dep.packageConditions) {
       conditions = conditions ? [...conditions] : [];
       for (let key in ExportsCondition) {
+        // @ts-expect-error TS7053
         if (this.#dep.packageConditions & ExportsCondition[key]) {
           conditions.push(key);
         }
@@ -137,40 +139,41 @@ export default class Dependency implements IDependency {
   }
 
   get symbols(): IMutableDependencySymbols {
+    // @ts-expect-error TS2322
     return new MutableDependencySymbols(this.#options, this.#dep);
   }
 
-  get target(): ?Target {
+  get target(): Target | null | undefined {
     let target = this.#dep.target;
     return target ? new Target(target, this.#options) : null;
   }
 
-  get sourceAssetId(): ?string {
+  get sourceAssetId(): string | null | undefined {
     // TODO: does this need to be public?
     return this.#dep.sourceAssetId;
   }
 
-  get sourcePath(): ?FilePath {
+  get sourcePath(): FilePath | null | undefined {
     // TODO: does this need to be public?
     return fromProjectPath(this.#options.projectRoot, this.#dep.sourcePath);
   }
 
-  get sourceAssetType(): ?string {
+  get sourceAssetType(): string | null | undefined {
     return this.#dep.sourceAssetType;
   }
 
-  get resolveFrom(): ?string {
+  get resolveFrom(): string | null | undefined {
     return fromProjectPath(
       this.#options.projectRoot,
       this.#dep.resolveFrom ?? this.#dep.sourcePath,
     );
   }
 
-  get range(): ?string {
+  get range(): string | null | undefined {
     return this.#dep.range;
   }
 
-  get pipeline(): ?string {
+  get pipeline(): string | null | undefined {
     return this.#dep.pipeline;
   }
 }

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

@@ -1,4 +1,3 @@
-// @flow strict-local
 import type {
   Environment as IEnvironment,
   EnvironmentContext,
@@ -10,6 +9,7 @@ import type {
   SourceLocation,
   SourceType,
   TargetSourceMapOptions,
+  EnvMap,
 } from '@atlaspack/types';
 import type {
   Environment as InternalEnvironment,
@@ -27,12 +27,17 @@ export const BROWSER_ENVS: Set<string> = new Set<string>([
   'web-worker',
   'service-worker',
   'worklet',
+  'tesseract',
   'electron-renderer',
 ]);
 const ELECTRON_ENVS = new Set(['electron-main', 'electron-renderer']);
 const NODE_ENVS = new Set(['node', ...ELECTRON_ENVS]);
 const WORKER_ENVS = new Set(['web-worker', 'service-worker']);
-export const ISOLATED_ENVS: Set<string> = new Set([...WORKER_ENVS, 'worklet']);
+export const ISOLATED_ENVS: Set<string> = new Set([
+  ...WORKER_ENVS,
+  'worklet',
+  'tesseract',
+]);
 
 const ALL_BROWSERS = [
   'chrome',
@@ -139,15 +144,15 @@ const supportData = {
     android: '71',
     samsung: '10.1',
   },
-};
+} as const;
 
 const internalEnvironmentToEnvironment: WeakMap<
   InternalEnvironment,
-  Environment,
+  Environment
 > = new WeakMap();
 const _environmentToInternalEnvironment: WeakMap<
   IEnvironment,
-  InternalEnvironment,
+  InternalEnvironment
 > = new WeakMap();
 export function environmentToInternalEnvironment(
   environment: IEnvironment,
@@ -156,13 +161,12 @@ export function environmentToInternalEnvironment(
 }
 
 export default class Environment implements IEnvironment {
-  #environment /*: InternalEnvironment */;
-  #options /*: AtlaspackOptions */;
+  // @ts-expect-error TS2564
+  #environment: InternalEnvironment;
+  // @ts-expect-error TS2564
+  #options: AtlaspackOptions;
 
-  constructor(
-    env: InternalEnvironment,
-    options: AtlaspackOptions,
-  ): Environment {
+  constructor(env: InternalEnvironment, options: AtlaspackOptions) {
     let existing = internalEnvironmentToEnvironment.get(env);
     if (existing != null) {
       return existing;
@@ -190,7 +194,7 @@ export default class Environment implements IEnvironment {
   get includeNodeModules():
     | boolean
     | Array<PackageName>
-    | {[PackageName]: boolean, ...} {
+    | Partial<Record<PackageName, boolean>> {
     return this.#environment.includeNodeModules;
   }
 
@@ -214,11 +218,11 @@ export default class Environment implements IEnvironment {
     return this.#environment.shouldScopeHoist;
   }
 
-  get sourceMap(): ?TargetSourceMapOptions {
+  get sourceMap(): TargetSourceMapOptions | null | undefined {
     return this.#environment.sourceMap;
   }
 
-  get loc(): ?SourceLocation {
+  get loc(): SourceLocation | null | undefined {
     return fromInternalSourceLocation(
       this.#options.projectRoot,
       this.#environment.loc,
@@ -229,7 +233,10 @@ export default class Environment implements IEnvironment {
     return this.#environment.unstableSingleFileOutput;
   }
 
-  // $FlowFixMe[unsupported-syntax]
+  get customEnv(): EnvMap | null | undefined {
+    return this.#environment.customEnv;
+  }
+
   [inspect](): string {
     return `Env(${this.#environment.context})`;
   }
@@ -258,9 +265,13 @@ export default class Environment implements IEnvironment {
     return this.#environment.context === 'worklet';
   }
 
+  isTesseract(): boolean {
+    return this.#environment.context === 'tesseract';
+  }
+
   matchesEngines(
     minVersions: VersionMap,
-    defaultValue?: boolean = false,
+    defaultValue: boolean = false,
   ): boolean {
     // Determine if the environment matches some minimum version requirements.
     // For browsers, we run a browserslist query with and without the minimum
@@ -306,7 +317,7 @@ export default class Environment implements IEnvironment {
 }
 
 function getExcludedBrowsers(minVersions: VersionMap) {
-  let browsers = [];
+  let browsers: Array<string> = [];
   for (let browser of ALL_BROWSERS) {
     let version = minVersions[browser];
     if (version) {