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

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

@@ -1,4 +1,3 @@
-// @flow
 import type {
   DependencySpecifier,
   SemverRange,
@@ -57,7 +56,7 @@ export async function createDevDependency(
   // Ensure that the package manager has an entry for this resolution.
   try {
     await options.packageManager.resolve(specifier, resolveFromAbsolute);
-  } catch (err) {
+  } catch (err: any) {
     // ignore
   }
 
@@ -103,49 +102,68 @@ export async function createDevDependency(
   return devDepRequest;
 }
 
-export type DevDepSpecifier = {|
-  specifier: DependencySpecifier,
-  resolveFrom: ProjectPath,
-|};
+export type DevDepSpecifier = {
+  specifier: DependencySpecifier;
+  resolveFrom: ProjectPath;
+};
 
-type DevDepRequests = {|
-  devDeps: Map<string, string>,
-  invalidDevDeps: Array<DevDepSpecifier>,
-|};
+type DevDepRequests = {
+  devDeps: Map<string, string>;
+  invalidDevDeps: Array<DevDepSpecifier>;
+};
 
-export async function getDevDepRequests<TResult: RequestResult>(
+export async function getDevDepRequests<TResult extends RequestResult>(
   api: RunAPI<TResult>,
 ): Promise<DevDepRequests> {
-  let previousDevDepRequests: Map<string, DevDepRequestResult> = new Map(
-    await Promise.all(
+  async function getPreviousDevDepRequests() {
+    const allDevDepRequests = await Promise.all(
       api
         .getSubRequests()
         .filter((req) => req.requestType === requestTypes.dev_dep_request)
-        .map(async (req) => [
-          req.id,
-          nullthrows(await api.getRequestResult<DevDepRequestResult>(req.id)),
-        ]),
-    ),
-  );
+        .map(
+          async (
+            req,
+          ): Promise<[string, DevDepRequestResult | null | undefined]> => [
+            req.id,
+            await api.getRequestResult<DevDepRequestResult>(req.id),
+          ],
+        ),
+    );
+    const nonNullDevDepRequests: Array<Array<string | DevDepRequestResult>> =
+      [];
+    for (const [id, result] of allDevDepRequests) {
+      if (result != null) {
+        nonNullDevDepRequests.push([id, result]);
+      }
+    }
+
+    // @ts-expect-error TS2769
+    return new Map(nonNullDevDepRequests);
+  }
+
+  const previousDevDepRequests = await getPreviousDevDepRequests();
 
   return {
     devDeps: new Map(
       [...previousDevDepRequests.entries()]
-        .filter(([id]) => api.canSkipSubrequest(id))
-        .map(([, req]: [string, DevDepRequestResult]) => [
+        // @ts-expect-error TS2769
+        .filter(([id]: [any]) => api.canSkipSubrequest(id))
+        .map(([, req]: [any, any]) => [
           `${req.specifier}:${fromProjectPathRelative(req.resolveFrom)}`,
           req.hash,
         ]),
     ),
     invalidDevDeps: await Promise.all(
       [...previousDevDepRequests.entries()]
-        .filter(([id]) => !api.canSkipSubrequest(id))
-        .flatMap(([, req]: [string, DevDepRequestResult]) => {
+        // @ts-expect-error TS2769
+        .filter(([id]: [any]) => !api.canSkipSubrequest(id))
+        .flatMap(([, req]: [any, any]) => {
           return [
             {
               specifier: req.specifier,
               resolveFrom: req.resolveFrom,
             },
+            // @ts-expect-error TS7006
             ...(req.additionalInvalidations ?? []).map((i) => ({
               specifier: i.specifier,
               resolveFrom: i.resolveFrom,
@@ -178,22 +196,25 @@ export function invalidateDevDeps(
   }
 }
 
-export type DevDepRequestResult = {|
-  specifier: DependencySpecifier,
-  resolveFrom: ProjectPath,
-  hash: string,
-  additionalInvalidations: void | Array<{|
-    range?: ?SemverRange,
-    resolveFrom: ProjectPath,
-    specifier: DependencySpecifier,
-  |}>,
-|};
+export type DevDepRequestResult = {
+  specifier: DependencySpecifier;
+  resolveFrom: ProjectPath;
+  hash: string;
+  additionalInvalidations:
+    | undefined
+    | Array<{
+        range?: SemverRange | null | undefined;
+        resolveFrom: ProjectPath;
+        specifier: DependencySpecifier;
+      }>;
+};
 
 const devDepRequests: Map<string, DevDepRequest> = createBuildCache();
 export function resolveDevDepRequestRef(
   devDepRequestRef: DevDepRequest | DevDepRequestRef,
 ): DevDepRequest {
   const devDepRequest =
+    // @ts-expect-error TS2339
     devDepRequestRef.type === 'ref'
       ? devDepRequests.get(devDepRequestRef.hash)
       : devDepRequestRef;
@@ -213,24 +234,28 @@ This is a bug in Atlaspack.`,
     );
   }
 
+  // @ts-expect-error TS2339
   if (devDepRequestRef.type !== 'ref') {
+    // @ts-expect-error TS2345
     devDepRequests.set(devDepRequest.hash, devDepRequest);
   }
 
+  // @ts-expect-error TS2322
   return devDepRequest;
 }
 
-export async function runDevDepRequest<TResult: RequestResult>(
+export async function runDevDepRequest<TResult extends RequestResult>(
   api: RunAPI<TResult>,
   devDepRequestRef: DevDepRequest | DevDepRequestRef,
 ) {
-  await api.runRequest<null, DevDepRequestResult | void>({
+  await api.runRequest<null, DevDepRequestResult | undefined>({
     id:
       'dev_dep_request:' +
       devDepRequestRef.specifier +
       ':' +
       devDepRequestRef.hash,
     type: requestTypes.dev_dep_request,
+    // @ts-expect-error TS2322
     run: ({api}) => {
       const devDepRequest = resolveDevDepRequestRef(devDepRequestRef);
 

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

@@ -1,5 +1,3 @@
-// @flow strict-local
-
 import type {Async, FilePath, PackageJSON, Glob} from '@atlaspack/types';
 import type {StaticRunOpts} from '../RequestTracker';
 import type {Entry, InternalFile, AtlaspackOptions} from '../types';
@@ -17,32 +15,31 @@ import ThrowableDiagnostic, {
   getJSONSourceLocation,
 } from '@atlaspack/diagnostic';
 import path from 'path';
-import {parse, type Mapping} from '@mischnic/json-sourcemap';
+import {parse, Mapping} from '@mischnic/json-sourcemap';
 import {requestTypes} from '../RequestTracker';
 import {
-  type ProjectPath,
+  ProjectPath,
   fromProjectPath,
   fromProjectPathRelative,
   toProjectPath,
 } from '../projectPath';
 
-type RunOpts<TResult> = {|
-  input: ProjectPath,
-  ...StaticRunOpts<TResult>,
-|};
+type RunOpts<TResult> = {
+  input: ProjectPath;
+} & StaticRunOpts<TResult>;
 
-export type EntryRequest = {|
-  id: string,
-  +type: typeof requestTypes.entry_request,
-  run: (RunOpts<EntryRequestResult>) => Async<EntryRequestResult>,
-  input: ProjectPath,
-|};
+export type EntryRequest = {
+  id: string;
+  readonly type: typeof requestTypes.entry_request;
+  run: (arg1: RunOpts<EntryRequestResult>) => Async<EntryRequestResult>;
+  input: ProjectPath;
+};
 
-export type EntryRequestResult = {|
-  entries: Array<Entry>,
-  files: Array<InternalFile>,
-  globs: Array<Glob>,
-|};
+export type EntryRequestResult = {
+  entries: Array<Entry>;
+  files: Array<InternalFile>;
+  globs: Array<Glob>;
+};
 
 const type = 'entry_request';
 
@@ -55,6 +52,7 @@ export default function createEntryRequest(input: ProjectPath): EntryRequest {
   };
 }
 
+// @ts-expect-error TS7031
 async function run({input, api, options}): Promise<EntryRequestResult> {
   let entryResolver = new EntryResolver(options);
   let filePath = fromProjectPath(options.projectRoot, input);
@@ -97,7 +95,7 @@ async function assertFile(
   let stat;
   try {
     stat = await fs.stat(source);
-  } catch (err) {
+  } catch (err: any) {
     let contents = await fs.readFile(pkgFilePath, 'utf8');
     let alternatives = await findAlternativeFiles(
       fs,
@@ -161,7 +159,7 @@ export class EntryResolver {
     let stat;
     try {
       stat = await this.options.inputFS.stat(entry);
-    } catch (err) {
+    } catch (err: any) {
       if (!isGlob(entry)) {
         throw new ThrowableDiagnostic({
           diagnostic: {
@@ -191,13 +189,13 @@ export class EntryResolver {
 
       if (pkg) {
         let {filePath} = pkg;
-        let entries = [];
+        let entries: Array<Entry> = [];
         let files = [
           {
             filePath: toProjectPath(this.options.projectRoot, filePath),
           },
         ];
-        let globs = [];
+        let globs: Array<Glob> = [];
 
         let targetsWithSources = 0;
         if (pkg.targets) {
@@ -348,23 +346,30 @@ export class EntryResolver {
     });
   }
 
-  async readPackage(entry: FilePath): Promise<?{
-    ...PackageJSON,
-    filePath: FilePath,
-    map: {|data: mixed, pointers: {|[string]: Mapping|}|},
-    ...
-  }> {
+  async readPackage(entry: FilePath): Promise<
+    | (PackageJSON & {
+        filePath: FilePath;
+        map: {
+          data: unknown;
+          pointers: {
+            [key: string]: Mapping;
+          };
+        };
+      })
+    | null
+    | undefined
+  > {
     let content, pkg;
     let pkgFile = path.join(entry, 'package.json');
     try {
       content = await this.options.inputFS.readFile(pkgFile, 'utf8');
-    } catch (err) {
+    } catch (err: any) {
       return null;
     }
 
     try {
       pkg = JSON.parse(content);
-    } catch (err) {
+    } catch (err: any) {
       // TODO: code frame?
       throw new ThrowableDiagnostic({
         diagnostic: {

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

@@ -1,5 +1,3 @@
-// @flow strict-local
-
 import type {ContentKey} from '@atlaspack/graph';
 import type {Async} from '@atlaspack/types';
 import type {SharedReference} from '@atlaspack/workers';
@@ -15,28 +13,31 @@ import nullthrows from 'nullthrows';
 import {runConfigRequest} from './ConfigRequest';
 import {getDevDepRequests, runDevDepRequest} from './DevDepRequest';
 import createAtlaspackConfigRequest from './AtlaspackConfigRequest';
-
-type PackageRequestInput = {|
-  bundleGraph: BundleGraph,
-  bundle: Bundle,
-  bundleGraphReference: SharedReference,
-  optionsRef: SharedReference,
-  useMainThread?: boolean,
-|};
+import {fromEnvironmentId} from '../EnvironmentManager';
+import {getFeatureFlag} from '@atlaspack/feature-flags';
+import logger from '@atlaspack/logger';
+import ThrowableDiagnostic, {Diagnostic} from '@atlaspack/diagnostic';
+
+type PackageRequestInput = {
+  bundleGraph: BundleGraph;
+  bundle: Bundle;
+  bundleGraphReference: SharedReference;
+  optionsRef: SharedReference;
+  useMainThread?: boolean;
+};
 
 export type PackageRequestResult = BundleInfo;
 
-type RunInput<TResult> = {|
-  input: PackageRequestInput,
-  ...StaticRunOpts<TResult>,
-|};
+type RunInput<TResult> = {
+  input: PackageRequestInput;
+} & StaticRunOpts<TResult>;
 
-export type PackageRequest = {|
-  id: ContentKey,
-  +type: typeof requestTypes.package_request,
-  run: (RunInput<BundleInfo>) => Async<BundleInfo>,
-  input: PackageRequestInput,
-|};
+export type PackageRequest = {
+  id: ContentKey;
+  readonly type: typeof requestTypes.package_request;
+  run: (arg1: RunInput<BundleInfo>) => Async<BundleInfo>;
+  input: PackageRequestInput;
+};
 
 export function createPackageRequest(
   input: PackageRequestInput,
@@ -49,8 +50,9 @@ export function createPackageRequest(
   };
 }
 
-async function run({input, api, farm}) {
+async function run({input, api, farm, rustAtlaspack}: RunInput<BundleInfo>) {
   let {bundleGraphReference, optionsRef, bundle, useMainThread} = input;
+
   let runPackage = farm.createHandle('runPackage', useMainThread);
 
   let start = Date.now();
@@ -61,8 +63,29 @@ async function run({input, api, farm}) {
     ),
   );
 
-  let {devDepRequests, configRequests, bundleInfo, invalidations} =
-    (await runPackage({
+  let packagingResult: RunPackagerRunnerResult;
+  if (
+    getFeatureFlag('nativePackager') &&
+    getFeatureFlag('nativePackagerSSRDev') &&
+    rustAtlaspack &&
+    fromEnvironmentId(bundle.env).context === 'tesseract' &&
+    bundle.type === 'js'
+  ) {
+    // Once this actually does something, the code below will be in an `else` block (i.e. we'll only run one or the other)
+    let result = await rustAtlaspack.package(bundle.id, {inlineRequires: true});
+    let error: Diagnostic | null = null;
+    [packagingResult, error] = result;
+    if (error) {
+      throw new ThrowableDiagnostic({
+        diagnostic: error,
+      });
+    }
+    logger.verbose({
+      message: JSON.stringify(packagingResult, null, 2),
+      origin: '@atlaspack/core',
+    });
+  } else {
+    packagingResult = (await runPackage({
       bundle,
       bundleGraphReference,
       optionsRef,
@@ -70,8 +93,11 @@ async function run({input, api, farm}) {
       previousDevDeps: devDeps,
       invalidDevDeps,
       previousInvalidations: api.getInvalidations(),
-    }): RunPackagerRunnerResult);
+    })) as RunPackagerRunnerResult;
+  }
 
+  let {devDepRequests, configRequests, bundleInfo, invalidations} =
+    packagingResult;
   for (let devDepRequest of devDepRequests) {
     await runDevDepRequest(api, devDepRequest);
   }
@@ -93,11 +119,12 @@ async function run({input, api, farm}) {
         api.invalidateOnOptionChange(invalidation.key);
         break;
       default:
+        // @ts-expect-error TS2339
         throw new Error(`Unknown invalidation type: ${invalidation.type}`);
     }
   }
 
-  // $FlowFixMe[cannot-write] time is marked read-only, but this is the exception
+  // @ts-expect-error TS2540
   bundleInfo.time = Date.now() - start;
 
   api.storeResult(bundleInfo);

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,