@atlaspack/core 2.17.4 → 2.18.0

package/src/public/Config.js

@@ -21,12 +21,89 @@ import {
 import Environment from './Environment';
 import {fromProjectPath, toProjectPath} from '../projectPath';
 import {getFeatureFlag} from '@atlaspack/feature-flags';
+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 */;
@@ -46,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 {
@@ -76,7 +153,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,
@@ -144,9 +221,10 @@ export default class PublicConfig implements IConfig {
         |}
       | ?{|
           /**
-           * If specified, only invalidate when this config key changes.
+           * 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.
            */
-          configKey?: string,
+          readTracking?: boolean,
         |},
   ): Promise<?ConfigResultWithFilePath<T>> {
     let packageKey = options?.packageKey;
@@ -157,7 +235,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],
@@ -166,27 +244,24 @@ export default class PublicConfig implements IConfig {
       }
     }
 
-    if (getFeatureFlag('granularTsConfigInvalidation')) {
-      const configKey = options?.configKey;
-      if (configKey != null) {
-        for (let fileName of fileNames) {
-          let config = await this.getConfigFrom(searchPath, [fileName], {
-            exclude: true,
+    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,
           });
-
-          if (config && config.contents[configKey]) {
-            // Invalidate only when the package key changes
-            this.invalidateOnConfigKeyChange(config.filePath, configKey);
-
-            return {
-              contents: config.contents[configKey],
-              filePath: config.filePath,
-            };
-          }
         }
-
-        // fall through so that file above invalidations are registered
       }
+
+      // fall through so that file above invalidations are registered
     }
 
     if (fileNames.length === 0) {
@@ -268,11 +343,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);
   }
@@ -282,7 +361,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: getFeatureFlag('granularTsConfigInvalidation'),
+    });
     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);
@@ -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/MutableBundleGraph.js

@@ -32,6 +32,7 @@ import {BundleBehavior} from '../types';
 import BundleGroup, {bundleGroupToInternalBundleGroup} from './BundleGroup';
 import type {ProjectPath} from '../projectPath';
 import {identifierRegistry} from '../IdentifierRegistry';
