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

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';
 
@@ -48,12 +46,13 @@ import UncommittedAsset from './UncommittedAsset';
 import {createAsset} from './assetUtils';
 import summarizeRequest from './summarizeRequest';
 import PluginOptions from './public/PluginOptions';
+import {fromEnvironmentId} from './EnvironmentManager';
 import {optionsProxy} from './utils';
 import {createConfig} from './InternalConfig';
 import {
   loadPluginConfig,
   getConfigRequests,
-  type ConfigRequest,
+  ConfigRequest,
 } from './requests/ConfigRequest';
 import {
   createDevDependency,
@@ -61,7 +60,7 @@ import {
   getWorkerDevDepRequests,
 } from './requests/DevDepRequest';
 import {
-  type ProjectPath,
+  ProjectPath,
   fromProjectPath,
   fromProjectPathRelative,
   toProjectPathUnsafe,
@@ -70,27 +69,28 @@ import {
 import {invalidateOnFileCreateToInternal, createInvalidations} from './utils';
 import invariant from 'assert';
 import {tracer, PluginTracer} from '@atlaspack/profiler';
+import {getFeatureFlag} from '@atlaspack/feature-flags';
 
 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>;
+};
 
 export default class Transformation {
   request: TransformationRequest;
@@ -140,7 +140,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 +165,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 +177,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 +187,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 +200,8 @@ export default class Transformation {
       ...this.resolverRunner.devDepRequests.values(),
     ]);
 
-    // $FlowFixMe because of $$raw
     return {
+      // @ts-expect-error TS2353
       $$raw: true,
       assets,
       configRequests,
@@ -224,6 +227,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 +238,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 +332,7 @@ export default class Transformation {
           range,
         },
       );
-    } catch (err) {
+    } catch (err: any) {
       // ignore
     }
 
@@ -347,8 +354,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 +406,7 @@ export default class Transformation {
               ),
             );
           }
