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

package/src/requests/{PathRequest.js → PathRequest.ts}

@@ -1,4 +1,3 @@
-// @flow strict-local
 import type {Diagnostic} from '@atlaspack/diagnostic';
 import type {
   Async,
@@ -24,13 +23,14 @@ import ThrowableDiagnostic, {
   md,
 } from '@atlaspack/diagnostic';
 import {PluginLogger} from '@atlaspack/logger';
+import {getFeatureFlag} from '@atlaspack/feature-flags';
 import nullthrows from 'nullthrows';
 import path from 'path';
 import {normalizePath} from '@atlaspack/utils';
 import {report} from '../ReporterRunner';
 import {getPublicDependency} from '../public/Dependency';
 import PluginOptions from '../public/PluginOptions';
-import {AtlaspackConfig, type LoadedPlugin} from '../AtlaspackConfig';
+import {AtlaspackConfig, LoadedPlugin} from '../AtlaspackConfig';
 import createAtlaspackConfigRequest, {
   getCachedAtlaspackConfig,
 } from './AtlaspackConfigRequest';
@@ -53,24 +53,23 @@ import {
 import {tracer, PluginTracer} from '@atlaspack/profiler';
 import {requestTypes} from '../RequestTracker';
 
-export type PathRequest = {|
-  id: string,
-  +type: typeof requestTypes.path_request,
-  run: (RunOpts<PathRequestResult>) => Async<PathRequestResult>,
-  input: PathRequestInput,
-|};
+export type PathRequest = {
+  id: string;
+  readonly type: typeof requestTypes.path_request;
+  run: (arg1: RunOpts<PathRequestResult>) => Async<PathRequestResult>;
+  input: PathRequestInput;
+};
 
-export type PathRequestResult = null | void | AssetGroup;
+export type PathRequestResult = null | undefined | AssetGroup;
 
-export type PathRequestInput = {|
-  dependency: Dependency,
-  name: string,
-|};
+export type PathRequestInput = {
+  dependency: Dependency;
+  name: string;
+};
 
-type RunOpts<TResult> = {|
-  input: PathRequestInput,
-  ...StaticRunOpts<TResult>,
-|};
+type RunOpts<TResult> = {
+  input: PathRequestInput;
+} & StaticRunOpts<TResult>;
 
 const PIPELINE_REGEX = /^([a-z0-9-]+?):(.*)$/i;
 
@@ -85,8 +84,10 @@ export default function createPathRequest(
   };
 }
 
+// @ts-expect-error TS7031
 async function run({input, api, options}): Promise<PathRequestResult> {
   let configResult = nullthrows(
+    // @ts-expect-error TS2347
     await api.runRequest<null, ConfigAndCachePath>(
       createAtlaspackConfigRequest(),
     ),
@@ -138,25 +139,25 @@ async function run({input, api, options}): Promise<PathRequestResult> {
 
   if (result.diagnostics && result.diagnostics.length > 0) {
     let err = new ThrowableDiagnostic({diagnostic: result.diagnostics});
-    // $FlowFixMe[prop-missing]
+    // @ts-expect-error TS2339
     err.code = 'MODULE_NOT_FOUND';
     throw err;
   }
 }
 
-type ResolverRunnerOpts = {|
-  config: AtlaspackConfig,
-  options: AtlaspackOptions,
-  previousDevDeps: Map<string, string>,
-|};
+type ResolverRunnerOpts = {
+  config: AtlaspackConfig;
+  options: AtlaspackOptions;
+  previousDevDeps: Map<string, string>;
+};
 
-type ResolverResult = {|
-  assetGroup: ?AssetGroup,
-  invalidateOnFileCreate?: Array<FileCreateInvalidation>,
-  invalidateOnFileChange?: Array<FilePath>,
-  invalidateOnEnvChange?: Array<string>,
-  diagnostics?: Array<Diagnostic>,
-|};
+type ResolverResult = {
+  assetGroup: AssetGroup | null | undefined;
+  invalidateOnFileCreate?: Array<FileCreateInvalidation>;
+  invalidateOnFileChange?: Array<FilePath>;
+  invalidateOnEnvChange?: Array<string>;
+  diagnostics?: Array<Diagnostic>;
+};
 
 const configCache = createBuildCache();
 
@@ -180,7 +181,7 @@ export class ResolverRunner {
   async getDiagnostic(
     dependency: Dependency,
     message: string,
-  ): Async<Diagnostic> {
+  ): Promise<Async<Diagnostic>> {
     let diagnostic: Diagnostic = {
       message,
       origin: '@atlaspack/core',
@@ -208,7 +209,7 @@ export class ResolverRunner {
   }
 
   async loadConfigs(
-    resolvers: Array<LoadedPlugin<Resolver<mixed>>>,
+    resolvers: Array<LoadedPlugin<Resolver<unknown>>>,
   ): Promise<void> {
     for (let plugin of resolvers) {
       // Only load config for a plugin once per build.
@@ -219,12 +220,15 @@ export class ResolverRunner {
           searchPath: toProjectPathUnsafe('index'),
         });
 
+        // @ts-expect-error TS2345
         await loadPluginConfig(plugin, config, this.options);
         configCache.set(plugin.name, config);
+        // @ts-expect-error TS2345
         this.configs.set(plugin.name, config);
       }
 
       if (config) {
+        // @ts-expect-error TS2339
         for (let devDep of config.devDeps) {
           let devDepRequest = await createDevDependency(
             devDep,
@@ -234,15 +238,18 @@ export class ResolverRunner {
           this.runDevDepRequest(devDepRequest);
         }
 
+        // @ts-expect-error TS2345
         this.configs.set(plugin.name, config);
       }
     }
   }
 
   runDevDepRequest(devDepRequest: DevDepRequest | DevDepRequestRef) {
+    // @ts-expect-error TS2339
     if (devDepRequest.type !== 'ref') {
       let {specifier, resolveFrom} = devDepRequest;
       let key = `${specifier}:${fromProjectPathRelative(resolveFrom)}`;
+      // @ts-expect-error TS2345
       this.devDepRequests.set(key, devDepRequest);
     }
   }
@@ -284,9 +291,9 @@ export class ResolverRunner {
       specifier = path.join(this.options.projectRoot, specifier);
     }
     let diagnostics: Array<Diagnostic> = [];
-    let invalidateOnFileCreate = [];
-    let invalidateOnFileChange = [];
-    let invalidateOnEnvChange = [];
+    let invalidateOnFileCreate: Array<FileCreateInvalidation> = [];
+    let invalidateOnFileChange: Array<FilePath> = [];
+    let invalidateOnEnvChange: Array<string> = [];
     for (let resolver of resolvers) {
       let measurement;
       try {
@@ -320,6 +327,9 @@ export class ResolverRunner {
 
           if (result.priority != null) {
             dependency.priority = Priority[result.priority];
+            if (getFeatureFlag('hmrImprovements')) {
+              dependency.resolverPriority = dependency.priority;
+            }
           }
 
           if (result.invalidateOnEnvChange) {
@@ -364,7 +374,7 @@ export class ResolverRunner {
                 env: dependency.env,
                 pipeline:
                   result.pipeline === undefined
-                    ? pipeline ?? dependency.pipeline
+                    ? (pipeline ?? dependency.pipeline)
                     : result.pipeline,
                 isURL: dep.specifierType === 'url',
               },
@@ -391,7 +401,7 @@ export class ResolverRunner {
             diagnostics.push(...errorDiagnostic);
           }
         }
-      } catch (e) {
+      } catch (e: any) {
         // Add error to error map, we'll append these to the standard error if we can't resolve the asset
         let errorDiagnostic = errorToDiagnostic(e, {
           origin: resolver.name,