@atlaspack/core 2.16.2-canary.48 → 2.16.2-canary.481

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

@@ -1,5 +1,3 @@
-// @flow strict-local
-
 import type {
   Blob,
   FilePath,
@@ -9,7 +7,7 @@ import type {
   NamedBundle as NamedBundleType,
   Async,
 } from '@atlaspack/types';
-import type SourceMap from '@parcel/source-map';
+import type SourceMap from '@atlaspack/source-map';
 import type {
   Bundle as InternalBundle,
   Config,
@@ -26,13 +24,12 @@ 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';
 import nullthrows from 'nullthrows';
 import path from 'path';
-import url from 'url';
 import {hashString, hashBuffer, Hash} from '@atlaspack/rust';
 
 import {NamedBundle, bundleToInternalBundle} from './public/Bundle';
@@ -53,7 +50,7 @@ import {
   loadPluginConfig,
   getConfigHash,
   getConfigRequests,
-  type PluginWithBundleConfig,
+  PluginWithBundleConfig,
 } from './requests/ConfigRequest';
 import {
   createDevDependency,
@@ -62,39 +59,44 @@ import {
 import {getInvalidationId, getInvalidationHash} from './assetUtils';
 import {optionsProxy} from './utils';
 import {invalidateDevDeps} from './requests/DevDepRequest';
+import {computeSourceMapRoot} from './requests/WriteBundleRequest';
 import {tracer, PluginTracer} from '@atlaspack/profiler';
-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,
-|};
+import {fromEnvironmentId} from './EnvironmentManager';
+
+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;
 
@@ -106,7 +108,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>;
@@ -176,10 +180,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();
 
@@ -219,7 +223,7 @@ export default class PackagerRunner {
     }
   }
 
-  async loadPluginConfig<T: PluginWithBundleConfig>(
+  async loadPluginConfig<T extends PluginWithBundleConfig>(
     bundleGraph: InternalBundleGraph,
     bundle: InternalBundle,
     plugin: LoadedPlugin<T>,
@@ -230,6 +234,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) {
@@ -289,7 +294,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;
     }
@@ -311,7 +316,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,
@@ -332,7 +337,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(
@@ -340,11 +351,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,
@@ -368,11 +380,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 {
@@ -422,24 +443,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,
@@ -470,7 +493,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> {
@@ -533,7 +556,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,
@@ -566,53 +589,24 @@ export default class PackagerRunner {
     bundle: InternalBundle,
     map: SourceMap,
   ): Promise<string> {
-    // sourceRoot should be a relative path between outDir and rootDir for node.js targets
+    let sourceRoot = computeSourceMapRoot(bundle, this.options);
+    let inlineSources = sourceRoot === undefined;
+
     let filePath = joinProjectPath(
       bundle.target.distDir,
       nullthrows(bundle.name),
     );
     let fullPath = fromProjectPath(this.options.projectRoot, filePath);
-    let sourceRoot: string = path.relative(
-      path.dirname(fullPath),
-      this.options.projectRoot,
-    );
-    let inlineSources = false;
-
-    if (bundle.target) {
-      if (
-        bundle.env.sourceMap &&
-        bundle.env.sourceMap.sourceRoot !== undefined
-      ) {
-        sourceRoot = bundle.env.sourceMap.sourceRoot;
-      } else if (
-        this.options.serveOptions &&
-        bundle.target.env.context === 'browser'
-      ) {
-        sourceRoot = '/__parcel_source_root';
-      }
-
-      if (
-        bundle.env.sourceMap &&
-        bundle.env.sourceMap.inlineSources !== undefined
-      ) {
-        inlineSources = bundle.env.sourceMap.inlineSources;
-      } else if (bundle.target.env.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;
+
+    const bundleEnv = fromEnvironmentId(bundle.env);
+    let isInlineMap = bundleEnv.sourceMap && bundleEnv.sourceMap.inline;
 
     let stringified = await map.stringify({
       file: path.basename(mapFilename),
-      // $FlowFixMe
       fs: this.options.inputFS,
       rootDir: this.options.projectRoot,
-      sourceRoot: !inlineSources
-        ? url.format(url.parse(sourceRoot + '/'))
-        : undefined,
+      sourceRoot,
       inlineSources,
       format: isInlineMap ? 'inline' : 'string',
     });
@@ -628,7 +622,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(
@@ -638,7 +632,7 @@ export default class PackagerRunner {
         );
       }
     }
-    let globalInfoResults = {};
+    let globalInfoResults: Record<string, any> = {};
     for (let [pluginName, config] of bundleConfigs) {
       if (config) {
         globalInfoResults[pluginName] = await getConfigHash(
@@ -659,21 +653,6 @@ 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 +
@@ -708,35 +687,32 @@ 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 = getFeatureFlag('cachePerformanceImprovements')
-      ? isLargeBlob
-      : isLargeBlob || (await this.options.cache.has(contentKey));
+    let contentExists =
+      isLargeBlob || (await this.options.cache.has(contentKey));
     if (!contentExists) {
       return null;
     }
 
-    let mapExists = getFeatureFlag('cachePerformanceImprovements')
-      ? await this.options.cache.hasLargeBlob(mapKey)
-      : await this.options.cache.has(mapKey);
+    let mapExists = await this.options.cache.has(mapKey);
 
     return {
       contents: isLargeBlob
         ? this.options.cache.getStream(contentKey)
         : blobToStream(await this.options.cache.getBlob(contentKey)),
       map: mapExists
-        ? blobToStream(
-            getFeatureFlag('cachePerformanceImprovements')
-              ? await this.options.cache.getLargeBlob(mapKey)
-              : await this.options.cache.getBlob(mapKey),
-          )
+        ? blobToStream(await this.options.cache.getBlob(mapKey))
         : null,
     };
   }
@@ -745,25 +721,25 @@ 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 = getFeatureFlag('cachePerformanceImprovements');
+    // @ts-expect-error TS2702
+    let hashReferences: RegExp.matchResult | Array<string> = [];
+    let isLargeBlob = false;
 
     // TODO: don't replace hash references in binary files??
     if (contents instanceof Readable) {
-      if (!getFeatureFlag('cachePerformanceImprovements')) {
-        isLargeBlob = true;
-      }
+      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) ?? [],
@@ -781,29 +757,17 @@ export default class PackagerRunner {
       hash = hashBuffer(buffer);
       hashReferences = contents.match(HASH_REF_REGEX) ?? [];
 
-      if (getFeatureFlag('cachePerformanceImprovements')) {
-        await this.options.cache.setLargeBlob(cacheKeys.content, buffer);
-      } else {
-        await this.options.cache.setBlob(cacheKeys.content, buffer);
-      }
+      await this.options.cache.setBlob(cacheKeys.content, buffer);
     } else {
       size = contents.length;
       hash = hashBuffer(contents);
       hashReferences = contents.toString().match(HASH_REF_REGEX) ?? [];
 
-      if (getFeatureFlag('cachePerformanceImprovements')) {
-        await this.options.cache.setLargeBlob(cacheKeys.content, contents);
-      } else {
-        await this.options.cache.setBlob(cacheKeys.content, contents);
-      }
+      await this.options.cache.setBlob(cacheKeys.content, contents);
     }
 
     if (map != null) {
-      if (getFeatureFlag('cachePerformanceImprovements')) {
-        await this.options.cache.setLargeBlob(cacheKeys.map, map);
-      } else {
-        await this.options.cache.setBlob(cacheKeys.map, map);
-      }
+      await this.options.cache.setBlob(cacheKeys.map, map);
     }
 
     let info = {
@@ -820,23 +784,14 @@ export default class PackagerRunner {
   }
 
   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);