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

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',

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

@@ -1,5 +1,3 @@
-// @flow strict-local
-
 import type {
   Bundle as InternalBundle,
   AtlaspackOptions,
@@ -34,20 +32,21 @@ import {
 import Target from './Target';
 import {BundleBehaviorNames} from '../types';
 import {fromProjectPath} from '../projectPath';
+import {fromEnvironmentId} from '../EnvironmentManager';
 
 const inspect = Symbol.for('nodejs.util.inspect.custom');
 
 const internalBundleToBundle: DefaultWeakMap<
   AtlaspackOptions,
-  DefaultWeakMap<BundleGraph, WeakMap<InternalBundle, Bundle>>,
+  DefaultWeakMap<BundleGraph, WeakMap<InternalBundle, Bundle>>
 > = new DefaultWeakMap(() => new DefaultWeakMap(() => new WeakMap()));
 const internalBundleToNamedBundle: DefaultWeakMap<
   AtlaspackOptions,
-  DefaultWeakMap<BundleGraph, WeakMap<InternalBundle, NamedBundle>>,
+  DefaultWeakMap<BundleGraph, WeakMap<InternalBundle, NamedBundle>>
 > = new DefaultWeakMap(() => new DefaultWeakMap(() => new WeakMap()));
 const internalBundleToPackagedBundle: DefaultWeakMap<
   AtlaspackOptions,
-  DefaultWeakMap<BundleGraph, WeakMap<InternalBundle, PackagedBundle>>,
+  DefaultWeakMap<BundleGraph, WeakMap<InternalBundle, PackagedBundle>>
 > = new DefaultWeakMap(() => new DefaultWeakMap(() => new WeakMap()));
 
 // Friendly access for other modules within this package that need access
@@ -64,20 +63,19 @@ export function bundleToInternalBundleGraph(bundle: IBundle): BundleGraph {
 
 // Require this private object to be present when invoking these constructors,
 // preventing others from using them. They should use the static `get` method.
-let _private = {};
+let _private: Record<string, any> = {};
 
 export class Bundle implements IBundle {
-  #bundle /*: InternalBundle */;
-  #bundleGraph /*: BundleGraph */;
-  #options /*: AtlaspackOptions */;
+  #bundle: InternalBundle;
+  #bundleGraph: BundleGraph;
+  #options: AtlaspackOptions;
 
-  // $FlowFixMe
   [inspect]() {
     return `Bundle(${this.#bundle.id})`;
   }
 
   constructor(
-    sentinel: mixed,
+    sentinel: unknown,
     bundle: InternalBundle,
     bundleGraph: BundleGraph,
     options: AtlaspackOptions,
@@ -123,23 +121,23 @@ export class Bundle implements IBundle {
   }
 
   get env(): IEnvironment {
-    return new Environment(this.#bundle.env, this.#options);
+    return new Environment(fromEnvironmentId(this.#bundle.env), this.#options);
   }
 
-  get needsStableName(): ?boolean {
+  get needsStableName(): boolean | null | undefined {
     return this.#bundle.needsStableName;
   }
 
-  get bundleBehavior(): ?BundleBehavior {
+  get bundleBehavior(): BundleBehavior | null | undefined {
     let bundleBehavior = this.#bundle.bundleBehavior;
     return bundleBehavior != null ? BundleBehaviorNames[bundleBehavior] : null;
   }
 
-  get isSplittable(): ?boolean {
+  get isSplittable(): boolean | null | undefined {
     return this.#bundle.isSplittable;
   }
 
-  get manualSharedBundle(): ?string {
+  get manualSharedBundle(): string | null | undefined {
     return this.#bundle.manualSharedBundle;
   }
 
@@ -169,7 +167,7 @@ export class Bundle implements IBundle {
     });
   }
 
-  getMainEntry(): ?IAsset {
+  getMainEntry(): IAsset | null | undefined {
     if (this.#bundle.mainEntryId != null) {
       let assetNode = this.#bundleGraph._graph.getNodeByContentKey(
         this.#bundle.mainEntryId,
@@ -181,9 +179,10 @@ export class Bundle implements IBundle {
 
   traverse<TContext>(
     visit: GraphVisitor<BundleTraversable, TContext>,
-  ): ?TContext {
+  ): TContext | null | undefined {
     return this.#bundleGraph.traverseBundle(
       this.#bundle,
+      // @ts-expect-error TS2345
       mapVisitor((node) => {
         if (node.type === 'asset') {
           return {
@@ -203,7 +202,7 @@ export class Bundle implements IBundle {
   traverseAssets<TContext>(
     visit: GraphVisitor<IAsset, TContext>,
     startAsset?: IAsset,
-  ): ?TContext {
+  ): TContext | null | undefined {
     return this.#bundleGraph.traverseAssets(
       this.#bundle,
       mapVisitor((asset) => assetFromValue(asset, this.#options), visit),
@@ -213,12 +212,12 @@ export class Bundle implements IBundle {
 }
 
 export class NamedBundle extends Bundle implements INamedBundle {
-  #bundle /*: InternalBundle */;
-  #bundleGraph /*: BundleGraph */;
-  #options /*: AtlaspackOptions */;
+  #bundle: InternalBundle;
+  #bundleGraph: BundleGraph;
+  #options: AtlaspackOptions;
 
   constructor(
-    sentinel: mixed,
+    sentinel: unknown,
     bundle: InternalBundle,
     bundleGraph: BundleGraph,
     options: AtlaspackOptions,
@@ -267,13 +266,13 @@ export class NamedBundle extends Bundle implements INamedBundle {
 }
 
 export class PackagedBundle extends NamedBundle implements IPackagedBundle {
-  #bundle /*: InternalBundle */;
-  #bundleGraph /*: BundleGraph */;
-  #options /*: AtlaspackOptions */;
-  #bundleInfo /*: ?PackagedBundleInfo */;
+  #bundle: InternalBundle;
+  #bundleGraph: BundleGraph;
+  #options: AtlaspackOptions;
+  #bundleInfo: PackagedBundleInfo | null | undefined;
 
   constructor(
-    sentinel: mixed,
+    sentinel: unknown,
     bundle: InternalBundle,
     bundleGraph: BundleGraph,
     options: AtlaspackOptions,
@@ -314,7 +313,7 @@ export class PackagedBundle extends NamedBundle implements IPackagedBundle {
     internalBundle: InternalBundle,
     bundleGraph: BundleGraph,
     options: AtlaspackOptions,
-    bundleInfo: ?PackagedBundleInfo,
+    bundleInfo?: PackagedBundleInfo | null,
   ): PackagedBundle {
     let packagedBundle = PackagedBundle.get(
       internalBundle,