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

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

@@ -1,5 +1,3 @@
-// @flow strict-local
-
 import type {
   FilePath,
   GenerateOutput,
@@ -31,7 +29,7 @@ import ThrowableDiagnostic, {
   errorToDiagnostic,
   escapeMarkdown,
   md,
-  type Diagnostic,
+  Diagnostic,
 } from '@atlaspack/diagnostic';
 import {SOURCEMAP_EXTENSIONS} from '@atlaspack/utils';
 
@@ -53,7 +51,8 @@ import {createConfig} from './InternalConfig';
 import {
   loadPluginConfig,
   getConfigRequests,
-  type ConfigRequest,
+  ConfigRequest,
+  loadPluginSetup,
 } from './requests/ConfigRequest';
 import {
   createDevDependency,
@@ -61,7 +60,7 @@ import {
   getWorkerDevDepRequests,
 } from './requests/DevDepRequest';
 import {
-  type ProjectPath,
+  ProjectPath,
   fromProjectPath,
   fromProjectPathRelative,
   toProjectPathUnsafe,
@@ -70,27 +69,34 @@ import {
 import {invalidateOnFileCreateToInternal, createInvalidations} from './utils';
 import invariant from 'assert';
 import {tracer, PluginTracer} from '@atlaspack/profiler';
+import SourceMap from '@atlaspack/source-map';
+import {getFeatureFlag} from '@atlaspack/feature-flags';
+import {createBuildCache} from '@atlaspack/build-cache';
 
 type GenerateFunc = (input: UncommittedAsset) => Promise<GenerateOutput>;
 
 type PostProcessFunc = (
-  Array<UncommittedAsset>,
+  arg1: Array<UncommittedAsset>,
 ) => Promise<Array<UncommittedAsset> | null>;
 
-export type TransformationOpts = {|
-  options: AtlaspackOptions,
-  config: AtlaspackConfig,
-  request: TransformationRequest,
-  workerApi: WorkerApi,
-|};
-
-export type TransformationResult = {|
-  assets?: Array<AssetValue>,
-  error?: Array<Diagnostic>,
-  configRequests: Array<ConfigRequest>,
-  invalidations: Invalidations,
-  devDepRequests: Array<DevDepRequest | DevDepRequestRef>,
-|};
+export type TransformationOpts = {
+  options: AtlaspackOptions;
+  config: AtlaspackConfig;
+  request: TransformationRequest;
+  workerApi: WorkerApi;
+};
+
+export type TransformationResult = {
+  assets?: Array<AssetValue>;
+  error?: Array<Diagnostic>;
+  configRequests: Array<ConfigRequest>;
+  invalidations: Invalidations;
+  devDepRequests: Array<DevDepRequest | DevDepRequestRef>;
+};
+
+// Global setup config are not file-specific, so we only need to
+// load them once per build.
+const setupConfig = createBuildCache<string, Config>();
 
 export default class Transformation {
   request: TransformationRequest;
@@ -140,7 +146,7 @@ export default class Transformation {
       // Load existing sourcemaps, this automatically runs the source contents extraction
       try {
         existing = await asset.loadExistingSourcemap();
-      } catch (err) {
+      } catch (err: any) {
         logger.verbose([
           {
             origin: '@atlaspack/core',
@@ -165,7 +171,9 @@ export default class Transformation {
       // If no existing sourcemap was found, initialize asset.sourceContent
       // with the original contents. This will be used when the transformer
       // calls setMap to ensure the source content is in the sourcemap.
-      asset.sourceContent = await asset.getCode();
+      if (!getFeatureFlag('omitSourcesContentInMemory')) {
+        asset.sourceContent = await asset.getCode();
+      }
     }
 
     invalidateDevDeps(
@@ -175,6 +183,7 @@ export default class Transformation {
     );
 
     let pipeline = await this.loadPipeline(
+      // @ts-expect-error TS2345
       this.request.filePath,
       asset.value.isSource,
       asset.value.pipeline,
@@ -184,7 +193,7 @@ export default class Transformation {
       let results = await this.runPipelines(pipeline, asset);
       await Promise.all(results.map((asset) => asset.commit()));
       assets = results.map((a) => a.value);
-    } catch (e) {
+    } catch (e: any) {
       error = e;
     }
 
@@ -197,8 +206,8 @@ export default class Transformation {
       ...this.resolverRunner.devDepRequests.values(),
     ]);
 
-    // $FlowFixMe because of $$raw
     return {
+      // @ts-expect-error TS2353
       $$raw: true,
       assets,
       configRequests,
@@ -224,6 +233,7 @@ export default class Transformation {
       size,
       isSource: summarizedIsSource,
     } = await summarizeRequest(this.options.inputFS, {
+      // @ts-expect-error TS2322
       filePath: fromProjectPath(this.options.projectRoot, filePath),
       code,
     });
@@ -234,10 +244,13 @@ export default class Transformation {
     return new UncommittedAsset({
       value: createAsset(this.options.projectRoot, {
         code,
+        // @ts-expect-error TS2322
         filePath,
         isSource,
+        // @ts-expect-error TS2345
         type: path.extname(fromProjectPathRelative(filePath)).slice(1),
         pipeline,
+        // @ts-expect-error TS2322
         env,
         query,
         stats: {
@@ -325,7 +338,7 @@ export default class Transformation {
           range,
         },
       );
-    } catch (err) {
+    } catch (err: any) {
       // ignore
     }
 
@@ -347,8 +360,8 @@ export default class Transformation {
 
     let initialType = initialAsset.value.type;
     let inputAssets = [initialAsset];
-    let resultingAssets = [];
-    let finalAssets = [];
+    let resultingAssets: Array<UncommittedAsset> = [];
+    let finalAssets: Array<UncommittedAsset> = [];
     for (let transformer of pipeline.transformers) {
       resultingAssets = [];
       for (let asset of inputAssets) {
@@ -399,7 +412,7 @@ export default class Transformation {
               ),
             );
           }
-        } catch (e) {
+        } catch (e: any) {
           let diagnostic = errorToDiagnostic(e, {
             origin: transformer.name,
             filePath: fromProjectPath(
@@ -453,7 +466,7 @@ export default class Transformation {
           if (asset.isASTDirty && asset.generate) {
             let output = await asset.generate();
             asset.content = output.content;
-            asset.mapBuffer = output.map?.toBuffer();
+            asset.mapBuffer = SourceMap.safeToBuffer(output.map);
           }
 
           asset.clearAST();
@@ -466,7 +479,7 @@ export default class Transformation {
   async loadPipeline(
     filePath: ProjectPath,
     isSource: boolean,
-    pipeline: ?string,
+    pipeline?: string | null,
   ): Promise<Pipeline> {
     let transformers = await this.atlaspackConfig.getTransformers(
       filePath,
@@ -502,13 +515,13 @@ export default class Transformation {
     newType,
     newPipeline,
     currentPipeline,
-  }: {|
-    filePath: ProjectPath,
-    isSource: boolean,
-    newType: string,
-    newPipeline: ?string,
-    currentPipeline: Pipeline,
-  |}): Promise<?Pipeline> {
+  }: {
+    filePath: ProjectPath;
+    isSource: boolean;
+    newType: string;
+    newPipeline: string | null | undefined;
+    currentPipeline: Pipeline;
+  }): Promise<Pipeline | null | undefined> {
     let filePathRelative = fromProjectPathRelative(filePath);
     let nextFilePath = toProjectPathUnsafe(
       filePathRelative.slice(0, -path.extname(filePathRelative).length) +
@@ -529,17 +542,48 @@ export default class Transformation {
   }
 
   async loadTransformerConfig(
-    transformer: LoadedPlugin<Transformer<mixed>>,
+    transformer: LoadedPlugin<Transformer<unknown>>,
     isSource: boolean,
-  ): Promise<?Config> {
+  ): Promise<Config | null | undefined> {
+    // Only load setup config for a transformer once per build.
+    let config = setupConfig.get(transformer.name);
+
+    if (config == null && transformer.plugin.setup != null) {
+      config = createConfig({
+        plugin: transformer.name,
+        searchPath: toProjectPathUnsafe('index'),
+        // Consider project setup config as source
+        isSource: true,
+      });
+
+      await loadPluginSetup(
+        transformer.name,
+        transformer.plugin.setup,
+        config,
+        this.options,
+      );
+
+      setupConfig.set(transformer.name, config);
+    }
+
+    if (config != null) {
+      for (let devDep of config.devDeps) {
+        await this.addDevDependency(devDep);
+      }
+
+      // `loadConfig` is not called for setup configs
+      return config;
+    }
+
     let loadConfig = transformer.plugin.loadConfig;
     if (!loadConfig) {
       return;
     }
 
-    let config = createConfig({
+    config = createConfig({
       plugin: transformer.name,
       isSource,
+      // @ts-expect-error TS2322
       searchPath: this.request.filePath,
       env: this.request.env,
     });
@@ -556,12 +600,12 @@ export default class Transformation {
   async runTransformer(
     pipeline: Pipeline,
     asset: UncommittedAsset,
-    transformer: Transformer<mixed>,
+    transformer: Transformer<unknown>,
     transformerName: string,
-    preloadedConfig: ?Config,
-    configKeyPath?: string,
+    preloadedConfig: Config | null | undefined,
+    configKeyPath: string | null | undefined,
     atlaspackConfig: AtlaspackConfig,
-  ): Promise<$ReadOnlyArray<TransformerResult | UncommittedAsset>> {
+  ): Promise<ReadonlyArray<TransformerResult | UncommittedAsset>> {
     const logger = new PluginLogger({origin: transformerName});
     const tracer = new PluginTracer({
       origin: transformerName,
@@ -603,6 +647,7 @@ export default class Transformation {
         throw new ThrowableDiagnostic({diagnostic: result.diagnostics});
       }
 
+      // @ts-expect-error TS2322
       return fromProjectPath(
         this.options.projectRoot,
         nullthrows(result.assetGroup).filePath,
@@ -625,7 +670,7 @@ export default class Transformation {
     ) {
       let output = await asset.generate();
       asset.content = output.content;
-      asset.mapBuffer = output.map?.toBuffer();
+      asset.mapBuffer = SourceMap.safeToBuffer(output.map);
     }
 
     // Load config for the transformer.
@@ -649,8 +694,8 @@ export default class Transformation {
     }
 
     // Transform.
+    // @ts-expect-error TS2322
     let transfomerResult: Array<TransformerResult | MutableAsset> =
-      // $FlowFixMe the returned IMutableAsset really is a MutableAsset
       await transformer.transform({
         asset: new MutableAsset(asset),
         config,
@@ -712,27 +757,27 @@ export default class Transformation {
   }
 }
 
-type Pipeline = {|
-  id: string,
-  transformers: Array<TransformerWithNameAndConfig>,
-  options: AtlaspackOptions,
-  pluginOptions: PluginOptions,
-  workerApi: WorkerApi,
-  postProcess?: PostProcessFunc,
-  generate?: GenerateFunc,
-|};
-
-type TransformerWithNameAndConfig = {|
-  name: PackageName,
-  plugin: Transformer<mixed>,
-  config: ?Config,
-  configKeyPath?: string,
-  resolveFrom: ProjectPath,
-  range?: ?SemverRange,
-|};
+type Pipeline = {
+  id: string;
+  transformers: Array<TransformerWithNameAndConfig>;
+  options: AtlaspackOptions;
+  pluginOptions: PluginOptions;
+  workerApi: WorkerApi;
+  postProcess?: PostProcessFunc;
+  generate?: GenerateFunc;
+};
+
+type TransformerWithNameAndConfig = {
+  name: PackageName;
+  plugin: Transformer<unknown>;
+  config: Config | null | undefined;
+  configKeyPath?: string;
+  resolveFrom: ProjectPath;
+  range?: SemverRange | null | undefined;
+};
 
 function normalizeAssets(
-  options,
+  options: AtlaspackOptions,
   results: Array<TransformerResult | MutableAsset>,
 ): Array<TransformerResult | UncommittedAsset> {
   return results.map((result) => {

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

@@ -1,5 +1,3 @@
-// @flow strict-local
-
 import type {
   AST,
   Blob,
@@ -13,7 +11,7 @@ import type {Asset, Dependency, AtlaspackOptions, Invalidations} from './types';
 
 import invariant from 'assert';
 import {Readable} from 'stream';
-import SourceMap from '@parcel/source-map';
+import SourceMap from '@atlaspack/source-map';
 import {serializeRaw} from '@atlaspack/build-cache';
 import {
   blobToStream,
@@ -30,36 +28,32 @@ import {ATLASPACK_VERSION} from './constants';
 import {createAsset, createAssetIdFromOptions} from './assetUtils';
 import {BundleBehaviorNames} from './types';
 import {invalidateOnFileCreateToInternal, createInvalidations} from './utils';
-import {
-  type ProjectPath,
-  fromProjectPath,
-  fromProjectPathRelative,
-} from './projectPath';
-import {getFeatureFlag} from '@atlaspack/feature-flags';
-
-type UncommittedAssetOptions = {|
-  value: Asset,
-  options: AtlaspackOptions,
-  content?: ?Blob,
-  mapBuffer?: ?Buffer,
-  ast?: ?AST,
-  isASTDirty?: ?boolean,
-  code?: ?string,
-  invalidations?: Invalidations,
-|};
+import {ProjectPath, fromProjectPath} from './projectPath';
+import {fromEnvironmentId} from './EnvironmentManager';
+
+type UncommittedAssetOptions = {
+  value: Asset;
+  options: AtlaspackOptions;
+  content?: Blob | null | undefined;
+  mapBuffer?: Buffer | null | undefined;
+  ast?: AST | null | undefined;
+  isASTDirty?: boolean | null | undefined;
+  code?: string | null | undefined;
+  invalidations?: Invalidations;
+};
 
 export default class UncommittedAsset {
   value: Asset;
   options: AtlaspackOptions;
-  content: ?(Blob | Promise<Buffer>);
-  mapBuffer: ?Buffer;
-  sourceContent: ?string;
-  map: ?SourceMap;
-  ast: ?AST;
+  content: Blob | Promise<Buffer> | null | undefined;
+  mapBuffer: Buffer | null | undefined;
+  sourceContent: string | null | undefined;
+  map: SourceMap | null | undefined;
+  ast: AST | null | undefined;
   isASTDirty: boolean;
-  code: ?string;
+  code: string | null | undefined;
   invalidations: Invalidations;
-  generate: ?() => Promise<GenerateOutput>;
+  generate: (() => Promise<GenerateOutput>) | null | undefined;
 
   constructor({
     value,
@@ -125,9 +119,10 @@ export default class UncommittedAsset {
     this.value.committed = true;
   }
 
-  async commitContent(
-    contentKey: string,
-  ): Promise<{|size: number, hash: string|}> {
+  async commitContent(contentKey: string): Promise<{
+    size: number;
+    hash: string;
+  }> {
     let content = await this.content;
     if (content == null) {
       return {size: 0, hash: ''};
@@ -139,7 +134,8 @@ export default class UncommittedAsset {
       await this.options.cache.setStream(
         contentKey,
         content.pipe(
-          new TapStream((buf) => {
+          // @ts-expect-error TS2554
+          new TapStream((buf: Buffer) => {
             hash.writeBuffer(buf);
             size += buf.length;
           }),
@@ -175,6 +171,7 @@ export default class UncommittedAsset {
     if (typeof content === 'string' || content instanceof Buffer) {
       return content.toString();
     } else if (content != null) {
+      // @ts-expect-error TS2345
       this.content = bufferStream(content);
       return (await this.content).toString();
     }
@@ -192,6 +189,7 @@ export default class UncommittedAsset {
       return Buffer.from(content);
     }
 
+    // @ts-expect-error TS2345
     this.content = bufferStream(content);
     return this.content;
   }
@@ -229,7 +227,7 @@ export default class UncommittedAsset {
     this.clearAST();
   }
 
-  async loadExistingSourcemap(): Promise<?SourceMap> {
+  async loadExistingSourcemap(): Promise<SourceMap | null | undefined> {
     if (this.map) {
       return this.map;
     }
@@ -246,18 +244,18 @@ export default class UncommittedAsset {
 
     if (map) {
       this.map = map;
-      this.mapBuffer = map.toBuffer();
+      this.mapBuffer = SourceMap.safeToBuffer(map);
       this.setCode(code.replace(SOURCEMAP_RE, ''));
     }
 
     return this.map;
   }
 
-  getMapBuffer(): Promise<?Buffer> {
+  getMapBuffer(): Promise<Buffer | null | undefined> {
     return Promise.resolve(this.mapBuffer);
   }
 
-  async getMap(): Promise<?SourceMap> {
+  async getMap(): Promise<SourceMap | null | undefined> {
     if (this.map == null) {
       let mapBuffer = this.mapBuffer ?? (await this.getMapBuffer());
       if (mapBuffer) {
@@ -269,14 +267,13 @@ export default class UncommittedAsset {
     return this.map;
   }
 
-  setMap(map: ?SourceMap): void {
+  setMap(map?: SourceMap | null): void {
     // If we have sourceContent available, it means this asset is source code without
     // a previous source map. Ensure that the map set by the transformer has the original
     // source content available.
     if (map != null && this.sourceContent != null) {
       map.setSourceContent(
         fromProjectPath(this.options.projectRoot, this.value.filePath),
-        // $FlowFixMe
         this.sourceContent,
       );
       this.sourceContent = null;
@@ -286,7 +283,7 @@ export default class UncommittedAsset {
     this.mapBuffer = this.map?.toBuffer();
   }
 
-  getAST(): Promise<?AST> {
+  getAST(): Promise<AST | null | undefined> {
     return Promise.resolve(this.ast);
   }
 
@@ -306,11 +303,6 @@ export default class UncommittedAsset {
   }
 
   getCacheKey(key: string): string {
-    if (getFeatureFlag('cachePerformanceImprovements')) {
-      const filePath = fromProjectPathRelative(this.value.filePath);
-      return `Asset/${ATLASPACK_VERSION}/${filePath}/${this.value.id}/${key}`;
-    }
-
     return hashString(ATLASPACK_VERSION + key + this.value.id);
   }
 
@@ -319,9 +311,13 @@ export default class UncommittedAsset {
     let {env, symbols, ...rest} = opts;
     let dep = createDependency(this.options.projectRoot, {
       ...rest,
-      // $FlowFixMe "convert" the $ReadOnlyMaps to the interal mutable one
+      // @ts-expect-error TS2322
       symbols,
-      env: mergeEnvironments(this.options.projectRoot, this.value.env, env),
+      env: mergeEnvironments(
+        this.options.projectRoot,
+        fromEnvironmentId(this.value.env),
+        env,
+      ),
       sourceAssetId: this.value.id,
       sourcePath: fromProjectPath(
         this.options.projectRoot,
@@ -386,7 +382,7 @@ export default class UncommittedAsset {
         isSource: this.value.isSource,
         env: mergeEnvironments(
           this.options.projectRoot,
-          this.value.env,
+          fromEnvironmentId(this.value.env),
           result.env,
         ),
         dependencies:
@@ -404,7 +400,7 @@ export default class UncommittedAsset {
           time: 0,
           size: this.value.stats.size,
         },
-        // $FlowFixMe
+        // @ts-expect-error TS2322
         symbols: result.symbols,
         sideEffects: result.sideEffects ?? this.value.sideEffects,
         uniqueKey: result.uniqueKey,
@@ -419,7 +415,7 @@ export default class UncommittedAsset {
       content,
       ast: result.ast,
       isASTDirty: result.ast === this.ast ? this.isASTDirty : true,
-      mapBuffer: result.map ? result.map.toBuffer() : null,
+      mapBuffer: SourceMap.safeToBuffer(result.map),
       code: this.code,
       invalidations: this.invalidations,
     });
@@ -435,7 +431,7 @@ export default class UncommittedAsset {
   }
 
   updateId() {
-    // $FlowFixMe - this is fine
+    // @ts-expect-error TS2345
     this.value.id = createAssetIdFromOptions(this.value);
   }
 }