-        } catch (e) {
+        } catch (e: any) {
           let diagnostic = errorToDiagnostic(e, {
             origin: transformer.name,
             filePath: fromProjectPath(
@@ -466,7 +473,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 +509,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,9 +536,9 @@ export default class Transformation {
   }
 
   async loadTransformerConfig(
-    transformer: LoadedPlugin<Transformer<mixed>>,
+    transformer: LoadedPlugin<Transformer<unknown>>,
     isSource: boolean,
-  ): Promise<?Config> {
+  ): Promise<Config | null | undefined> {
     let loadConfig = transformer.plugin.loadConfig;
     if (!loadConfig) {
       return;
@@ -540,6 +547,7 @@ export default class Transformation {
     let config = createConfig({
       plugin: transformer.name,
       isSource,
+      // @ts-expect-error TS2322
       searchPath: this.request.filePath,
       env: this.request.env,
     });
@@ -556,12 +564,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 +611,7 @@ export default class Transformation {
         throw new ThrowableDiagnostic({diagnostic: result.diagnostics});
       }
 
+      // @ts-expect-error TS2322
       return fromProjectPath(
         this.options.projectRoot,
         nullthrows(result.assetGroup).filePath,
@@ -649,8 +658,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 +721,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,
@@ -30,31 +28,37 @@ import {ATLASPACK_VERSION} from './constants';
 import {createAsset, createAssetIdFromOptions} from './assetUtils';
 import {BundleBehaviorNames} from './types';
 import {invalidateOnFileCreateToInternal, createInvalidations} from './utils';
-import {type ProjectPath, fromProjectPath} from './projectPath';
-
-type UncommittedAssetOptions = {|
-  value: Asset,
-  options: AtlaspackOptions,
-  content?: ?Blob,
-  mapBuffer?: ?Buffer,
-  ast?: ?AST,
-  isASTDirty?: ?boolean,
-  code?: ?string,
-  invalidations?: Invalidations,
-|};
+import {
+  ProjectPath,
+  fromProjectPath,
+  fromProjectPathRelative,
+} from './projectPath';
+import {getFeatureFlag} from '@atlaspack/feature-flags';
+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,
@@ -120,9 +124,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: ''};
@@ -134,7 +139,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;
           }),
@@ -153,7 +159,9 @@ export default class UncommittedAsset {
       size = content.length;
     }
 
+    // Maybe we should just store this in a file instead of LMDB
     await this.options.cache.setBlob(contentKey, content);
+
     return {size, hash};
   }
 
@@ -168,6 +176,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();
     }
@@ -185,6 +194,7 @@ export default class UncommittedAsset {
       return Buffer.from(content);
     }
 
+    // @ts-expect-error TS2345
     this.content = bufferStream(content);
     return this.content;
   }
@@ -214,12 +224,15 @@ export default class UncommittedAsset {
     this.clearAST();
   }
 
+  /**
+   * @deprecated This has been broken on any cache other than FSCache for a long time.
+   */
   setStream(stream: Readable) {
     this.content = stream;
     this.clearAST();
   }
 
-  async loadExistingSourcemap(): Promise<?SourceMap> {
+  async loadExistingSourcemap(): Promise<SourceMap | null | undefined> {
     if (this.map) {
       return this.map;
     }
@@ -243,11 +256,11 @@ export default class UncommittedAsset {
     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) {
@@ -259,14 +272,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;
@@ -276,7 +288,7 @@ export default class UncommittedAsset {
     this.mapBuffer = this.map?.toBuffer();
   }
 
-  getAST(): Promise<?AST> {
+  getAST(): Promise<AST | null | undefined> {
     return Promise.resolve(this.ast);
   }
 
@@ -296,6 +308,11 @@ 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);
   }
 
@@ -304,9 +321,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,
@@ -371,7 +392,7 @@ export default class UncommittedAsset {
         isSource: this.value.isSource,
         env: mergeEnvironments(
           this.options.projectRoot,
-          this.value.env,
+          fromEnvironmentId(this.value.env),
           result.env,
         ),
         dependencies:
@@ -389,7 +410,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,
@@ -420,7 +441,7 @@ export default class UncommittedAsset {
   }
 
   updateId() {
-    // $FlowFixMe - this is fine
+    // @ts-expect-error TS2345
     this.value.id = createAssetIdFromOptions(this.value);
   }
 }

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

@@ -1,5 +1,3 @@
-// @flow strict-local
-
 import type {WorkerApi} from '@atlaspack/workers';
 import type {AssetGroup, AtlaspackOptions, ReportFn} from './types';
 import type {Validator, ValidateResult} from '@atlaspack/types';
@@ -18,29 +16,34 @@ import summarizeRequest from './summarizeRequest';
 import {fromProjectPath, fromProjectPathRelative} from './projectPath';
 import {PluginTracer} from '@atlaspack/profiler';
 
-export type ValidationOpts = {|
-  config: AtlaspackConfig,
+export type ValidationOpts = {
+  config: AtlaspackConfig;
   /**
    * If true, this Validation instance will run all validators that implement the single-threaded "validateAll" method.
    * If falsy, it will run validators that implement the one-asset-at-a-time "validate" method.
    */
-  dedicatedThread?: boolean,
-  options: AtlaspackOptions,
-  requests: AssetGroup[],
-  report: ReportFn,
-  workerApi?: WorkerApi,
-|};
+  dedicatedThread?: boolean;
+  options: AtlaspackOptions;
+  requests: AssetGroup[];
+  report: ReportFn;
+  workerApi?: WorkerApi;
+};
 
 export default class Validation {
-  allAssets: {[validatorName: string]: UncommittedAsset[], ...} = {};
-  allValidators: {[validatorName: string]: Validator, ...} = {};
+  allAssets: {
+    [validatorName: string]: UncommittedAsset[];
+  } = {};
+  allValidators: {
+    [validatorName: string]: Validator;
+  } = {};
   dedicatedThread: boolean;
-  impactfulOptions: $Shape<AtlaspackOptions>;
+  // @ts-expect-error TS2564
+  impactfulOptions: Partial<AtlaspackOptions>;
   options: AtlaspackOptions;
   atlaspackConfig: AtlaspackConfig;
   report: ReportFn;
   requests: AssetGroup[];
-  workerApi: ?WorkerApi;
+  workerApi: WorkerApi | null | undefined;
 
   constructor({
     config,
@@ -71,10 +74,12 @@ export default class Validation {
             origin: validatorName,
             category: 'validator',
           });
-          let validatorResults: Array<?ValidateResult> = [];
+          let validatorResults: Array<ValidateResult | null | undefined> = [];
           try {
             // If the plugin supports the single-threading validateAll method, pass all assets to it.
+            // @ts-expect-error TS2339
             if (plugin.validateAll && this.dedicatedThread) {
+              // @ts-expect-error TS2339
               validatorResults = await plugin.validateAll({
                 assets: assets.map((asset) => new Asset(asset)),
                 options: pluginOptions,
@@ -94,12 +99,15 @@ export default class Validation {
             }
 
             // Otherwise, pass the assets one-at-a-time
+            // @ts-expect-error TS2339
             else if (plugin.validate && !this.dedicatedThread) {
               await Promise.all(
                 assets.map(async (input) => {
                   let config = null;
                   let publicAsset = new Asset(input);
+                  // @ts-expect-error TS2339
                   if (plugin.getConfig) {
+                    // @ts-expect-error TS2339
                     config = await plugin.getConfig({
                       asset: publicAsset,
                       options: pluginOptions,
@@ -115,6 +123,7 @@ export default class Validation {
                     });
                   }
 
+                  // @ts-expect-error TS2339
                   let validatorResult = await plugin.validate({
                     asset: publicAsset,
                     options: pluginOptions,
@@ -127,7 +136,7 @@ export default class Validation {
               );
             }
             this.handleResults(validatorResults);
-          } catch (e) {
+          } catch (e: any) {
             throw new ThrowableDiagnostic({
               diagnostic: errorToDiagnostic(e, {
                 origin: validatorName,
@@ -145,12 +154,14 @@ export default class Validation {
       this.requests.map(async (request) => {
         this.report({
           type: 'validation',
+          // @ts-expect-error TS2322
           filePath: fromProjectPath(this.options.projectRoot, request.filePath),
         });
 
         let asset = await this.loadAsset(request);
 
         let validators = await this.atlaspackConfig.getValidators(
+          // @ts-expect-error TS2345
           request.filePath,
         );
 
@@ -166,7 +177,7 @@ export default class Validation {
     );
   }
 
-  handleResults(validatorResults: Array<?ValidateResult>) {
+  handleResults(validatorResults: Array<ValidateResult | null | undefined>) {
     let warnings: Array<Diagnostic> = [];
     let errors: Array<Diagnostic> = [];
     validatorResults.forEach((result) => {
@@ -192,6 +203,7 @@ export default class Validation {
     let {content, size, isSource} = await summarizeRequest(
       this.options.inputFS,
       {
+        // @ts-expect-error TS2322
         filePath: fromProjectPath(this.options.projectRoot, request.filePath),
       },
     );
@@ -199,10 +211,13 @@ export default class Validation {
     return new UncommittedAsset({
       value: createAsset(this.options.projectRoot, {
         code,
+        // @ts-expect-error TS2322
         filePath: filePath,
         isSource,
+        // @ts-expect-error TS2345
         type: path.extname(fromProjectPathRelative(filePath)).slice(1),
         query,
+        // @ts-expect-error TS2322
         env: env,
         stats: {
           time: 0,