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

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,
       });
 

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

@@ -1,4 +1,3 @@
-// @flow strict-local
 import type {FilePath} from '@atlaspack/types';
 import path from 'path';
 import {relativePath, normalizeSeparators} from '@atlaspack/utils';
@@ -7,7 +6,7 @@ import {getFeatureFlagValue} from '@atlaspack/feature-flags';
 /**
  * A path that's relative to the project root.
  */
-export opaque type ProjectPath = string;
+export type ProjectPath = string;
 
 /**
  * Converts a file path to a project-relative path.
@@ -46,15 +45,24 @@ function toProjectPath_(projectRoot: FilePath, p: FilePath): ProjectPath {
   return relative;
 }
 
+// @ts-expect-error TS2322
 export const toProjectPath: ((
   projectRoot: FilePath,
   p: FilePath,
 ) => ProjectPath) &
-  ((projectRoot: FilePath, p: FilePath | void) => ProjectPath | void) &
-  // $FlowFixMe Not sure how to type properly
-  ((projectRoot: FilePath, p: ?FilePath) => ?ProjectPath) = toProjectPath_;
-
-function fromProjectPath_(projectRoot: FilePath, p: ?ProjectPath): ?FilePath {
+  ((
+    projectRoot: FilePath,
+    p: FilePath | undefined,
+  ) => ProjectPath | undefined) &
+  ((
+    projectRoot: FilePath,
+    p?: FilePath | null | undefined,
+  ) => ProjectPath | null | undefined) = toProjectPath_;
+
+function fromProjectPath_(
+  projectRoot: FilePath,
+  p?: ProjectPath | null,
+): FilePath | null | undefined {
   if (p == null) {
     return null;
   }
@@ -76,12 +84,15 @@ function fromProjectPath_(projectRoot: FilePath, p: ?ProjectPath): ?FilePath {
   return projectRoot + projectPath;
 }
 
+// @ts-expect-error TS2322
 export const fromProjectPath: ((
   projectRoot: FilePath,
   p: ProjectPath,
 ) => FilePath) &
-  // $FlowFixMe Not sure how to type properly
-  ((projectRoot: FilePath, p: ?ProjectPath) => ?FilePath) = fromProjectPath_;
+  ((
+    projectRoot: FilePath,
+    p?: ProjectPath | null | undefined,
+  ) => FilePath | null | undefined) = fromProjectPath_;
 
 /**
  * Returns a path relative to the project root. This should be used when computing cache keys

package/src/public/{Asset.js → Asset.ts}

@@ -1,5 +1,3 @@
-// @flow strict-local
-
 import type SourceMap from '@parcel/source-map';
 import type {Readable} from 'stream';
 import type {FileSystem} from '@atlaspack/fs';
@@ -36,6 +34,7 @@ import {
   BundleBehaviorNames,
 } from '../types';
 import {toInternalSourceLocation} from '../utils';
+import {fromEnvironmentId} from '../EnvironmentManager';
 
 const inspect = Symbol.for('nodejs.util.inspect.custom');
 
@@ -46,12 +45,12 @@ const assetValueToMutableAsset: WeakMap<AssetValue, MutableAsset> =
 
 const _assetToAssetValue: WeakMap<
   IAsset | IMutableAsset | BaseAsset,
-  AssetValue,
+  AssetValue
 > = new WeakMap();
 
 const _mutableAssetToUncommittedAsset: WeakMap<
   IMutableAsset,
-  UncommittedAsset,
+  UncommittedAsset
 > = new WeakMap();
 
 export function assetToAssetValue(asset: IAsset | IMutableAsset): AssetValue {
@@ -80,14 +79,13 @@ export function assetFromValue(
 
 class BaseAsset {
   #asset: CommittedAsset | UncommittedAsset;
-  #query /*: ?URLSearchParams */;
+  #query: URLSearchParams | null | undefined;
 
   constructor(asset: CommittedAsset | UncommittedAsset) {
     this.#asset = asset;
     _assetToAssetValue.set(this, asset.value);
   }
 
-  // $FlowFixMe[unsupported-syntax]
   [inspect](): string {
     return `Asset(${this.filePath})`;
   }
