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

package/src/atlaspack-v3/worker/{worker.js → worker.ts}

@@ -1,6 +1,6 @@
-// @flow
 import assert from 'assert';
 import * as napi from '@atlaspack/rust';
+// @ts-expect-error TS2305
 import type {JsCallable} from '@atlaspack/rust';
 import {NodeFS} from '@atlaspack/fs';
 import {NodePackageManager} from '@atlaspack/package-manager';
@@ -25,6 +25,7 @@ import {
   bundleBehaviorMap,
   dependencyPriorityMap,
 } from './compat';
+import {FeatureFlags} from '@atlaspack/feature-flags';
 
 const CONFIG = Symbol.for('parcel-plugin-config');
 
@@ -39,11 +40,10 @@ export class AtlaspackWorker {
     this.#fs = new NodeFS();
   }
 
-  loadPlugin: JsCallable<[LoadPluginOptions], Promise<void>> = jsCallable(
-    async ({kind, specifier, resolveFrom}) => {
+  loadPlugin: JsCallable<[LoadPluginOptions], Promise<undefined>> = jsCallable(
+    async ({kind, specifier, resolveFrom, featureFlags}) => {
       let customRequire = module.createRequire(resolveFrom);
       let resolvedPath = customRequire.resolve(specifier);
-      // $FlowFixMe
       let resolvedModule = await import(resolvedPath);
 
       let instance = undefined;
@@ -60,6 +60,11 @@ export class AtlaspackWorker {
           `Plugin could not be resolved\n\t${kind}\n\t${resolveFrom}\n\t${specifier}`,
         );
       }
+      // Set feature flags in the worker process
+      if (featureFlags) {
+        const {setFeatureFlags} = await import('@atlaspack/feature-flags');
+        setFeatureFlags(featureFlags);
+      }
 
       switch (kind) {
         case 'resolver':
@@ -74,7 +79,7 @@ export class AtlaspackWorker {
 
   runResolverResolve: JsCallable<
     [RunResolverResolveOptions],
-    Promise<RunResolverResolveResult>,
+    Promise<RunResolverResolveResult>
   > = jsCallable(
     async ({
       key,
@@ -110,9 +115,10 @@ export class AtlaspackWorker {
           inputFS: this.#fs,
           outputFS: this.#fs,
         }),
-      };
+      } as const;
 
       if (!('config' in state)) {
+        // @ts-expect-error TS2345
         state.config = await state.resolver.loadConfig?.({
           config: new PluginConfig({
             env,
@@ -126,6 +132,7 @@ export class AtlaspackWorker {
         });
       }
 
+      // @ts-expect-error TS2345
       const result = await state.resolver.resolve({
         specifier,
         dependency,
@@ -141,6 +148,13 @@ export class AtlaspackWorker {
         };
       }
 
+      if (result.isExcluded) {
+        return {
+          invalidations: [],
+          resolution: {type: 'excluded'},
+        };
+      }
+
       return {
         invalidations: [],
         resolution: {
@@ -159,8 +173,8 @@ export class AtlaspackWorker {
   );
 
   runTransformerTransform: JsCallable<
-    [RunTransformerTransformOptions, Buffer, ?string],
-    Promise<RunTransformerTransformResult>,
+    [RunTransformerTransformOptions, Buffer, string | null | undefined],
+    Promise<RunTransformerTransformResult>
   > = jsCallable(
     async ({key, env: napiEnv, options, asset: innerAsset}, contents, map) => {
       const state = this.#transformers.get(key);
@@ -185,6 +199,7 @@ export class AtlaspackWorker {
       const env = new Environment(napiEnv);
       const mutableAsset = new MutableAsset(
         innerAsset,
+        // @ts-expect-error TS2345
         contents,
         env,
         this.#fs,
@@ -202,8 +217,9 @@ export class AtlaspackWorker {
           inputFS: this.#fs,
           outputFS: this.#fs,
         }),
-      };
+      } as const;
 
+      // @ts-expect-error TS2345
       const config = await transformer.loadConfig?.({
         config: new PluginConfig({
           env,
@@ -218,6 +234,7 @@ export class AtlaspackWorker {
 
       if (transformer.parse) {
         const ast = await transformer.parse({
+          // @ts-expect-error TS2322
           asset: mutableAsset,
           config,
           resolve: resolveFunc,
@@ -229,6 +246,7 @@ export class AtlaspackWorker {
       }
 
       const result = await state.transformer.transform({
+        // @ts-expect-error TS2322
         asset: mutableAsset,
         config,
         resolve: resolveFunc,
@@ -238,8 +256,8 @@ export class AtlaspackWorker {
       if (transformer.generate) {
         const ast = await mutableAsset.getAST();
         if (ast) {
-          // $FlowFixMe "Cannot call `transformer.generate` because  undefined [1] is not a function." 🤷‍♀️
           const output = await transformer.generate({
+            // @ts-expect-error TS2322
             asset: mutableAsset,
             ast,
             ...defaultOptions,
@@ -250,6 +268,7 @@ export class AtlaspackWorker {
           } else if (output.content instanceof Buffer) {
             mutableAsset.setBuffer(output.content);
           } else {
+            // @ts-expect-error TS2345
             mutableAsset.setStream(output.content);
           }
 
@@ -269,6 +288,14 @@ export class AtlaspackWorker {
         '[V3] Unimplemented: New asset returned from Node transformer',
       );
 
+      let assetBuffer: Buffer | null = await mutableAsset.getBuffer();
+
+      // If the asset has no code, we set the buffer to null, which we can
+      // detect in Rust, to avoid passing back an empty buffer, which we can't.
+      if (assetBuffer.length === 0) {
+        assetBuffer = null;
+      }
+
       return [
         {
           id: mutableAsset.id,
@@ -288,10 +315,10 @@ export class AtlaspackWorker {
           type: mutableAsset.type,
           uniqueKey: mutableAsset.uniqueKey,
         },
-        await mutableAsset.getBuffer(),
+        assetBuffer,
         // Only send back the map if it has changed
         mutableAsset.isMapDirty
-          ? // $FlowFixMe A dirty map means this will be valid
+          ? // @ts-expect-error TS2533
             JSON.stringify((await mutableAsset.getMap()).toVLQ())
           : '',
       ];
@@ -304,59 +331,68 @@ const worker = new AtlaspackWorker();
 const napiWorker = napi.newNodejsWorker(worker);
 parentPort?.postMessage(napiWorker);
 
-type ResolverState<T> = {|
-  resolver: Resolver<T>,
-  config?: T,
-  packageManager?: NodePackageManager,
-|};
-
-type TransformerState<T> = {|
-  packageManager?: NodePackageManager,
-  transformer: Transformer<T>,
-|};
-
-type LoadPluginOptions = {|
-  kind: 'resolver' | 'transformer',
-  specifier: string,
-  resolveFrom: string,
-|};
-
-type RpcPluginOptions = {|
-  projectRoot: string,
-  mode: string,
-|};
-
-type RunResolverResolveOptions = {|
-  key: string,
-  dependency: napi.Dependency,
-  specifier: FilePath,
-  pipeline: ?string,
-  pluginOptions: RpcPluginOptions,
-|};
-
-type RunResolverResolveResult = {|
-  invalidations: Array<*>,
+type ResolverState<T> = {
+  resolver: Resolver<T>;
+  config?: T;
+  packageManager?: NodePackageManager;
+};
+
+type TransformerState<T> = {
+  packageManager?: NodePackageManager;
+  transformer: Transformer<T>;
+};
+
+type LoadPluginOptions = {
+  kind: 'resolver' | 'transformer';
+  specifier: string;
+  resolveFrom: string;
+  featureFlags?: FeatureFlags;
+};
+
+type RpcPluginOptions = {
+  projectRoot: string;
+  mode: string;
+};
+
+type RunResolverResolveOptions = {
+  key: string;
+  // @ts-expect-error TS2694
+  dependency: napi.Dependency;
+  specifier: FilePath;
+  pipeline: string | null | undefined;
+  pluginOptions: RpcPluginOptions;
+};
+
+type RunResolverResolveResult = {
+  invalidations: Array<any>;
   resolution:
-    | {|type: 'unresolved'|}
-    | {|type: 'excluded'|}
-    | {|
-        type: 'resolved',
-        canDefer: boolean,
-        filePath: string,
-        sideEffects: boolean,
-        code?: string,
-        meta?: mixed,
-        pipeline?: string,
-        priority?: ?number,
-        query?: string,
-      |},
-|};
-
-type RunTransformerTransformOptions = {|
-  key: string,
-  env: napi.Environment,
-  options: RpcPluginOptions,
-  asset: napi.Asset,
-|};
-
+    | {
+        type: 'unresolved';
+      }
+    | {
+        type: 'excluded';
+      }
+    | {
+        type: 'resolved';
+        canDefer: boolean;
+        filePath: string;
+        sideEffects: boolean;
+        code?: string;
+        meta?: unknown;
+        pipeline?: string;
+        priority?: number | null | undefined;
+        query?: string;
+      };
+};
+
+type RunTransformerTransformOptions = {
+  key: string;
+  // @ts-expect-error TS2724
+  env: napi.Environment;
+  options: RpcPluginOptions;
+  // @ts-expect-error TS2694
+  asset: napi.Asset;
+};
+
+// @ts-expect-error TS2694
 type RunTransformerTransformResult = [napi.RpcAssetResult, Buffer, string];

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

@@ -1,6 +1,3 @@
-// @flow strict-local
-
-// $FlowFixMe
 import {version} from '../package.json';
 
 export const ATLASPACK_VERSION = version;

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

@@ -1,5 +1,3 @@
-// @flow
-
 import type {Asset, BundleBehavior} from '@atlaspack/types';
 import type {Graph} from '@atlaspack/graph';
 import type {AssetGraphNode, BundleGraphNode, Environment} from './types';
@@ -18,7 +16,7 @@ const COLORS = {
   transformer_request: 'cyan',
   file: 'gray',
   default: 'white',
-};
+} as const;
 
 const TYPE_COLORS = {
   // bundle graph
@@ -33,16 +31,16 @@ const TYPE_COLORS = {
   invalidated_by_create_above: 'orange',
   invalidate_by_update: 'cyan',
   invalidated_by_delete: 'red',
-};
+} as const;
 
 export default async function dumpGraphToGraphViz(
   graph:
     | Graph<AssetGraphNode>
-    | Graph<{|
-        assets: Set<Asset>,
-        sourceBundles: Set<number>,
-        bundleBehavior?: ?BundleBehavior,
-      |}>
+    | Graph<{
+        assets: Set<Asset>;
+        sourceBundles: Set<number>;
+        bundleBehavior?: BundleBehavior | null | undefined;
+      }>
     | Graph<BundleGraphNode>,
   name: string,
   edgeTypes?: typeof bundleGraphEdgeTypes | typeof requestGraphEdgeTypes,
@@ -54,12 +52,12 @@ export default async function dumpGraphToGraphViz(
     return;
   }
 
-  let mode: ?string = process.env.ATLASPACK_BUILD_REPL
-    ? // $FlowFixMe
+  let mode: string | null | undefined = process.env.ATLASPACK_BUILD_REPL
+    ? // @ts-expect-error TS7017
       globalThis.ATLASPACK_DUMP_GRAPHVIZ?.mode
     : process.env.ATLASPACK_DUMP_GRAPHVIZ;
 
-  // $FlowFixMe[invalid-compare]
+  // @ts-expect-error TS2367
   if (mode == null || mode == false) {
     return;
   }
@@ -69,74 +67,96 @@ export default async function dumpGraphToGraphViz(
   let GraphVizGraph = require('graphviz/lib/deps/graph').Graph;
   let g = new GraphVizGraph(null, 'G');
   g.type = 'digraph';
-  // $FlowFixMe
   for (let [id, node] of graph.nodes.entries()) {
     if (node == null) continue;
     let n = g.addNode(nodeId(id));
-    // $FlowFixMe default is fine. Not every type needs to be in the map.
+    // @ts-expect-error TS7053
     n.set('color', COLORS[node.type || 'default']);
     n.set('shape', 'box');
     n.set('style', 'filled');
     let label;
     if (typeof node === 'string') {
       label = node;
+      // @ts-expect-error TS2339
     } else if (node.assets) {
+      // @ts-expect-error TS2339
       label = `(${nodeId(id)}), (assetIds: ${[...node.assets]
         .map((a) => {
           let arr = a.filePath.split('/');
           return arr[arr.length - 1];
         })
+        // @ts-expect-error TS2339
         .join(', ')}) (sourceBundles: ${[...node.sourceBundles].join(
         ', ',
+        // @ts-expect-error TS2339
       )}) (bb ${node.bundleBehavior ?? 'none'})`;
+      // @ts-expect-error TS2339
     } else if (node.type) {
+      // @ts-expect-error TS2339
       label = `[${fromNodeId(id)}] ${node.type || 'No Type'}: [${node.id}]: `;
+      // @ts-expect-error TS2339
       if (node.type === 'dependency') {
+        // @ts-expect-error TS2339
         label += node.value.specifier;
-        let parts = [];
+        let parts: Array<undefined | string> = [];
+        // @ts-expect-error TS2339
         if (node.value.priority !== Priority.sync) {
           parts.push(
             Object.entries(Priority).find(
-              ([, v]) => v === node.value.priority,
+              // @ts-expect-error TS2339
+              ([, v]: [any, any]) => v === node.value.priority,
             )?.[0],
           );
         }
+        // @ts-expect-error TS2339
         if (node.value.isOptional) parts.push('optional');
+        // @ts-expect-error TS2339
         if (node.value.specifierType === SpecifierType.url) parts.push('url');
+        // @ts-expect-error TS2339
         if (node.hasDeferred) parts.push('deferred');
+        // @ts-expect-error TS2339
         if (node.deferred) parts.push('deferred');
+        // @ts-expect-error TS2339
         if (node.excluded) parts.push('excluded');
         if (parts.length) label += ' (' + parts.join(', ') + ')';
+        // @ts-expect-error TS2339
         if (node.value.env) label += ` (${getEnvDescription(node.value.env)})`;
+        // @ts-expect-error TS2339
         let depSymbols = node.value.symbols;
         if (detailedSymbols) {
           if (depSymbols) {
             if (depSymbols.size) {
               label +=
                 '\\nsymbols: ' +
-                [...depSymbols].map(([e, {local}]) => [e, local]).join(';');
+                [...depSymbols]
+                  .map(([e, {local}]: [any, any]) => [e, local])
+                  .join(';');
             }
             let weakSymbols = [...depSymbols]
-              .filter(([, {isWeak}]) => isWeak)
-              .map(([s]) => s);
+              .filter(([, {isWeak}]: [any, any]) => isWeak)
+              .map(([s]: [any]) => s);
             if (weakSymbols.length) {
               label += '\\nweakSymbols: ' + weakSymbols.join(',');
             }
+            // @ts-expect-error TS2339
             if (node.usedSymbolsUp.size > 0) {
               label +=
                 '\\nusedSymbolsUp: ' +
+                // @ts-expect-error TS2339
                 [...node.usedSymbolsUp]
-                  .map(([s, sAsset]) =>
+                  .map(([s, sAsset]: [any, any]) =>
                     sAsset
                       ? `${s}(${sAsset.asset}.${sAsset.symbol ?? ''})`
                       : sAsset === null
-                      ? `${s}(external)`
-                      : `${s}(ambiguous)`,
+                        ? `${s}(external)`
+                        : `${s}(ambiguous)`,
                   )
                   .join(',');
             }
+            // @ts-expect-error TS2339
             if (node.usedSymbolsDown.size > 0) {
               label +=
+                // @ts-expect-error TS2339
                 '\\nusedSymbolsDown: ' + [...node.usedSymbolsDown].join(',');
             }
             // if (node.usedSymbolsDownDirty) label += '\\nusedSymbolsDownDirty';
@@ -147,22 +167,30 @@ export default async function dumpGraphToGraphViz(
             label += '\\nsymbols: cleared';
           }
         }
+        // @ts-expect-error TS2339
       } else if (node.type === 'asset') {
         label +=
+          // @ts-expect-error TS2339
           path.basename(fromProjectPathRelative(node.value.filePath)) +
           '#' +
+          // @ts-expect-error TS2339
           node.value.type;
         if (detailedSymbols) {
+          // @ts-expect-error TS2339
           if (!node.value.symbols) {
             label += '\\nsymbols: cleared';
+            // @ts-expect-error TS2339
           } else if (node.value.symbols.size) {
             label +=
               '\\nsymbols: ' +
+              // @ts-expect-error TS2339
               [...node.value.symbols]
-                .map(([e, {local}]) => [e, local])
+                .map(([e, {local}]: [any, any]) => [e, local])
                 .join(';');
           }
+          // @ts-expect-error TS2339
           if (node.usedSymbols.size) {
+            // @ts-expect-error TS2339
             label += '\\nusedSymbols: ' + [...node.usedSymbols].join(',');
           }
           // if (node.usedSymbolsDownDirty) label += '\\nusedSymbolsDownDirty';
@@ -170,23 +198,38 @@ export default async function dumpGraphToGraphViz(
         } else {
           label += '\\nsymbols: cleared';
         }
+        // @ts-expect-error TS2339
       } else if (node.type === 'asset_group') {
+        // @ts-expect-error TS2339
         if (node.deferred) label += '(deferred)';
+        // @ts-expect-error TS2339
       } else if (node.type === 'file') {
+        // @ts-expect-error TS2339
         label += path.basename(node.id);
+        // @ts-expect-error TS2339
       } else if (node.type === 'transformer_request') {
         label +=
+          // @ts-expect-error TS2339
           path.basename(node.value.filePath) +
+          // @ts-expect-error TS2339
           ` (${getEnvDescription(node.value.env)})`;
+        // @ts-expect-error TS2339
       } else if (node.type === 'bundle') {
-        let parts = [];
+        let parts: Array<string> = [];
+        // @ts-expect-error TS2339
         if (node.value.needsStableName) parts.push('stable name');
+        // @ts-expect-error TS2339
         parts.push(node.value.name);
+        // @ts-expect-error TS2339
         parts.push('bb:' + (node.value.bundleBehavior ?? 'null'));
+        // @ts-expect-error TS2339
         if (node.value.isPlaceholder) parts.push('placeholder');
         if (parts.length) label += ' (' + parts.join(', ') + ')';
+        // @ts-expect-error TS2339
         if (node.value.env) label += ` (${getEnvDescription(node.value.env)})`;
+        // @ts-expect-error TS2339
       } else if (node.type === 'request') {
+        // @ts-expect-error TS2339
         label = node.requestType + ':' + node.id;
       }
     }
@@ -196,14 +239,16 @@ export default async function dumpGraphToGraphViz(
   let edgeNames;
   if (edgeTypes) {
     edgeNames = Object.fromEntries(
-      Object.entries(edgeTypes).map(([k, v]) => [v, k]),
+      Object.entries(edgeTypes).map(([k, v]: [any, any]) => [v, k]),
     );
   }
 
+  // @ts-expect-error TS2488
   for (let edge of graph.getAllEdges()) {
     let gEdge = g.addEdge(nodeId(edge.from), nodeId(edge.to));
     let color = null;
     if (edge.type != 1 && edgeNames) {
+      // @ts-expect-error TS7053
       color = TYPE_COLORS[edgeNames[edge.type]];
     }
     if (color != null) {
@@ -212,7 +257,7 @@ export default async function dumpGraphToGraphViz(
   }
 
   if (process.env.ATLASPACK_BUILD_REPL) {
-    // $FlowFixMe
+    // @ts-expect-error TS7017
     globalThis.ATLASPACK_DUMP_GRAPHVIZ?.(name, g.to_dot());
   } else {
     const tempy = require('tempy');
@@ -223,8 +268,8 @@ export default async function dumpGraphToGraphViz(
   }
 }
 
-function nodeId(id) {
-  // $FlowFixMe
+// @ts-expect-error TS2552
+function nodeId(id: NodeId | number) {
   return `node${id}`;
 }
 

package/src/index.ts

@@ -0,0 +1,18 @@
+import * as EnvironmentManager from './EnvironmentManager';
+
+export {
+  default,
+  default as Atlaspack,
+  default as Parcel,
+  BuildError,
+  createWorkerFarm,
+  INTERNAL_RESOLVE,
+  INTERNAL_TRANSFORM,
+  WORKER_PATH,
+} from './Atlaspack';
+export {ATLASPACK_VERSION} from './constants';
+export {default as resolveOptions} from './resolveOptions';
+export {createEnvironment} from './Environment';
+export {default as Environment} from './public/Environment';
+export * from './atlaspack-v3';
+export {EnvironmentManager};

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

@@ -1,4 +1,3 @@
-// @flow
 import type {FilePath, PackageName, Semver} from '@atlaspack/types';
 import type {AtlaspackOptions} from './types';
 
@@ -9,7 +8,7 @@ import ThrowableDiagnostic, {
   md,
 } from '@atlaspack/diagnostic';
 import {findAlternativeNodeModules} from '@atlaspack/utils';
-import {type ProjectPath, toProjectPath} from './projectPath';
+import {ProjectPath, toProjectPath} from './projectPath';
 
 const NODE_MODULES = `${path.sep}node_modules${path.sep}`;
 const CONFIG = Symbol.for('parcel-plugin-config');
@@ -17,13 +16,13 @@ const CONFIG = Symbol.for('parcel-plugin-config');
 export default async function loadPlugin<T>(
   pluginName: PackageName,
   configPath: FilePath,
-  keyPath?: string,
+  keyPath: string | null | undefined,
   options: AtlaspackOptions,
-): Promise<{|
-  plugin: T,
-  version: Semver,
-  resolveFrom: ProjectPath,
-|}> {
+): Promise<{
+  plugin: T;
+  version: Semver;
+  resolveFrom: ProjectPath;
+}> {
   let resolveFrom = configPath;
 
   // Config packages can reference plugins, but cannot contain other plugins within them.
@@ -58,7 +57,7 @@ export default async function loadPlugin<T>(
     ({pkg} = await options.packageManager.resolve(pluginName, resolveFrom, {
       shouldAutoInstall: options.shouldAutoInstall,
     }));
-  } catch (err) {
+  } catch (err: any) {
     if (err.code !== 'MODULE_NOT_FOUND') {
       throw err;
     }

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

@@ -1,5 +1,3 @@
-// @flow strict-local
-
 import type {FileSystem} from '@atlaspack/fs';
 import type {EnvMap, FilePath} from '@atlaspack/types';
 
@@ -30,6 +28,7 @@ export default async function loadEnv(
       const envPath = await resolveConfig(
         fs,
         filePath,
+        // @ts-expect-error TS2322
         [dotenvFile],
         projectRoot,
       );
@@ -41,6 +40,7 @@ export default async function loadEnv(
       // https://github.com/motdotla/dotenv-expand/blob/ddb73d02322fe8522b4e05b73e1c1ad24ea7c14a/lib/main.js#L5
       let output = variableExpansion({
         parsed: dotenv.parse(await fs.readFile(envPath)),
+        // @ts-expect-error TS2353
         ignoreProcessEnv: true,
       });