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

package/src/{PackagerRunner.js → PackagerRunner.ts}

@@ -1,5 +1,3 @@
-// @flow strict-local
-
 import type {
   Blob,
   FilePath,
@@ -26,7 +24,7 @@ import type {DevDepSpecifier} from './requests/DevDepRequest';
 
 import invariant from 'assert';
 import {createBuildCache} from '@atlaspack/build-cache';
-import {blobToStream, TapStream} from '@atlaspack/utils';
+import {blobToStream, debugTools, TapStream} from '@atlaspack/utils';
 import {PluginLogger} from '@atlaspack/logger';
 import ThrowableDiagnostic, {errorToDiagnostic} from '@atlaspack/diagnostic';
 import {Readable} from 'stream';
@@ -53,7 +51,7 @@ import {
   loadPluginConfig,
   getConfigHash,
   getConfigRequests,
-  type PluginWithBundleConfig,
+  PluginWithBundleConfig,
 } from './requests/ConfigRequest';
 import {
   createDevDependency,
@@ -63,37 +61,43 @@ import {getInvalidationId, getInvalidationHash} from './assetUtils';
 import {optionsProxy} from './utils';
 import {invalidateDevDeps} from './requests/DevDepRequest';
 import {tracer, PluginTracer} from '@atlaspack/profiler';
+import {fromEnvironmentId} from './EnvironmentManager';
+import {getFeatureFlag} from '@atlaspack/feature-flags';
 
-type Opts = {|
-  config: AtlaspackConfig,
-  options: AtlaspackOptions,
-  report: ReportFn,
-  previousDevDeps: Map<string, string>,
-  previousInvalidations: Array<RequestInvalidation>,
-|};
-
-export type RunPackagerRunnerResult = {|
-  bundleInfo: BundleInfo,
-  configRequests: Array<ConfigRequest>,
-  devDepRequests: Array<DevDepRequest | DevDepRequestRef>,
-  invalidations: Array<RequestInvalidation>,
-|};
-
-export type BundleInfo = {|
-  +type: string,
-  +size: number,
-  +hash: string,
-  +hashReferences: Array<string>,
-  +time?: number,
-  +cacheKeys: CacheKeyMap,
-  +isLargeBlob: boolean,
-|};
-
-type CacheKeyMap = {|
-  content: string,
-  map: string,
-  info: string,
-|};
+type Opts = {
+  config: AtlaspackConfig;
+  options: AtlaspackOptions;
+  report: ReportFn;
+  previousDevDeps: Map<string, string>;
+  previousInvalidations: Array<RequestInvalidation>;
+};
+
+export type RunPackagerRunnerResult = {
+  bundleInfo: BundleInfo;
+  configRequests: Array<ConfigRequest>;
+  devDepRequests: Array<DevDepRequest | DevDepRequestRef>;
+  invalidations: Array<RequestInvalidation>;
+};
+
+export type BundleInfo = {
+  readonly type: string;
+  readonly size: number;
+  readonly hash: string;
+  readonly hashReferences: Array<string>;
+  readonly time?: number;
+  readonly cacheKeys: CacheKeyMap;
+  readonly isLargeBlob: boolean;
+  readonly scopeHoistingStats?: {
+    totalAssets: number;
+    wrappedAssets: number;
+  };
+};
+
+type CacheKeyMap = {
+  content: string;
+  map: string;
+  info: string;
+};
 
 const BOUNDARY_LENGTH = HASH_REF_PREFIX.length + 32 - 1;
 
@@ -105,7 +109,9 @@ export default class PackagerRunner {
   config: AtlaspackConfig;
   options: AtlaspackOptions;
   pluginOptions: PluginOptions;
+  // @ts-expect-error TS2564
   distDir: FilePath;
+  // @ts-expect-error TS2564
   distExists: Set<FilePath>;
   report: ReportFn;
   previousDevDeps: Map<string, string>;
@@ -175,10 +181,10 @@ export default class PackagerRunner {
   async loadConfigs(
     bundleGraph: InternalBundleGraph,
     bundle: InternalBundle,
-  ): Promise<{|
-    configs: Map<string, Config>,
-    bundleConfigs: Map<string, Config>,
-  |}> {
+  ): Promise<{
+    configs: Map<string, Config>;
+    bundleConfigs: Map<string, Config>;
+  }> {
     let configs = new Map();
     let bundleConfigs = new Map();
 
@@ -218,7 +224,7 @@ export default class PackagerRunner {
     }
   }
 
-  async loadPluginConfig<T: PluginWithBundleConfig>(
+  async loadPluginConfig<T extends PluginWithBundleConfig>(
     bundleGraph: InternalBundleGraph,
     bundle: InternalBundle,
     plugin: LoadedPlugin<T>,
@@ -229,6 +235,7 @@ export default class PackagerRunner {
       // Only load config for a plugin once per build.
       let existing = pluginConfigs.get(plugin.name);
       if (existing != null) {
+        // @ts-expect-error TS2345
         configs.set(plugin.name, existing);
       } else {
         if (plugin.plugin.loadConfig != null) {
@@ -288,7 +295,7 @@ export default class PackagerRunner {
     bundle: InternalBundle,
     configs: Map<string, Config>,
     bundleConfigs: Map<string, Config>,
-  ): Async<?BundleInfo> {
+  ): Promise<Async<BundleInfo | null | undefined>> {
     if (this.options.shouldDisableCache) {
       return;
     }
@@ -310,7 +317,7 @@ export default class PackagerRunner {
     configs: Map<string, Config>,
     bundleConfigs: Map<string, Config>,
   ): Promise<BundleInfo> {
-    let {type, contents, map} = await this.getBundleResult(
+    let {type, contents, map, scopeHoistingStats} = await this.getBundleResult(
       bundle,
       bundleGraph,
       configs,
@@ -331,7 +338,13 @@ export default class PackagerRunner {
       info: PackagerRunner.getInfoKey(cacheKey),
     };
 
-    return this.writeToCache(cacheKeys, type, contents, map);
+    let cachedResult = await this.writeToCache(cacheKeys, type, contents, map);
+
+    if (debugTools['scope-hoisting-stats']) {
+      return {...cachedResult, scopeHoistingStats};
+    }
+
+    return cachedResult;
   }
 
   async getBundleResult(
@@ -339,11 +352,12 @@ export default class PackagerRunner {
     bundleGraph: InternalBundleGraph,
     configs: Map<string, Config>,
     bundleConfigs: Map<string, Config>,
-  ): Promise<{|
-    type: string,
-    contents: Blob,
-    map: ?string,
-  |}> {
+  ): Promise<{
+    type: string;
+    contents: Blob;
+    map: string | null | undefined;
+    scopeHoistingStats?: BundleResult['scopeHoistingStats'];
+  }> {
     let packaged = await this.package(
       bundle,
       bundleGraph,
@@ -367,11 +381,20 @@ export default class PackagerRunner {
       type: res.type ?? type,
       contents: res.contents,
       map,
+      scopeHoistingStats: packaged.scopeHoistingStats,
     };
   }
 
-  getSourceMapReference(bundle: NamedBundle, map: ?SourceMap): Async<?string> {
-    if (map && bundle.env.sourceMap && bundle.bundleBehavior !== 'inline') {
+  getSourceMapReference(
+    bundle: NamedBundle,
+    map?: SourceMap | null,
+  ): Async<string | null | undefined> {
+    if (
+      map &&
+      bundle.env.sourceMap &&
+      bundle.bundleBehavior !== 'inline' &&
+      bundle.bundleBehavior !== 'inlineIsolated'
+    ) {
       if (bundle.env.sourceMap && bundle.env.sourceMap.inline) {
         return this.generateSourceMap(bundleToInternalBundle(bundle), map);
       } else {
@@ -421,24 +444,26 @@ export default class PackagerRunner {
           bundle: BundleType,
           bundleGraph: BundleGraphType<NamedBundleType>,
         ) => {
-          if (bundle.bundleBehavior !== 'inline') {
+          if (
+            bundle.bundleBehavior !== 'inline' &&
+            bundle.bundleBehavior !== 'inlineIsolated'
+          ) {
             throw new Error(
               'Bundle is not inline and unable to retrieve contents',
             );
           }
 
-          let res = await this.getBundleResult(
+          let {contents} = await this.getBundleResult(
             bundleToInternalBundle(bundle),
-            // $FlowFixMe
             bundleGraphToInternalBundleGraph(bundleGraph),
             configs,
             bundleConfigs,
           );
 
-          return {contents: res.contents};
+          return {contents};
         },
       });
-    } catch (e) {
+    } catch (e: any) {
       throw new ThrowableDiagnostic({
         diagnostic: errorToDiagnostic(e, {
           origin: name,
@@ -469,7 +494,7 @@ export default class PackagerRunner {
     internalBundleGraph: InternalBundleGraph,
     type: string,
     contents: Blob,
-    map?: ?SourceMap,
+    map: SourceMap | null | undefined,
     configs: Map<string, Config>,
     bundleConfigs: Map<string, Config>,
   ): Promise<BundleResult> {
@@ -532,7 +557,7 @@ export default class PackagerRunner {
         optimized.type = next.type ?? optimized.type;
         optimized.contents = next.contents;
         optimized.map = next.map;
-      } catch (e) {
+      } catch (e: any) {
         throw new ThrowableDiagnostic({
           diagnostic: errorToDiagnostic(e, {
             origin: optimizer.name,
@@ -577,36 +602,47 @@ export default class PackagerRunner {
     );
     let inlineSources = false;
 
+    const bundleEnv = fromEnvironmentId(bundle.env);
     if (bundle.target) {
-      if (
-        bundle.env.sourceMap &&
-        bundle.env.sourceMap.sourceRoot !== undefined
-      ) {
-        sourceRoot = bundle.env.sourceMap.sourceRoot;
+      const bundleTargetEnv = fromEnvironmentId(bundle.target.env);
+
+      if (bundleEnv.sourceMap && bundleEnv.sourceMap.sourceRoot !== undefined) {
+        sourceRoot = bundleEnv.sourceMap.sourceRoot;
       } else if (
         this.options.serveOptions &&
-        bundle.target.env.context === 'browser'
+        bundleTargetEnv.context === 'browser'
       ) {
         sourceRoot = '/__parcel_source_root';
       }
 
       if (
-        bundle.env.sourceMap &&
-        bundle.env.sourceMap.inlineSources !== undefined
+        bundleEnv.sourceMap &&
+        bundleEnv.sourceMap.inlineSources !== undefined
       ) {
-        inlineSources = bundle.env.sourceMap.inlineSources;
-      } else if (bundle.target.env.context !== 'node') {
+        inlineSources = bundleEnv.sourceMap.inlineSources;
+      } else if (bundleTargetEnv.context !== 'node') {
         // inlining should only happen in production for browser targets by default
         inlineSources = this.options.mode === 'production';
       }
     }
 
     let mapFilename = fullPath + '.map';
-    let isInlineMap = bundle.env.sourceMap && bundle.env.sourceMap.inline;
+    let isInlineMap = bundleEnv.sourceMap && bundleEnv.sourceMap.inline;
+
+    if (getFeatureFlag('omitSourcesContentInMemory') && !isInlineMap) {
+      if (
+        !(bundleEnv.sourceMap && bundleEnv.sourceMap.inlineSources === false)
+      ) {
+        /*
+          We're omitting sourcesContent during transformation to allow GC to run.
+          Ensure sources are still inlined into the final source maps written to disk. UNLESS the user explicitly disabled inlineSources.
+        */
+        inlineSources = true;
+      }
+    }
 
     let stringified = await map.stringify({
       file: path.basename(mapFilename),
-      // $FlowFixMe
       fs: this.options.inputFS,
       rootDir: this.options.projectRoot,
       sourceRoot: !inlineSources
@@ -627,7 +663,7 @@ export default class PackagerRunner {
     bundleConfigs: Map<string, Config>,
     invalidations: Array<RequestInvalidation>,
   ): Promise<string> {
-    let configResults = {};
+    let configResults: Record<string, any> = {};
     for (let [pluginName, config] of configs) {
       if (config) {
         configResults[pluginName] = await getConfigHash(
@@ -637,7 +673,7 @@ export default class PackagerRunner {
         );
       }
     }
-    let globalInfoResults = {};
+    let globalInfoResults: Record<string, any> = {};
     for (let [pluginName, config] of bundleConfigs) {
       if (config) {
         globalInfoResults[pluginName] = await getConfigHash(
@@ -658,6 +694,21 @@ export default class PackagerRunner {
       this.options,
     );
 
+    if (getFeatureFlag('cachePerformanceImprovements')) {
+      const hash = hashString(
+        ATLASPACK_VERSION +
+          devDepHashes +
+          invalidationHash +
+          bundle.target.publicUrl +
+          bundleGraph.getHash(bundle) +
+          JSON.stringify(configResults) +
+          JSON.stringify(globalInfoResults) +
+          this.options.mode +
+          (this.options.shouldBuildLazily ? 'lazy' : 'eager'),
+      );
+      return path.join(bundle.displayName ?? bundle.name ?? bundle.id, hash);
+    }
+
     return hashString(
       ATLASPACK_VERSION +
         devDepHashes +
@@ -692,28 +743,39 @@ export default class PackagerRunner {
     return devDepHashes;
   }
 
-  async readFromCache(cacheKey: string): Promise<?{|
-    contents: Readable,
-    map: ?Readable,
-  |}> {
+  async readFromCache(cacheKey: string): Promise<
+    | {
+        contents: Readable;
+        map: Readable | null | undefined;
+      }
+    | null
+    | undefined
+  > {
     let contentKey = PackagerRunner.getContentKey(cacheKey);
     let mapKey = PackagerRunner.getMapKey(cacheKey);
 
     let isLargeBlob = await this.options.cache.hasLargeBlob(contentKey);
-    let contentExists =
-      isLargeBlob || (await this.options.cache.has(contentKey));
+    let contentExists = getFeatureFlag('cachePerformanceImprovements')
+      ? isLargeBlob
+      : isLargeBlob || (await this.options.cache.has(contentKey));
     if (!contentExists) {
       return null;
     }
 
-    let mapExists = await this.options.cache.has(mapKey);
+    let mapExists = getFeatureFlag('cachePerformanceImprovements')
+      ? await this.options.cache.hasLargeBlob(mapKey)
+      : await this.options.cache.has(mapKey);
 
     return {
       contents: isLargeBlob
         ? this.options.cache.getStream(contentKey)
         : blobToStream(await this.options.cache.getBlob(contentKey)),
       map: mapExists
-        ? blobToStream(await this.options.cache.getBlob(mapKey))
+        ? blobToStream(
+            getFeatureFlag('cachePerformanceImprovements')
+              ? await this.options.cache.getLargeBlob(mapKey)
+              : await this.options.cache.getBlob(mapKey),
+          )
         : null,
     };
   }
@@ -722,22 +784,27 @@ export default class PackagerRunner {
     cacheKeys: CacheKeyMap,
     type: string,
     contents: Blob,
-    map: ?string,
+    map?: string | null,
   ): Promise<BundleInfo> {
     let size = 0;
     let hash;
-    let hashReferences = [];
-    let isLargeBlob = false;
+    // @ts-expect-error TS2702
+    let hashReferences: RegExp.matchResult | Array<string> = [];
+    let isLargeBlob = getFeatureFlag('cachePerformanceImprovements');
 
     // TODO: don't replace hash references in binary files??
     if (contents instanceof Readable) {
-      isLargeBlob = true;
+      if (!getFeatureFlag('cachePerformanceImprovements')) {
+        isLargeBlob = true;
+      }
+
       let boundaryStr = '';
       let h = new Hash();
       await this.options.cache.setStream(
         cacheKeys.content,
         blobToStream(contents).pipe(
-          new TapStream((buf) => {
+          // @ts-expect-error TS2554
+          new TapStream((buf: Buffer) => {
             let str = boundaryStr + buf.toString();
             hashReferences = hashReferences.concat(
               str.match(HASH_REF_REGEX) ?? [],
@@ -754,17 +821,32 @@ export default class PackagerRunner {
       size = buffer.byteLength;
       hash = hashBuffer(buffer);
       hashReferences = contents.match(HASH_REF_REGEX) ?? [];
-      await this.options.cache.setBlob(cacheKeys.content, buffer);
+
+      if (getFeatureFlag('cachePerformanceImprovements')) {
+        await this.options.cache.setLargeBlob(cacheKeys.content, buffer);
+      } else {
+        await this.options.cache.setBlob(cacheKeys.content, buffer);
+      }
     } else {
       size = contents.length;
       hash = hashBuffer(contents);
       hashReferences = contents.toString().match(HASH_REF_REGEX) ?? [];
-      await this.options.cache.setBlob(cacheKeys.content, contents);
+
+      if (getFeatureFlag('cachePerformanceImprovements')) {
+        await this.options.cache.setLargeBlob(cacheKeys.content, contents);
+      } else {
+        await this.options.cache.setBlob(cacheKeys.content, contents);
+      }
     }
 
     if (map != null) {
-      await this.options.cache.setBlob(cacheKeys.map, map);
+      if (getFeatureFlag('cachePerformanceImprovements')) {
+        await this.options.cache.setLargeBlob(cacheKeys.map, map);
+      } else {
+        await this.options.cache.setBlob(cacheKeys.map, map);
+      }
     }
+
     let info = {
       type,
       size,
@@ -773,19 +855,29 @@ export default class PackagerRunner {
       cacheKeys,
       isLargeBlob,
     };
+
     await this.options.cache.set(cacheKeys.info, info);
     return info;
   }
 
   static getContentKey(cacheKey: string): string {
+    if (getFeatureFlag('cachePerformanceImprovements')) {
+      return `PackagerRunner/${ATLASPACK_VERSION}/${cacheKey}/content`;
+    }
     return hashString(`${cacheKey}:content`);
   }
 
   static getMapKey(cacheKey: string): string {
+    if (getFeatureFlag('cachePerformanceImprovements')) {
+      return `PackagerRunner/${ATLASPACK_VERSION}/${cacheKey}/map`;
+    }
     return hashString(`${cacheKey}:map`);
   }
 
   static getInfoKey(cacheKey: string): string {
+    if (getFeatureFlag('cachePerformanceImprovements')) {
+      return `PackagerRunner/${ATLASPACK_VERSION}/${cacheKey}/info`;
+    }
     return hashString(`${cacheKey}:info`);
   }
 }

package/src/{ReporterRunner.js → ReporterRunner.ts}

@@ -1,5 +1,3 @@
-// @flow strict-local
-
 import type {ReporterEvent, Reporter} from '@atlaspack/types';
 import type {WorkerApi} from '@atlaspack/workers';
 import type {Bundle as InternalBundle, AtlaspackOptions} from './types';
@@ -23,11 +21,11 @@ import BundleGraph from './BundleGraph';
 import {tracer, PluginTracer} from '@atlaspack/profiler';
 import {anyToDiagnostic} from '@atlaspack/diagnostic';
 
-type Opts = {|
-  options: AtlaspackOptions,
-  reporters: Array<LoadedPlugin<Reporter>>,
-  workerFarm: WorkerFarm,
-|};
+type Opts = {
+  options: AtlaspackOptions;
+  reporters: Array<LoadedPlugin<Reporter>>;
+  workerFarm: WorkerFarm;
+};
 
 const instances: Set<ReporterRunner> = new Set();
 
@@ -58,24 +56,21 @@ export default class ReporterRunner {
     }
   }
 
-  eventHandler: (ReporterEvent) => void = (event): void => {
+  eventHandler: (arg1: ReporterEvent) => void = (event): void => {
     if (
       event.type === 'buildProgress' &&
       (event.phase === 'optimizing' || event.phase === 'packaging') &&
       !(event.bundle instanceof NamedBundle)
     ) {
-      // $FlowFixMe[prop-missing]
+      // @ts-expect-error TS2339
       let bundleGraphRef = event.bundleGraphRef;
-      // $FlowFixMe[incompatible-exact]
+      // @ts-expect-error TS2739
       let bundle: InternalBundle = event.bundle;
       // Convert any internal bundles back to their public equivalents as reporting
       // is public api
-      let bundleGraph = this.workerFarm.workerApi.getSharedReference(
-        // $FlowFixMe
-        bundleGraphRef,
-      );
+      let bundleGraph =
+        this.workerFarm.workerApi.getSharedReference(bundleGraphRef);
       invariant(bundleGraph instanceof BundleGraph);
-      // $FlowFixMe[incompatible-call]
       this.report({
         ...event,
         bundle: NamedBundle.get(bundle, bundleGraph, this.options),
@@ -88,11 +83,12 @@ export default class ReporterRunner {
 
   async report(unsanitisedEvent: ReporterEvent) {
     let event: ReporterEvent = unsanitisedEvent;
+    // @ts-expect-error TS2339
     if (event.diagnostics) {
       // Sanitise input before passing to reporters
-      // $FlowFixMe too complex to narrow down by type
       event = {
         ...event,
+        // @ts-expect-error TS2322
         diagnostics: anyToDiagnostic(event.diagnostics),
       };
     }
@@ -105,7 +101,6 @@ export default class ReporterRunner {
           measurement = tracer.createMeasurement(reporter.name, 'reporter');
         }
         await reporter.plugin.report({
-          // $FlowFixMe
           event,
           options: this.pluginOptions,
           logger: new PluginLogger({origin: reporter.name}),
@@ -114,7 +109,7 @@ export default class ReporterRunner {
             category: 'reporter',
           }),
         });
-      } catch (reportError) {
+      } catch (reportError: any) {
         if (event.type !== 'buildSuccess') {
           // This will be captured by consumers
           INTERNAL_ORIGINAL_CONSOLE.error(reportError);