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

package/src/public/MutableBundleGraph.js

@@ -11,6 +11,7 @@ import type {
 } from '@atlaspack/types';
 import type {
   AtlaspackOptions,
+  BundleGraphNode,
   BundleGroup as InternalBundleGroup,
   BundleNode,
 } from '../types';
@@ -32,6 +33,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,
@@ -53,9 +55,9 @@ export default class MutableBundleGraph
   extends BundleGraph<IBundle>
   implements IMutableBundleGraph
 {
-  #graph /*: InternalBundleGraph */;
-  #options /*: AtlaspackOptions */;
-  #bundlePublicIds /*: Set<string> */ = new Set<string>();
+  #graph: InternalBundleGraph;
+  #options: AtlaspackOptions;
+  #bundlePublicIds: Set<string> = new Set<string>();
 
   constructor(graph: InternalBundleGraph, options: AtlaspackOptions) {
     super(graph, Bundle.get.bind(Bundle), options);
@@ -206,7 +208,8 @@ export default class MutableBundleGraph
       bundleBehavior: opts.bundleBehavior ?? null,
     });
 
-    let existing = this.#graph._graph.getNodeByContentKey(bundleId);
+    let existing: ?BundleGraphNode =
+      this.#graph._graph.getNodeByContentKey(bundleId);
     if (existing != null) {
       invariant(existing.type === 'bundle');
       return Bundle.get(existing.value, this.#graph, this.#options);
@@ -236,7 +239,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/PluginOptions.js

@@ -18,7 +18,7 @@ let parcelOptionsToPluginOptions: WeakMap<AtlaspackOptions, PluginOptions> =
   new WeakMap();
 
 export default class PluginOptions implements IPluginOptions {
-  #options /*: AtlaspackOptions */;
+  #options: AtlaspackOptions;
 
   constructor(options: AtlaspackOptions): PluginOptions {
     let existing = parcelOptionsToPluginOptions.get(options);

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');
 
@@ -21,8 +22,8 @@ export function targetToInternalTarget(target: ITarget): TargetValue {
 }
 
 export default class Target implements ITarget {
-  #target /*: TargetValue */;
-  #options /*: AtlaspackOptions */;
+  #target: TargetValue;
+  #options: AtlaspackOptions;
 
   constructor(target: TargetValue, options: AtlaspackOptions): Target {
     let existing = internalTargetToTarget.get(target);
@@ -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/AssetGraphRequest.js

@@ -20,6 +20,7 @@ import logger from '@atlaspack/logger';
 
 import invariant from 'assert';
 import nullthrows from 'nullthrows';
+import {getFeatureFlag} from '@atlaspack/feature-flags';
 import {PromiseQueue, setEqual} from '@atlaspack/utils';
 import {hashString} from '@atlaspack/rust';
 import ThrowableDiagnostic from '@atlaspack/diagnostic';
@@ -161,12 +162,21 @@ export class AssetGraphBuilder {
     this.shouldBuildLazily = shouldBuildLazily ?? false;
     this.lazyIncludes = lazyIncludes ?? [];
     this.lazyExcludes = lazyExcludes ?? [];
-    this.cacheKey =
-      hashString(
+    if (getFeatureFlag('cachePerformanceImprovements')) {
+      const key = hashString(
         `${ATLASPACK_VERSION}${name}${JSON.stringify(entries) ?? ''}${
           options.mode
         }${options.shouldBuildLazily ? 'lazy' : 'eager'}`,
-      ) + '-AssetGraph';
+      );
+      this.cacheKey = `AssetGraph/${ATLASPACK_VERSION}/${options.mode}/${key}`;
+    } else {
+      this.cacheKey =
+        hashString(
+          `${ATLASPACK_VERSION}${name}${JSON.stringify(entries) ?? ''}${
+            options.mode
+          }${options.shouldBuildLazily ? 'lazy' : 'eager'}`,
+        ) + '-AssetGraph';
+    }
 
     this.isSingleChangeRebuild =
       api

package/src/requests/AssetGraphRequestRust.js

@@ -5,6 +5,7 @@ import invariant from 'assert';
 import ThrowableDiagnostic from '@atlaspack/diagnostic';
 import type {Async} from '@atlaspack/types';
 import {instrument} from '@atlaspack/logger';
+import {getFeatureFlag} from '@atlaspack/feature-flags';
 
 import AssetGraph, {nodeFromAssetGroup} from '../AssetGraph';
 import type {AtlaspackV3} from '../atlaspack-v3';
@@ -16,6 +17,8 @@ import type {
   AssetGraphRequestInput,
   AssetGraphRequestResult,
 } from './AssetGraphRequest';
+import {toEnvironmentRef} from '../EnvironmentManager';
+import {getEnvironmentHash} from '../Environment';
 
 type RunInput = {|
   input: AssetGraphRequestInput,
@@ -166,9 +169,14 @@ export function getAssetGraph(serializedGraph: any): {
 
       asset.committed = true;
       asset.contentKey = id;
-      asset.env.id = getEnvId(asset.env);
+      asset.env.id = getFeatureFlag('environmentDeduplication')
+        ? // TODO: Rust can do this and avoid copying a significant amount of data over
+          getEnvironmentHash(asset.env)
+        : getEnvId(asset.env);
       asset.mapKey = `map:${asset.id}`;
 
+      asset.env = toEnvironmentRef(asset.env);
+
       // This is populated later when we map the edges between assets and dependencies
       asset.dependencies = new Map();
 
@@ -195,7 +203,11 @@ export function getAssetGraph(serializedGraph: any): {
       let dependency = node.value.dependency;
 
       dependency.id = id;
-      dependency.env.id = getEnvId(dependency.env);
+      dependency.env.id = getFeatureFlag('environmentDeduplication')
+        ? // TODO: Rust can do this and avoid copying a significant amount of data over
+          getEnvironmentHash(dependency.env)
+        : getEnvId(dependency.env);
+      dependency.env = toEnvironmentRef(dependency.env);
 
       if (dependency.symbols != null) {
         dependency.symbols = new Map(dependency.symbols?.map(mapSymbols));

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/BundleGraphRequest.js

@@ -20,6 +20,7 @@ import invariant from 'assert';
 import assert from 'assert';
 import nullthrows from 'nullthrows';
 import {PluginLogger} from '@atlaspack/logger';
+import {getFeatureFlag} from '@atlaspack/feature-flags';
 import ThrowableDiagnostic, {errorToDiagnostic} from '@atlaspack/diagnostic';
 import AssetGraph from '../AssetGraph';
 import BundleGraph from '../public/BundleGraph';
@@ -282,12 +283,21 @@ class BundlerRunner {
     this.pluginOptions = new PluginOptions(
       optionsProxy(this.options, api.invalidateOnOptionChange),
     );
-    this.cacheKey =
-      hashString(
+    if (getFeatureFlag('cachePerformanceImprovements')) {
+      const key = hashString(
         `${ATLASPACK_VERSION}:BundleGraph:${
           JSON.stringify(options.entries) ?? ''
         }${options.mode}${options.shouldBuildLazily ? 'lazy' : 'eager'}`,
-      ) + '-BundleGraph';
+      );
+      this.cacheKey = `BundleGraph/${ATLASPACK_VERSION}/${options.mode}/${key}`;
+    } else {
+      this.cacheKey =
+        hashString(
+          `${ATLASPACK_VERSION}:BundleGraph:${
+            JSON.stringify(options.entries) ?? ''
+          }${options.mode}${options.shouldBuildLazily ? 'lazy' : 'eager'}`,
+        ) + '-BundleGraph';
+    }
   }
 
   async loadConfigs() {

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/DevDepRequest.js

@@ -1,4 +1,5 @@
-// @flow
+// @flow strict-local
+
 import type {
   DependencySpecifier,
   SemverRange,
@@ -116,17 +117,29 @@ type DevDepRequests = {|
 export async function getDevDepRequests<TResult: RequestResult>(
   api: RunAPI<TResult>,
 ): Promise<DevDepRequests> {
-  let previousDevDepRequests: Map<string, DevDepRequestResult> = new Map(
-    await Promise.all(
+  async function getPreviousDevDepRequests() {
+    const allDevDepRequests = await Promise.all(
       api
         .getSubRequests()
         .filter((req) => req.requestType === requestTypes.dev_dep_request)
-        .map(async (req) => [
-          req.id,
-          nullthrows(await api.getRequestResult<DevDepRequestResult>(req.id)),
-        ]),
-    ),
-  );
+        .map(
+          async (req): Promise<[string, DevDepRequestResult | null | void]> => [
+            req.id,
+            await api.getRequestResult<DevDepRequestResult>(req.id),
+          ],
+        ),
+    );
+    const nonNullDevDepRequests = [];
+    for (const [id, result] of allDevDepRequests) {
+      if (result != null) {
+        nonNullDevDepRequests.push([id, result]);
+      }
+    }
+
+    return new Map(nonNullDevDepRequests);
+  }
+
+  const previousDevDepRequests = await getPreviousDevDepRequests();
 
   return {
     devDeps: new Map(

package/src/requests/PathRequest.js

@@ -24,6 +24,7 @@ import ThrowableDiagnostic, {
   md,
 } from '@atlaspack/diagnostic';
 import {PluginLogger} from '@atlaspack/logger';
+import {getFeatureFlag} from '@atlaspack/feature-flags';
 import nullthrows from 'nullthrows';
 import path from 'path';
 import {normalizePath} from '@atlaspack/utils';
@@ -320,6 +321,9 @@ export class ResolverRunner {
 
           if (result.priority != null) {
             dependency.priority = Priority[result.priority];
+            if (getFeatureFlag('hmrImprovements')) {
+              dependency.resolverPriority = dependency.priority;
+            }
           }
 
           if (result.invalidateOnEnvChange) {

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

@@ -40,6 +40,8 @@ import {AtlaspackConfig} from '../AtlaspackConfig';
 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;
@@ -110,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'),
     );
@@ -167,14 +171,15 @@ async function run({input, options, api}) {
     api,
   );
 
-  if (
-    mapKey &&
-    bundle.env.sourceMap &&
-    !bundle.env.sourceMap.inline &&
-    (await options.cache.has(mapKey))
-  ) {
+  const hasSourceMap = getFeatureFlag('cachePerformanceImprovements')
+    ? await options.cache.hasLargeBlob(mapKey)
+    : await options.cache.has(mapKey);
+  if (mapKey && env.sourceMap && !env.sourceMap.inline && hasSourceMap) {
+    const mapEntry = getFeatureFlag('cachePerformanceImprovements')
+      ? await options.cache.getLargeBlob(mapKey)
+      : await options.cache.getBlob(mapKey);
     await writeFiles(
-      blobToStream(await options.cache.getBlob(mapKey)),
+      blobToStream(mapEntry),
       info,
       hashRefToNameHash,
       options,
@@ -189,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

@@ -9,6 +9,7 @@ import {requestTypes} from '../RequestTracker';
 import type {PackagedBundleInfo} from '../types';
 import type BundleGraph from '../BundleGraph';
 import type {BundleInfo} from '../PackagerRunner';
+import {report} from '../ReporterRunner';
 
 import {HASH_REF_PREFIX} from '../constants';
 import {joinProjectPath} from '../projectPath';
@@ -38,6 +39,22 @@ export type WriteBundlesRequest = {|
   input: WriteBundlesRequestInput,
 |};
 
+function reportPackagingProgress(
+  completeBundles: number,
+  totalBundles: number,
+) {
+  if (!getFeatureFlag('cliProgressReportingImprovements')) {
+    return;
+  }
+
+  report({
+    type: 'buildProgress',
+    phase: 'packagingAndOptimizing',
+    totalBundles,
+    completeBundles,
+  });
+}
+
 /**
  * Packages, optimizes, and writes all bundles to the dist directory.
  */
@@ -84,6 +101,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,
@@ -96,14 +114,19 @@ async function run({input, api, farm, options}) {
       return true;
     });
 
+  let cachedBundles = new Set(
+    bundles.filter((b) => api.canSkipSubrequest(bundleGraph.getHash(b))),
+  );
+
   // Package on the main thread if there is only one bundle to package.
   // This avoids the cost of serializing the bundle graph for single file change builds.
   let useMainThread =
-    bundles.length === 1 ||
-    bundles.filter((b) => !api.canSkipSubrequest(bundleGraph.getHash(b)))
-      .length === 1;
+    bundles.length === 1 || bundles.length - cachedBundles.size <= 1;
 
   try {
+    let completeBundles = cachedBundles.size;
+    reportPackagingProgress(completeBundles, bundles.length);
+
     await Promise.all(
       bundles.map(async (bundle) => {
         let request = createPackageRequest({
@@ -116,6 +139,11 @@ async function run({input, api, farm, options}) {
 
         let info = await api.runRequest(request);
 
+        if (!cachedBundles.has(bundle)) {
+          completeBundles++;
+          reportPackagingProgress(completeBundles, bundles.length);
+        }
+
         if (!useMainThread) {
           // Force a refresh of the cache to avoid a race condition
           // between threaded reads and writes that can result in an LMDB cache miss:

package/src/resolveOptions.js

@@ -153,8 +153,10 @@ export default async function resolveOptions(
 
     const needsRustLmdbCache = getFeatureFlag('atlaspackV3');
 
-    if (!needsRustLmdbCache && !(outputFS instanceof NodeFS)) {
-      return new FSCache(outputFS, cacheDir);
+    if (!getFeatureFlag('cachePerformanceImprovements')) {
+      if (!needsRustLmdbCache && !(outputFS instanceof NodeFS)) {
+        return new FSCache(outputFS, cacheDir);
+      }
     }
 
     return new LMDBLiteCache(cacheDir);