@atlaspack/core 2.16.2-dev.14 → 2.16.2-dev.1c70d50f9.99

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,
@@ -24,6 +25,7 @@ import {
   toProjectPath,
 } from '../projectPath';
 import {requestTypes} from '../RequestTracker';
+import {getFeatureFlag} from '@atlaspack/feature-flags';
 
 // A cache of dev dep requests keyed by invalidations.
 // If the package manager returns the same invalidation object, then
@@ -116,17 +118,47 @@ type DevDepRequests = {|
 export async function getDevDepRequests<TResult: RequestResult>(
   api: RunAPI<TResult>,
 ): Promise<DevDepRequests> {
-  let previousDevDepRequests: Map<string, DevDepRequestResult> = new Map(
-    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)),
-        ]),
-    ),
-  );
+  async function getPreviousDevDepRequests() {
+    if (getFeatureFlag('fixBuildAbortCorruption')) {
+      const allDevDepRequests = await Promise.all(
+        api
+          .getSubRequests()
+          .filter((req) => req.requestType === requestTypes.dev_dep_request)
+          .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);
+    } else {
+      return new Map(
+        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),
+              ),
+            ]),
+        ),
+      );
+    }
+  }
+
+  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

@@ -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/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);

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,11 +140,12 @@ export type Dependency = {|
   isEntry: boolean,
   isOptional: boolean,
   loc: ?InternalSourceLocation,
-  env: Environment,
+  env: EnvironmentRef,
   packageConditions?: number,
   customPackageConditions?: Array<string>,
   meta: Meta,
   resolverMeta?: ?Meta,
+  resolverPriority?: $Values<typeof Priority>,
   target: ?Target,
   sourceAssetId: ?string,
   sourcePath: ?ProjectPath,
@@ -180,7 +182,7 @@ export type Asset = {|
   bundleBehavior: ?$Values<typeof BundleBehavior>,
   isBundleSplittable: boolean,
   isSource: boolean,
-  env: Environment,
+  env: EnvironmentRef,
   meta: Meta,
   stats: Stats,
   contentKey: ?string,
@@ -388,7 +390,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 +494,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 +541,7 @@ export type Bundle = {|
   publicId: ?string,
   hashReference: string,
   type: string,
-  env: Environment,
+  env: EnvironmentRef,
   entryAssetIds: Array<ContentKey>,
   mainEntryId: ?ContentKey,
   needsStableName: ?boolean,
@@ -573,6 +575,7 @@ export type BundleGroupNode = {|
 
 export type PackagedBundleInfo = {|
   filePath: ProjectPath,
+  bundleId: ContentKey,
   type: string,
   stats: Stats,
 |};

package/test/Environment.test.js

@@ -5,10 +5,11 @@ import assert from 'assert';
 import expect from 'expect';
 import {createEnvironment} from '../src/Environment';
 import {initializeMonitoring} from '../../rust';
+import {fromEnvironmentId} from '../src/EnvironmentManager';
 
 describe('Environment', () => {
   it('assigns a default environment with nothing passed', () => {
-    assert.deepEqual(createEnvironment(), {
+    assert.deepEqual(fromEnvironmentId(createEnvironment()), {
       id: 'd821e85f6b50315e',
       context: 'browser',
       engines: {
@@ -27,27 +28,32 @@ describe('Environment', () => {
   });
 
   it('assigns a node context if a node engine is given', () => {
-    assert.deepEqual(createEnvironment({engines: {node: '>= 10.0.0'}}), {
-      id: '2320af923a717577',
-      context: 'node',
-      engines: {
-        node: '>= 10.0.0',
+    assert.deepEqual(
+      fromEnvironmentId(createEnvironment({engines: {node: '>= 10.0.0'}})),
+      {
+        id: '2320af923a717577',
+        context: 'node',
+        engines: {
+          node: '>= 10.0.0',
+        },
+        includeNodeModules: false,
+        outputFormat: 'commonjs',
+        isLibrary: false,
+        shouldOptimize: false,
+        shouldScopeHoist: false,
+        sourceMap: undefined,
+        loc: undefined,
+        sourceType: 'module',
+        unstableSingleFileOutput: false,
       },
-      includeNodeModules: false,
-      outputFormat: 'commonjs',
-      isLibrary: false,
-      shouldOptimize: false,
-      shouldScopeHoist: false,
-      sourceMap: undefined,
-      loc: undefined,
-      sourceType: 'module',
-      unstableSingleFileOutput: false,
-    });
+    );
   });
 
   it('assigns a browser context if browser engines are given', () => {
     assert.deepEqual(
-      createEnvironment({engines: {browsers: ['last 1 version']}}),
+      fromEnvironmentId(
+        createEnvironment({engines: {browsers: ['last 1 version']}}),
+      ),
       {
         id: '75603271034eff15',
         context: 'browser',
@@ -68,7 +74,7 @@ describe('Environment', () => {
   });
 
   it('assigns default engines for node', () => {
-    assert.deepEqual(createEnvironment({context: 'node'}), {
+    assert.deepEqual(fromEnvironmentId(createEnvironment({context: 'node'})), {
       id: 'e45cc12216f7857d',
       context: 'node',
       engines: {
@@ -87,22 +93,25 @@ describe('Environment', () => {
   });
 
   it('assigns default engines for browsers', () => {
-    assert.deepEqual(createEnvironment({context: 'browser'}), {
-      id: 'd821e85f6b50315e',
-      context: 'browser',
-      engines: {
-        browsers: ['> 0.25%'],
+    assert.deepEqual(
+      fromEnvironmentId(createEnvironment({context: 'browser'})),
+      {
+        id: 'd821e85f6b50315e',
+        context: 'browser',
+        engines: {
+          browsers: ['> 0.25%'],
+        },
+        includeNodeModules: true,
+        outputFormat: 'global',
+        isLibrary: false,
+        shouldOptimize: false,
+        shouldScopeHoist: false,
+        sourceMap: undefined,
+        loc: undefined,
+        sourceType: 'module',
+        unstableSingleFileOutput: false,
       },
-      includeNodeModules: true,
-      outputFormat: 'global',
-      isLibrary: false,
-      shouldOptimize: false,
-      shouldScopeHoist: false,
-      sourceMap: undefined,
-      loc: undefined,
-      sourceType: 'module',
-      unstableSingleFileOutput: false,
-    });
+    );
   });
 });
 
@@ -114,6 +123,6 @@ describe('createEnvironment', function () {
       /* ignore */
     }
     const environment = createEnvironment({});
-    expect(environment.id).toEqual('d821e85f6b50315e');
+    expect(fromEnvironmentId(environment).id).toEqual('d821e85f6b50315e');
   });
 });