@@ -101,7 +99,10 @@ class BaseAsset {
   }
 
   get env(): IEnvironment {
-    return new Environment(this.#asset.value.env, this.#asset.options);
+    return new Environment(
+      fromEnvironmentId(this.#asset.value.env),
+      this.#asset.options,
+    );
   }
 
   get fs(): FileSystem {
@@ -126,7 +127,7 @@ class BaseAsset {
     return this.#asset.value.meta;
   }
 
-  get bundleBehavior(): ?BundleBehavior {
+  get bundleBehavior(): BundleBehavior | null | undefined {
     let bundleBehavior = this.#asset.value.bundleBehavior;
     return bundleBehavior == null ? null : BundleBehaviorNames[bundleBehavior];
   }
@@ -144,22 +145,23 @@ class BaseAsset {
   }
 
   get symbols(): IAssetSymbols {
+    // @ts-expect-error TS2322
     return new AssetSymbols(this.#asset.options, this.#asset.value);
   }
 
-  get uniqueKey(): ?string {
+  get uniqueKey(): string | null | undefined {
     return this.#asset.value.uniqueKey;
   }
 
-  get astGenerator(): ?ASTGenerator {
+  get astGenerator(): ASTGenerator | null | undefined {
     return this.#asset.value.astGenerator;
   }
 
-  get pipeline(): ?string {
+  get pipeline(): string | null | undefined {
     return this.#asset.value.pipeline;
   }
 
-  getDependencies(): $ReadOnlyArray<IDependency> {
+  getDependencies(): ReadonlyArray<IDependency> {
     return this.#asset
       .getDependencies()
       .map((dep) => getPublicDependency(dep, this.#asset.options));
@@ -177,24 +179,25 @@ class BaseAsset {
     return this.#asset.getStream();
   }
 
-  getMap(): Promise<?SourceMap> {
+  getMap(): Promise<SourceMap | null | undefined> {
     return this.#asset.getMap();
   }
 
-  getAST(): Promise<?AST> {
+  getAST(): Promise<AST | null | undefined> {
     return this.#asset.getAST();
   }
 
-  getMapBuffer(): Promise<?Buffer> {
+  getMapBuffer(): Promise<Buffer | null | undefined> {
     return this.#asset.getMapBuffer();
   }
 }
 
 export class Asset extends BaseAsset implements IAsset {
-  #asset /*: CommittedAsset | UncommittedAsset */;
-  #env /*: ?Environment */;
+  // @ts-expect-error TS2564
+  #asset: CommittedAsset | UncommittedAsset;
+  #env: Environment | null | undefined;
 
-  constructor(asset: CommittedAsset | UncommittedAsset): Asset {
+  constructor(asset: CommittedAsset | UncommittedAsset) {
     let assetValueToAsset = asset.value.committed
       ? committedAssetValueToAsset
       : uncommittedAssetValueToAsset;
@@ -210,7 +213,10 @@ export class Asset extends BaseAsset implements IAsset {
   }
 
   get env(): IEnvironment {
-    this.#env ??= new Environment(this.#asset.value.env, this.#asset.options);
+    this.#env ??= new Environment(
+      fromEnvironmentId(this.#asset.value.env),
+      this.#asset.options,
+    );
     return this.#env;
   }
 
@@ -220,9 +226,10 @@ export class Asset extends BaseAsset implements IAsset {
 }
 
 export class MutableAsset extends BaseAsset implements IMutableAsset {
-  #asset /*: UncommittedAsset */;
+  // @ts-expect-error TS2564
+  #asset: UncommittedAsset;
 
-  constructor(asset: UncommittedAsset): MutableAsset {
+  constructor(asset: UncommittedAsset) {
     let existing = assetValueToMutableAsset.get(asset.value);
     if (existing != null) {
       return existing;
@@ -235,7 +242,7 @@ export class MutableAsset extends BaseAsset implements IMutableAsset {
     return this;
   }
 
-  setMap(map: ?SourceMap): void {
+  setMap(map?: SourceMap | null): void {
     this.#asset.setMap(map);
   }
 
@@ -243,6 +250,7 @@ export class MutableAsset extends BaseAsset implements IMutableAsset {
     return this.#asset.value.type;
   }
 
+  // @ts-expect-error TS1095
   set type(type: string): void {
     if (type !== this.#asset.value.type) {
       this.#asset.value.type = type;
@@ -250,12 +258,13 @@ export class MutableAsset extends BaseAsset implements IMutableAsset {
     }
   }
 
-  get bundleBehavior(): ?BundleBehavior {
+  get bundleBehavior(): BundleBehavior | null | undefined {
     let bundleBehavior = this.#asset.value.bundleBehavior;
     return bundleBehavior == null ? null : BundleBehaviorNames[bundleBehavior];
   }
 
-  set bundleBehavior(bundleBehavior: ?BundleBehavior): void {
+  // @ts-expect-error TS1095
+  set bundleBehavior(bundleBehavior?: BundleBehavior | null): void {
     this.#asset.value.bundleBehavior = bundleBehavior
       ? BundleBehaviorMap[bundleBehavior]
       : null;
@@ -265,6 +274,7 @@ export class MutableAsset extends BaseAsset implements IMutableAsset {
     return this.#asset.value.isBundleSplittable;
   }
 
+  // @ts-expect-error TS1095
   set isBundleSplittable(isBundleSplittable: boolean): void {
     this.#asset.value.isBundleSplittable = isBundleSplittable;
   }
@@ -273,15 +283,17 @@ export class MutableAsset extends BaseAsset implements IMutableAsset {
     return this.#asset.value.sideEffects;
   }
 
+  // @ts-expect-error TS1095
   set sideEffects(sideEffects: boolean): void {
     this.#asset.value.sideEffects = sideEffects;
   }
 
-  get uniqueKey(): ?string {
+  get uniqueKey(): string | null | undefined {
     return this.#asset.value.uniqueKey;
   }
 
-  set uniqueKey(uniqueKey: ?string): void {
+  // @ts-expect-error TS1095
+  set uniqueKey(uniqueKey?: string | null): void {
     if (this.#asset.value.uniqueKey != null) {
       throw new Error(
         "Cannot change an asset's uniqueKey after it has been set.",
@@ -291,6 +303,7 @@ export class MutableAsset extends BaseAsset implements IMutableAsset {
   }
 
   get symbols(): IMutableAssetSymbols {
+    // @ts-expect-error TS2322
     return new MutableAssetSymbols(this.#asset.options, this.#asset.value);
   }
 
@@ -340,7 +353,7 @@ export class MutableAsset extends BaseAsset implements IMutableAsset {
     return this.#asset.setAST(ast);
   }
 
-  addURLDependency(url: string, opts: $Shape<DependencyOptions>): string {
+  addURLDependency(url: string, opts: Partial<DependencyOptions>): string {
     return this.addDependency({
       specifier: url,
       specifierType: 'url',