+import {toEnvironmentRef} from '../EnvironmentManager';
 
 function createBundleId(data: {|
   entryAssetId: string | null,
@@ -236,7 +237,7 @@ export default class MutableBundleGraph
           : bundleId.slice(-8),
         type: opts.entryAsset ? opts.entryAsset.type : opts.type,
         env: opts.env
-          ? environmentToInternalEnvironment(opts.env)
+          ? toEnvironmentRef(environmentToInternalEnvironment(opts.env))
           : nullthrows(entryAsset).env,
         entryAssetIds: entryAsset ? [entryAsset.id] : [],
         mainEntryId: entryAsset?.id,

package/src/public/Target.js

@@ -11,6 +11,7 @@ import nullthrows from 'nullthrows';
 import Environment from './Environment';
 import {fromProjectPath} from '../projectPath';
 import {fromInternalSourceLocation} from '../utils';
+import {fromEnvironmentId} from '../EnvironmentManager';
 
 const inspect = Symbol.for('nodejs.util.inspect.custom');
 
@@ -46,7 +47,7 @@ export default class Target implements ITarget {
   }
 
   get env(): IEnvironment {
-    return new Environment(this.#target.env, this.#options);
+    return new Environment(fromEnvironmentId(this.#target.env), this.#options);
   }
 
   get name(): string {

package/src/requests/AssetRequest.js

@@ -21,6 +21,7 @@ import {fromProjectPath, fromProjectPathRelative} from '../projectPath';
 import {report} from '../ReporterRunner';
 import {requestTypes} from '../RequestTracker';
 import type {DevDepRequestResult} from './DevDepRequest';
+import {toEnvironmentId} from '../EnvironmentManager';
 
 type RunInput<TResult> = {|
   input: AssetRequestInput,
@@ -51,7 +52,7 @@ function getId(input: AssetRequestInput) {
   return hashString(
     type +
       fromProjectPathRelative(input.filePath) +
-      input.env.id +
+      toEnvironmentId(input.env) +
       String(input.isSource) +
       String(input.sideEffects) +
       (input.code ?? '') +

package/src/requests/ConfigRequest.js

@@ -63,7 +63,7 @@ export type ConfigRequest = {
   invalidateOnFileChange: Set<ProjectPath>,
   invalidateOnConfigKeyChange: Array<{|
     filePath: ProjectPath,
-    configKey: string,
+    configKey: string[],
   |}>,
   invalidateOnFileCreate: Array<InternalFileCreateInvalidation>,
   invalidateOnEnvChange: Set<string>,
@@ -108,34 +108,58 @@ export async function loadPluginConfig<T: PluginWithLoadConfig>(
   }
 }
 
+/**
+ * Return value at a given key path within an object.
+ *
+ * @example
+ *     const obj = { a: { b: { c: 'd' } } };
+ *     getValueAtPath(obj, ['a', 'b', 'c']);        // 'd'
+ *     getValueAtPath(obj, ['a', 'b', 'd']);        // undefined
+ *     getValueAtPath(obj, ['a', 'b']);             // { c: 'd' }
+ *     getValueAtPath(obj, ['a', 'b', 'c', 'd']);   // undefined
+ */
+export function getValueAtPath(obj: Object, key: string[]): any {
+  let current = obj;
+  for (let part of key) {
+    if (current == null) {
+      return undefined;
+    }
+    current = current[part];
+  }
+  return current;
+}
+
 const configKeyCache = createBuildCache();
 
 export async function getConfigKeyContentHash(
   filePath: ProjectPath,
-  configKey: string,
+  configKey: string[],
   options: AtlaspackOptions,
 ): Async<string> {
-  let cacheKey = `${fromProjectPathRelative(filePath)}:${configKey}`;
+  let cacheKey = `${fromProjectPathRelative(filePath)}:${JSON.stringify(
+    configKey,
+  )}`;
   let cachedValue = configKeyCache.get(cacheKey);
 
   if (cachedValue) {
     return cachedValue;
   }
 
-  let conf = await readConfig(
+  const conf = await readConfig(
     options.inputFS,
     fromProjectPath(options.projectRoot, filePath),
   );
 
-  if (conf == null || conf.config[configKey] == null) {
+  const value = getValueAtPath(conf?.config, configKey);
+  if (conf == null || value == null) {
     // This can occur when a config key has been removed entirely during `respondToFSEvents`
     return '';
   }
 
-  let contentHash =
-    typeof conf.config[configKey] === 'object'
-      ? hashObject(conf.config[configKey])
-      : hashString(JSON.stringify(conf.config[configKey]));
+  const contentHash =
+    typeof value === 'object'
+      ? hashObject(value)
+      : hashString(JSON.stringify(value));
 
   configKeyCache.set(cacheKey, contentHash);
 

package/src/requests/TargetRequest.js

@@ -49,6 +49,7 @@ import {BROWSER_ENVS} from '../public/Environment';
 import {optionsProxy, toInternalSourceLocation} from '../utils';
 import {fromProjectPath, toProjectPath, joinProjectPath} from '../projectPath';
 import {requestTypes} from '../RequestTracker';
+import {fromEnvironmentId} from '../EnvironmentManager';
 
 type RunOpts<TResult> = {|
   input: Entry,
@@ -345,7 +346,7 @@ export class TargetResolver {
             },
           });
         }
-        if (!BROWSER_ENVS.has(targets[0].env.context)) {
+        if (!BROWSER_ENVS.has(fromEnvironmentId(targets[0].env).context)) {
           throw new ThrowableDiagnostic({
             diagnostic: {
               message: `Only browser targets are supported in serve mode`,
@@ -1491,21 +1492,22 @@ async function debugResolvedTargets(input, targets, targetInfo, options) {
 
     // Resolve relevant engines for context.
     let engines;
-    switch (target.env.context) {
+    const env = fromEnvironmentId(target.env);
+    switch (env.context) {
       case 'browser':
       case 'web-worker':
       case 'service-worker':
       case 'worklet': {
-        let browsers = target.env.engines.browsers;
+        let browsers = env.engines.browsers;
         engines = Array.isArray(browsers) ? browsers.join(', ') : browsers;
         break;
       }
       case 'node':
-        engines = target.env.engines.node;
+        engines = env.engines.node;
         break;
       case 'electron-main':
       case 'electron-renderer':
-        engines = target.env.engines.electron;
+        engines = env.engines.electron;
         break;
     }
 
@@ -1547,9 +1549,7 @@ async function debugResolvedTargets(input, targets, targetInfo, options) {
       }
 
       if (keyInfo.inferred) {
-        highlight.inferred.push(
-          md`${key} to be ${JSON.stringify(target.env[key])}`,
-        );
+        highlight.inferred.push(md`${key} to be ${JSON.stringify(env[key])}`);
       }
     }
 
@@ -1578,22 +1578,20 @@ async function debugResolvedTargets(input, targets, targetInfo, options) {
 
     // Format includeNodeModules to be human readable.
     let includeNodeModules;
-    if (typeof target.env.includeNodeModules === 'boolean') {
-      includeNodeModules = String(target.env.includeNodeModules);
-    } else if (Array.isArray(target.env.includeNodeModules)) {
+    if (typeof env.includeNodeModules === 'boolean') {
+      includeNodeModules = String(env.includeNodeModules);
+    } else if (Array.isArray(env.includeNodeModules)) {
       includeNodeModules =
         'only ' +
-        listFormat.format(
-          target.env.includeNodeModules.map((m) => JSON.stringify(m)),
-        );
+        listFormat.format(env.includeNodeModules.map((m) => JSON.stringify(m)));
     } else if (
-      target.env.includeNodeModules &&
-      typeof target.env.includeNodeModules === 'object'
+      env.includeNodeModules &&
+      typeof env.includeNodeModules === 'object'
     ) {
       includeNodeModules =
         'all except ' +
         listFormat.format(
-          Object.entries(target.env.includeNodeModules)
+          Object.entries(env.includeNodeModules)
             .filter(([, v]) => v === false)
             .map(([k]) => JSON.stringify(k)),
         );
@@ -1609,18 +1607,14 @@ async function debugResolvedTargets(input, targets, targetInfo, options) {
                  fromProjectPath(options.projectRoot, input.filePath),
                )}
               **Output**: ${path.relative(process.cwd(), output)}
-              **Format**: ${target.env.outputFormat} ${format(
-        info.outputFormat,
-      )}
-             **Context**: ${target.env.context} ${format(info.context)}
+              **Format**: ${env.outputFormat} ${format(info.outputFormat)}
+             **Context**: ${env.context} ${format(info.context)}
              **Engines**: ${engines || ''} ${format(info.engines)}
-        **Library Mode**: ${String(target.env.isLibrary)} ${format(
-        info.isLibrary,
-      )}
+        **Library Mode**: ${String(env.isLibrary)} ${format(info.isLibrary)}
 **Include Node Modules**: ${includeNodeModules} ${format(
         info.includeNodeModules,
       )}
-            **Optimize**: ${String(target.env.shouldOptimize)} ${format(
+            **Optimize**: ${String(env.shouldOptimize)} ${format(
         info.shouldOptimize,
       )}`,
       codeFrames: target.loc

package/src/requests/WriteBundleRequest.js

@@ -41,6 +41,7 @@ import ThrowableDiagnostic, {errorToDiagnostic} from '@atlaspack/diagnostic';
 import {PluginTracer, tracer} from '@atlaspack/profiler';
 import {requestTypes} from '../RequestTracker';
 import {getFeatureFlag} from '@atlaspack/feature-flags';
+import {fromEnvironmentId} from '../EnvironmentManager';
 
 const HASH_REF_PREFIX_LEN = HASH_REF_PREFIX.length;
 const BOUNDARY_LENGTH = HASH_REF_PREFIX.length + 32 - 1;
@@ -111,7 +112,9 @@ async function run({input, options, api}) {
   let cacheKeys = info.cacheKeys;
   let mapKey = cacheKeys.map;
   let fullPath = fromProjectPath(options.projectRoot, filePath);
-  if (mapKey && bundle.env.sourceMap && !bundle.env.sourceMap.inline) {
+  const env = fromEnvironmentId(bundle.env);
+
+  if (mapKey && env.sourceMap && !env.sourceMap.inline) {
     api.invalidateOnFileDelete(
       toProjectPath(options.projectRoot, fullPath + '.map'),
     );
@@ -171,12 +174,7 @@ async function run({input, options, api}) {
   const hasSourceMap = getFeatureFlag('cachePerformanceImprovements')
     ? await options.cache.hasLargeBlob(mapKey)
     : await options.cache.has(mapKey);
-  if (
-    mapKey &&
-    bundle.env.sourceMap &&
-    !bundle.env.sourceMap.inline &&
-    hasSourceMap
-  ) {
+  if (mapKey && env.sourceMap && !env.sourceMap.inline && hasSourceMap) {
     const mapEntry = getFeatureFlag('cachePerformanceImprovements')
       ? await options.cache.getLargeBlob(mapKey)
       : await options.cache.getBlob(mapKey);
@@ -196,6 +194,7 @@ async function run({input, options, api}) {
 
   let res = {
     filePath,
+    bundleId: bundle.id,
     type: info.type,
     stats: {
       size,

package/src/requests/WriteBundlesRequest.js

@@ -84,6 +84,7 @@ async function run({input, api, farm, options}) {
         ).replace(bundle.hashReference, hash);
         res.set(bundle.id, {
           filePath: joinProjectPath(bundle.target.distDir, name),
+          bundleId: bundle.id,
           type: bundle.type, // FIXME: this is wrong if the packager changes the type...
           stats: {
             time: 0,

package/src/types.js

@@ -34,6 +34,7 @@ import type {ProjectPath} from './projectPath';
 import type {Event} from '@parcel/watcher';
 import type {FeatureFlags} from '@atlaspack/feature-flags';
 import type {BackendType} from '@parcel/watcher';
+import type {EnvironmentRef} from './EnvironmentManager';
 
 export type AtlaspackPluginNode = {|
   packageName: PackageName,
@@ -97,7 +98,7 @@ export type InternalSourceLocation = {|
 export type Target = {|
   distEntry?: ?FilePath,
   distDir: ProjectPath,
-  env: Environment,
+  env: EnvironmentRef,
   name: string,
   publicUrl: string,
   loc?: ?InternalSourceLocation,
@@ -139,7 +140,7 @@ export type Dependency = {|
   isEntry: boolean,
   isOptional: boolean,
   loc: ?InternalSourceLocation,
-  env: Environment,
+  env: EnvironmentRef,
   packageConditions?: number,
   customPackageConditions?: Array<string>,
   meta: Meta,
@@ -180,7 +181,7 @@ export type Asset = {|
   bundleBehavior: ?$Values<typeof BundleBehavior>,
   isBundleSplittable: boolean,
   isSource: boolean,
-  env: Environment,
+  env: EnvironmentRef,
   meta: Meta,
   stats: Stats,
   contentKey: ?string,
@@ -388,7 +389,7 @@ export type RootNode = {|id: ContentKey, +type: 'root', value: string | null|};
 export type AssetRequestInput = {|
   name?: string, // AssetGraph name, needed so that different graphs can isolated requests since the results are not stored
   filePath: ProjectPath,
-  env: Environment,
+  env: EnvironmentRef,
   isSource?: boolean,
   canDefer?: boolean,
   sideEffects?: boolean,
@@ -492,13 +493,13 @@ export type Config = {|
   id: string,
   isSource: boolean,
   searchPath: ProjectPath,
-  env: Environment,
+  env: EnvironmentRef,
   cacheKey: ?string,
   result: ConfigResult,
   invalidateOnFileChange: Set<ProjectPath>,
   invalidateOnConfigKeyChange: Array<{|
     filePath: ProjectPath,
-    configKey: string,
+    configKey: string[],
   |}>,
   invalidateOnFileCreate: Array<InternalFileCreateInvalidation>,
   invalidateOnEnvChange: Set<string>,
@@ -539,7 +540,7 @@ export type Bundle = {|
   publicId: ?string,
   hashReference: string,
   type: string,
-  env: Environment,
+  env: EnvironmentRef,
   entryAssetIds: Array<ContentKey>,
   mainEntryId: ?ContentKey,
   needsStableName: ?boolean,
@@ -573,6 +574,7 @@ export type BundleGroupNode = {|
 
 export type PackagedBundleInfo = {|
   filePath: ProjectPath,
+  bundleId: ContentKey,
   type: string,
   stats: Stats,
 |};