@atlaspack/core 2.16.2-canary.21 → 2.16.2-canary.211

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

@@ -1,4 +1,3 @@
-// @flow
 import type {
   Glob,
   Transformer,
@@ -32,33 +31,33 @@ import {globToRegex} from '@atlaspack/utils';
 import {basename} from 'path';
 import loadPlugin from './loadAtlaspackPlugin';
 import {
-  type ProjectPath,
+  ProjectPath,
   fromProjectPath,
   fromProjectPathRelative,
   toProjectPathUnsafe,
 } from './projectPath';
 
-type GlobMap<T> = {[Glob]: T, ...};
-type SerializedAtlaspackConfig = {|
-  $$raw: boolean,
-  config: ProcessedAtlaspackConfig,
-  options: AtlaspackOptions,
-|};
+type GlobMap<T> = Partial<Record<Glob, T>>;
+type SerializedAtlaspackConfig = {
+  $$raw: boolean;
+  config: ProcessedAtlaspackConfig;
+  options: AtlaspackOptions;
+};
 
-export type LoadedPlugin<T> = {|
-  name: string,
-  version: Semver,
-  plugin: T,
-  resolveFrom: ProjectPath,
-  keyPath?: string,
-|};
+export type LoadedPlugin<T> = {
+  name: string;
+  version: Semver;
+  plugin: T;
+  resolveFrom: ProjectPath;
+  keyPath?: string;
+};
 
 export class AtlaspackConfig {
   options: AtlaspackOptions;
   filePath: ProjectPath;
   resolvers: PureAtlaspackConfigPipeline;
   transformers: GlobMap<ExtendableAtlaspackConfigPipeline>;
-  bundler: ?AtlaspackPluginNode;
+  bundler: AtlaspackPluginNode | null | undefined;
   namers: PureAtlaspackConfigPipeline;
   runtimes: PureAtlaspackConfigPipeline;
   packagers: GlobMap<AtlaspackPluginNode>;
@@ -114,11 +113,11 @@ export class AtlaspackConfig {
     };
   }
 
-  _loadPlugin<T>(node: AtlaspackPluginNode): Promise<{|
-    plugin: T,
-    version: Semver,
-    resolveFrom: ProjectPath,
-  |}> {
+  _loadPlugin<T>(node: AtlaspackPluginNode): Promise<{
+    plugin: T;
+    version: Semver;
+    resolveFrom: ProjectPath;
+  }> {
     let plugin = this.pluginCache.get(node.packageName);
     if (plugin) {
       return plugin;
@@ -137,6 +136,7 @@ export class AtlaspackConfig {
 
   async loadPlugin<T>(node: AtlaspackPluginNode): Promise<LoadedPlugin<T>> {
     let plugin = await this._loadPlugin(node);
+    // @ts-expect-error TS2322
     return {
       ...plugin,
       name: node.packageName,
@@ -154,7 +154,7 @@ export class AtlaspackConfig {
     return Promise.all(plugins.map((p) => this.loadPlugin<T>(p)));
   }
 
-  async getResolvers(): Promise<Array<LoadedPlugin<Resolver<mixed>>>> {
+  async getResolvers(): Promise<Array<LoadedPlugin<Resolver<unknown>>>> {
     if (this.resolvers.length === 0) {
       throw await this.missingPluginError(
         this.resolvers,
@@ -163,12 +163,12 @@ export class AtlaspackConfig {
       );
     }
 
-    return this.loadPlugins<Resolver<mixed>>(this.resolvers);
+    return this.loadPlugins<Resolver<unknown>>(this.resolvers);
   }
 
   _getValidatorNodes(
     filePath: ProjectPath,
-  ): $ReadOnlyArray<AtlaspackPluginNode> {
+  ): ReadonlyArray<AtlaspackPluginNode> {
     let validators: PureAtlaspackConfigPipeline =
       this.matchGlobMapPipelines(filePath, this.validators) || [];
 
@@ -188,7 +188,7 @@ export class AtlaspackConfig {
     return this.loadPlugins<Validator>(validators);
   }
 
-  getNamedPipelines(): $ReadOnlyArray<string> {
+  getNamedPipelines(): ReadonlyArray<string> {
     return Object.keys(this.transformers)
       .filter((glob) => glob.includes(':'))
       .map((glob) => glob.split(':')[0]);
@@ -196,9 +196,9 @@ export class AtlaspackConfig {
 
   async getTransformers(
     filePath: ProjectPath,
-    pipeline?: ?string,
+    pipeline?: string | null,
     allowEmpty?: boolean,
-  ): Promise<Array<LoadedPlugin<Transformer<mixed>>>> {
+  ): Promise<Array<LoadedPlugin<Transformer<unknown>>>> {
     let transformers: PureAtlaspackConfigPipeline | null =
       this.matchGlobMapPipelines(filePath, this.transformers, pipeline);
     if (!transformers || transformers.length === 0) {
@@ -215,10 +215,10 @@ export class AtlaspackConfig {
       );
     }
 
-    return this.loadPlugins<Transformer<mixed>>(transformers);
+    return this.loadPlugins<Transformer<unknown>>(transformers);
   }
 
-  async getBundler(): Promise<LoadedPlugin<Bundler<mixed>>> {
+  async getBundler(): Promise<LoadedPlugin<Bundler<unknown>>> {
     if (!this.bundler) {
       throw await this.missingPluginError(
         [],
@@ -227,10 +227,10 @@ export class AtlaspackConfig {
       );
     }
 
-    return this.loadPlugin<Bundler<mixed>>(this.bundler);
+    return this.loadPlugin<Bundler<unknown>>(this.bundler);
   }
 
-  async getNamers(): Promise<Array<LoadedPlugin<Namer<mixed>>>> {
+  async getNamers(): Promise<Array<LoadedPlugin<Namer<unknown>>>> {
     if (this.namers.length === 0) {
       throw await this.missingPluginError(
         this.namers,
@@ -239,20 +239,20 @@ export class AtlaspackConfig {
       );
     }
 
-    return this.loadPlugins<Namer<mixed>>(this.namers);
+    return this.loadPlugins<Namer<unknown>>(this.namers);
   }
 
-  getRuntimes(): Promise<Array<LoadedPlugin<Runtime<mixed>>>> {
+  getRuntimes(): Promise<Array<LoadedPlugin<Runtime<unknown>>>> {
     if (!this.runtimes) {
       return Promise.resolve([]);
     }
 
-    return this.loadPlugins<Runtime<mixed>>(this.runtimes);
+    return this.loadPlugins<Runtime<unknown>>(this.runtimes);
   }
 
   async getPackager(
     filePath: FilePath,
-  ): Promise<LoadedPlugin<Packager<mixed, mixed>>> {
+  ): Promise<LoadedPlugin<Packager<unknown, unknown>>> {
     let packager = this.matchGlobMap(
       toProjectPathUnsafe(filePath),
       this.packagers,
@@ -264,12 +264,12 @@ export class AtlaspackConfig {
         '/packagers',
       );
     }
-    return this.loadPlugin<Packager<mixed, mixed>>(packager);
+    return this.loadPlugin<Packager<unknown, unknown>>(packager);
   }
 
   _getOptimizerNodes(
     filePath: FilePath,
-    pipeline: ?string,
+    pipeline?: string | null,
   ): PureAtlaspackConfigPipeline {
     // If a pipeline is specified, but it doesn't exist in the optimizers config, ignore it.
     // Pipelines for bundles come from their entry assets, so the pipeline likely exists in transformers.
@@ -291,21 +291,24 @@ export class AtlaspackConfig {
     );
   }
 
-  getOptimizerNames(filePath: FilePath, pipeline: ?string): Array<string> {
+  getOptimizerNames(
+    filePath: FilePath,
+    pipeline?: string | null,
+  ): Array<string> {
     let optimizers = this._getOptimizerNodes(filePath, pipeline);
     return optimizers.map((o) => o.packageName);
   }
 
   getOptimizers(
     filePath: FilePath,
-    pipeline: ?string,
-  ): Promise<Array<LoadedPlugin<Optimizer<mixed, mixed>>>> {
+    pipeline?: string | null,
+  ): Promise<Array<LoadedPlugin<Optimizer<unknown, unknown>>>> {
     let optimizers = this._getOptimizerNodes(filePath, pipeline);
     if (optimizers.length === 0) {
       return Promise.resolve([]);
     }
 
-    return this.loadPlugins<Optimizer<mixed, mixed>>(optimizers);
+    return this.loadPlugins<Optimizer<unknown, unknown>>(optimizers);
   }
 
   async getCompressors(
@@ -335,7 +338,7 @@ export class AtlaspackConfig {
   isGlobMatch(
     projectPath: ProjectPath,
     pattern: Glob,
-    pipeline?: ?string,
+    pipeline?: string | null,
   ): boolean {
     // glob's shouldn't be dependant on absolute paths anyway
     let filePath = fromProjectPathRelative(projectPath);
@@ -343,6 +346,7 @@ export class AtlaspackConfig {
     let [patternPipeline, patternGlob] = pattern.split(':');
     if (!patternGlob) {
       patternGlob = patternPipeline;
+      // @ts-expect-error TS2322
       patternPipeline = null;
     }
 
@@ -358,7 +362,10 @@ export class AtlaspackConfig {
     );
   }
 
-  matchGlobMap<T>(filePath: ProjectPath, globMap: {|[Glob]: T|}): ?T {
+  matchGlobMap<T>(
+    filePath: ProjectPath,
+    globMap: Partial<Record<Glob, T>>,
+  ): T | null | undefined {
     for (let pattern in globMap) {
       if (this.isGlobMatch(filePath, pattern)) {
         return globMap[pattern];
@@ -370,10 +377,10 @@ export class AtlaspackConfig {
 
   matchGlobMapPipelines(
     filePath: ProjectPath,
-    globMap: {|[Glob]: ExtendableAtlaspackConfigPipeline|},
-    pipeline?: ?string,
+    globMap: Partial<Record<Glob, ExtendableAtlaspackConfigPipeline>>,
+    pipeline?: string | null,
   ): PureAtlaspackConfigPipeline {
-    let matches = [];
+    let matches: Array<ExtendableAtlaspackConfigPipeline> = [];
     if (pipeline) {
       // If a pipeline is requested, a the glob needs to match exactly
       let exactMatch;
@@ -392,6 +399,7 @@ export class AtlaspackConfig {
 
     for (let pattern in globMap) {
       if (this.isGlobMatch(filePath, pattern)) {
+        // @ts-expect-error TS2345
         matches.push(globMap[pattern]);
       }
     }
@@ -417,7 +425,7 @@ export class AtlaspackConfig {
     };
 
     let res = flatten();
-    // $FlowFixMe afaik this should work
+    // @ts-expect-error TS2322
     return res;
   }
 
@@ -435,9 +443,12 @@ export class AtlaspackConfig {
     } else {
       configsWithPlugin = new Set(
         Object.keys(plugins).flatMap((k) =>
+          // @ts-expect-error TS7053
           Array.isArray(plugins[k])
-            ? getConfigPaths(this.options, plugins[k])
-            : [getConfigPath(this.options, plugins[k])],
+            ? // @ts-expect-error TS7053
+              getConfigPaths(this.options, plugins[k])
+            : // @ts-expect-error TS7053
+              [getConfigPath(this.options, plugins[k])],
         ),
       );
     }
@@ -478,12 +489,25 @@ export class AtlaspackConfig {
   }
 }
 
-function getConfigPaths(options, nodes) {
-  return nodes
-    .map((node) => (node !== '...' ? getConfigPath(options, node) : null))
-    .filter(Boolean);
+function getConfigPaths(
+  options: AtlaspackOptions,
+  nodes:
+    | AtlaspackPluginNode
+    | PureAtlaspackConfigPipeline
+    | ExtendableAtlaspackConfigPipeline,
+) {
+  return (
+    nodes
+      // @ts-expect-error TS2339
+      .map((node) => (node !== '...' ? getConfigPath(options, node) : null))
+      .filter(Boolean)
+  );
 }
 
-function getConfigPath(options, node) {
+function getConfigPath(
+  options: AtlaspackOptions,
+  node: AtlaspackPluginNode | ExtendableAtlaspackConfigPipeline,
+) {
+  // @ts-expect-error TS2339
   return fromProjectPath(options.projectRoot, node.resolveFrom);
 }