@atlaspack/core 2.16.2-canary.37 → 2.16.2-canary.371

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

@@ -1,4 +1,3 @@
-// @flow
 import type {
   Async,
   Config as IConfig,
@@ -7,6 +6,7 @@ import type {
   PluginTracer as IPluginTracer,
   NamedBundle as INamedBundle,
   BundleGraph as IBundleGraph,
+  TransformerSetup,
 } from '@atlaspack/types';
 import {readConfig, hashObject} from '@atlaspack/utils';
 import type {
@@ -30,52 +30,56 @@ import {PluginTracer} from '@atlaspack/profiler';
 import {requestTypes} from '../RequestTracker';
 import {fromProjectPath, fromProjectPathRelative} from '../projectPath';
 
+type Setup<T> = (arg1: {
+  config: IConfig;
+  options: IPluginOptions;
+  logger: IPluginLogger;
+  tracer: IPluginTracer;
+}) => Async<TransformerSetup<T>>;
+
 export type PluginWithLoadConfig = {
-  loadConfig?: ({|
-    config: IConfig,
-    options: IPluginOptions,
-    logger: IPluginLogger,
-    tracer: IPluginTracer,
-  |}) => Async<mixed>,
-  ...
+  loadConfig?: (arg1: {
+    config: IConfig;
+    options: IPluginOptions;
+    logger: IPluginLogger;
+    tracer: IPluginTracer;
+  }) => Async<unknown>;
 };
 
 export type PluginWithBundleConfig = {
-  loadConfig?: ({|
-    config: IConfig,
-    options: IPluginOptions,
-    logger: IPluginLogger,
-    tracer: IPluginTracer,
-  |}) => Async<mixed>,
-  loadBundleConfig?: ({|
-    bundle: INamedBundle,
-    bundleGraph: IBundleGraph<INamedBundle>,
-    config: IConfig,
-    options: IPluginOptions,
-    logger: IPluginLogger,
-    tracer: IPluginTracer,
-  |}) => Async<mixed>,
-  ...
+  loadConfig?: (arg1: {
+    config: IConfig;
+    options: IPluginOptions;
+    logger: IPluginLogger;
+    tracer: IPluginTracer;
+  }) => Async<unknown>;
+  loadBundleConfig?: (arg1: {
+    bundle: INamedBundle;
+    bundleGraph: IBundleGraph<INamedBundle>;
+    config: IConfig;
+    options: IPluginOptions;
+    logger: IPluginLogger;
+    tracer: IPluginTracer;
+  }) => Async<unknown>;
 };
 
 export type ConfigRequest = {
-  id: string,
-  invalidateOnFileChange: Set<ProjectPath>,
-  invalidateOnConfigKeyChange: Array<{|
-    filePath: ProjectPath,
-    configKey: string,
-  |}>,
-  invalidateOnFileCreate: Array<InternalFileCreateInvalidation>,
-  invalidateOnEnvChange: Set<string>,
-  invalidateOnOptionChange: Set<string>,
-  invalidateOnStartup: boolean,
-  invalidateOnBuild: boolean,
-  ...
+  id: string;
+  invalidateOnFileChange: Set<ProjectPath>;
+  invalidateOnConfigKeyChange: Array<{
+    filePath: ProjectPath;
+    configKey: string[];
+  }>;
+  invalidateOnFileCreate: Array<InternalFileCreateInvalidation>;
+  invalidateOnEnvChange: Set<string>;
+  invalidateOnOptionChange: Set<string>;
+  invalidateOnStartup: boolean;
+  invalidateOnBuild: boolean;
 };
 
-export type ConfigRequestResult = void;
+export type ConfigRequestResult = undefined;
 
-export async function loadPluginConfig<T: PluginWithLoadConfig>(
+export async function loadPluginConfig<T extends PluginWithLoadConfig>(
   loadedPlugin: LoadedPlugin<T>,
   config: Config,
   options: AtlaspackOptions,
@@ -99,7 +103,7 @@ export async function loadPluginConfig<T: PluginWithLoadConfig>(
         category: 'loadConfig',
       }),
     });
-  } catch (e) {
+  } catch (e: any) {
     throw new ThrowableDiagnostic({
       diagnostic: errorToDiagnostic(e, {
         origin: loadedPlugin.name,
@@ -108,41 +112,97 @@ export async function loadPluginConfig<T: PluginWithLoadConfig>(
   }
 }
 
+export async function loadPluginSetup<T>(
+  pluginName: string,
+  setup: Setup<T>,
+  config: Config,
+  options: AtlaspackOptions,
+): Promise<void> {
+  try {
+    let result = await setup({
+      config: new PublicConfig(config, options),
+      options: new PluginOptions(
+        optionsProxy(options, (option) => {
+          config.invalidateOnOptionChange.add(option);
+        }),
+      ),
+      logger: new PluginLogger({origin: pluginName}),
+      tracer: new PluginTracer({
+        origin: pluginName,
+        category: 'setup',
+      }),
+    });
+
+    config.result = result.config;
+  } catch (e: any) {
+    throw new ThrowableDiagnostic({
+      diagnostic: errorToDiagnostic(e, {
+        origin: pluginName,
+      }),
+    });
+  }
+}
+
+/**
+ * Return value at a given key path within an object.
+ *
+ * @example
+ *     const obj = { a: { b: { c: 'd' } } };
+ *     getValueAtPath(obj, ['a', 'b', 'c']);        // 'd'
+ *     getValueAtPath(obj, ['a', 'b', 'd']);        // undefined
+ *     getValueAtPath(obj, ['a', 'b']);             // { c: 'd' }
+ *     getValueAtPath(obj, ['a', 'b', 'c', 'd']);   // undefined
+ */
+export function getValueAtPath(obj: any, key: string[]): any {
+  let current = obj;
+  for (let part of key) {
+    if (current == null) {
+      return undefined;
+    }
+    current = current[part];
+  }
+  return current;
+}
+
 const configKeyCache = createBuildCache();
 
 export async function getConfigKeyContentHash(
   filePath: ProjectPath,
-  configKey: string,
+  configKey: string[],
   options: AtlaspackOptions,
-): Async<string> {
-  let cacheKey = `${fromProjectPathRelative(filePath)}:${configKey}`;
+): Promise<Async<string>> {
+  let cacheKey = `${fromProjectPathRelative(filePath)}:${JSON.stringify(
+    configKey,
+  )}`;
   let cachedValue = configKeyCache.get(cacheKey);
 
   if (cachedValue) {
+    // @ts-expect-error TS2322
     return cachedValue;
   }
 
-  let conf = await readConfig(
+  const conf = await readConfig(
     options.inputFS,
     fromProjectPath(options.projectRoot, filePath),
   );
 
-  if (conf == null || conf.config[configKey] == null) {
+  const value = getValueAtPath(conf?.config, configKey);
+  if (conf == null || value == null) {
     // This can occur when a config key has been removed entirely during `respondToFSEvents`
     return '';
   }
 
-  let contentHash =
-    typeof conf.config[configKey] === 'object'
-      ? hashObject(conf.config[configKey])
-      : hashString(JSON.stringify(conf.config[configKey]));
+  const contentHash =
+    typeof value === 'object'
+      ? hashObject(value)
+      : hashString(JSON.stringify(value));
 
   configKeyCache.set(cacheKey, contentHash);
 
   return contentHash;
 }
 
-export async function runConfigRequest<TResult: RequestResult>(
+export async function runConfigRequest<TResult extends RequestResult>(
   api: RunAPI<TResult>,
   configRequest: ConfigRequest,
 ) {
@@ -169,7 +229,7 @@ export async function runConfigRequest<TResult: RequestResult>(
     return;
   }
 
-  await api.runRequest<null, void>({
+  await api.runRequest<null, undefined>({
     id: 'config_request:' + configRequest.id,
     type: requestTypes.config_request,
     run: async ({api, options}) => {
@@ -240,7 +300,7 @@ export async function getConfigHash(
     } else if (config.result != null) {
       try {
         hash.writeBuffer(serializeRaw(config.result));
-      } catch (err) {
+      } catch (err: any) {
         throw new ThrowableDiagnostic({
           diagnostic: {
             message:

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,29 @@ import nullthrows from 'nullthrows';
 import {runConfigRequest} from './ConfigRequest';
 import {getDevDepRequests, runDevDepRequest} from './DevDepRequest';
 import createAtlaspackConfigRequest from './AtlaspackConfigRequest';
+import {fromEnvironmentId} from '../EnvironmentManager';
+import {getFeatureFlag} from '@atlaspack/feature-flags';
 
-type PackageRequestInput = {|
-  bundleGraph: BundleGraph,
-  bundle: Bundle,
-  bundleGraphReference: SharedReference,
-  optionsRef: SharedReference,
-  useMainThread?: boolean,
-|};
+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 +48,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,6 +61,17 @@ async function run({input, api, farm}) {
     ),
   );
 
+  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)
+    await rustAtlaspack.package();
+  }
+
   let {devDepRequests, configRequests, bundleInfo, invalidations} =
     (await runPackage({
       bundle,
@@ -70,7 +81,7 @@ async function run({input, api, farm}) {
       previousDevDeps: devDeps,
       invalidDevDeps,
       previousInvalidations: api.getInvalidations(),
-    }): RunPackagerRunnerResult);
+    })) as RunPackagerRunnerResult;
 
   for (let devDepRequest of devDepRequests) {
     await runDevDepRequest(api, devDepRequest);
@@ -93,11 +104,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);