@atlaspack/core 2.16.2-canary.5 → 2.16.2-canary.500

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,38 +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 {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 = {|
-  +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 +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>;
@@ -175,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();
 
@@ -218,7 +223,7 @@ export default class PackagerRunner {
     }
   }
 
-  async loadPluginConfig<T: PluginWithBundleConfig>(
+  async loadPluginConfig<T extends PluginWithBundleConfig>(
     bundleGraph: InternalBundleGraph,
     bundle: InternalBundle,
     plugin: LoadedPlugin<T>,
@@ -229,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) {
@@ -288,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;
     }
@@ -310,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,
@@ -331,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(
@@ -339,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,
@@ -367,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 {
@@ -421,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,
@@ -469,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> {
@@ -532,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,
@@ -565,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',
     });
@@ -627,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(
@@ -637,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(
@@ -692,10 +687,14 @@ 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);
 
@@ -722,22 +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 = [];
+    // @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) {
       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 +756,20 @@ export default class PackagerRunner {
       size = buffer.byteLength;
       hash = hashBuffer(buffer);
       hashReferences = contents.match(HASH_REF_REGEX) ?? [];
+
       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 (map != null) {
       await this.options.cache.setBlob(cacheKeys.map, map);
     }
+
     let info = {
       type,
       size,
@@ -773,6 +778,7 @@ export default class PackagerRunner {
       cacheKeys,
       isLargeBlob,
     };
+
     await this.options.cache.set(cacheKeys.info, info);
     return 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);