@atlaspack/core 2.16.2-canary.5 → 2.16.2-canary.500

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,

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

@@ -1,5 +1,3 @@
-// @flow strict-local
-
 import type {
   Asset as IAsset,
   Bundle as IBundle,
@@ -10,9 +8,9 @@ import type {
   ExportSymbolResolution,
   FilePath,
   GraphVisitor,
-  Symbol,
   NamedBundle,
   SymbolResolution,
+  Symbol,
   Target,
 } from '@atlaspack/types';
 import type {Bundle as InternalBundle, AtlaspackOptions} from '../types';
@@ -36,7 +34,7 @@ import BundleGroup, {bundleGroupToInternalBundleGroup} from './BundleGroup';
 // to the internal bundle.
 const _bundleGraphToInternalBundleGraph: WeakMap<
   IBundleGraph<IBundle>,
-  InternalBundleGraph,
+  InternalBundleGraph
 > = new WeakMap();
 export function bundleGraphToInternalBundleGraph(
   bundleGraph: IBundleGraph<IBundle>,
@@ -44,13 +42,13 @@ export function bundleGraphToInternalBundleGraph(
   return nullthrows(_bundleGraphToInternalBundleGraph.get(bundleGraph));
 }
 
-type BundleFactory<TBundle: IBundle> = (
-  InternalBundle,
-  InternalBundleGraph,
-  AtlaspackOptions,
+type BundleFactory<TBundle extends IBundle> = (
+  arg1: InternalBundle,
+  arg2: InternalBundleGraph,
+  arg3: AtlaspackOptions,
 ) => TBundle;
 
-export default class BundleGraph<TBundle: IBundle>
+export default class BundleGraph<TBundle extends IBundle>
   implements IBundleGraph<TBundle>
 {
   #graph: InternalBundleGraph;
@@ -65,7 +63,6 @@ export default class BundleGraph<TBundle: IBundle>
     this.#graph = graph;
     this.#options = options;
     this.#createBundle = createBundle;
-    // $FlowFixMe
     _bundleGraphToInternalBundleGraph.set(this, graph);
   }
 
@@ -81,7 +78,10 @@ export default class BundleGraph<TBundle: IBundle>
     return this.#graph.isDependencySkipped(dependencyToInternalDependency(dep));
   }
 
-  getResolvedAsset(dep: IDependency, bundle: ?IBundle): ?IAsset {
+  getResolvedAsset(
+    dep: IDependency,
+    bundle?: IBundle | null,
+  ): IAsset | null | undefined {
     let resolution = this.#graph.getResolvedAsset(
       dependencyToInternalDependency(dep),
       bundle && bundleToInternalBundle(bundle),
@@ -97,7 +97,7 @@ export default class BundleGraph<TBundle: IBundle>
       .map((dep) => getPublicDependency(dep, this.#options));
   }
 
-  getAssetWithDependency(dep: IDependency): ?IAsset {
+  getAssetWithDependency(dep: IDependency): IAsset | null | undefined {
     let asset = this.#graph.getAssetWithDependency(
       dependencyToInternalDependency(dep),
     );
@@ -114,7 +114,10 @@ export default class BundleGraph<TBundle: IBundle>
 
   getReferencedBundles(
     bundle: IBundle,
-    opts?: {|recursive?: boolean, includeInline?: boolean|},
+    opts?: {
+      recursive?: boolean;
+      includeInline?: boolean;
+    },
   ): Array<TBundle> {
     return this.#graph
       .getReferencedBundles(bundleToInternalBundle(bundle), opts)
@@ -129,11 +132,18 @@ export default class BundleGraph<TBundle: IBundle>
 
   resolveAsyncDependency(
     dependency: IDependency,
-    bundle: ?IBundle,
-  ): ?(
-    | {|type: 'bundle_group', value: IBundleGroup|}
-    | {|type: 'asset', value: IAsset|}
-  ) {
+    bundle?: IBundle | null,
+  ):
+    | {
+        type: 'bundle_group';
+        value: IBundleGroup;
+      }
+    | {
+        type: 'asset';
+        value: IAsset;
+      }
+    | null
+    | undefined {
     let resolved = this.#graph.resolveAsyncDependency(
       dependencyToInternalDependency(dependency),
       bundle && bundleToInternalBundle(bundle),
@@ -154,7 +164,10 @@ export default class BundleGraph<TBundle: IBundle>
     };
   }
 
-  getReferencedBundle(dependency: IDependency, bundle: IBundle): ?TBundle {
+  getReferencedBundle(
+    dependency: IDependency,
+    bundle: IBundle,
+  ): TBundle | null | undefined {
     let result = this.#graph.getReferencedBundle(
       dependencyToInternalDependency(dependency),
       bundleToInternalBundle(bundle),
@@ -185,6 +198,27 @@ export default class BundleGraph<TBundle: IBundle>
     );
   }
 
+  isAssetReferencedFastCheck(bundle: IBundle, asset: IAsset): boolean | null {
+    return this.#graph.isAssetReferencedFastCheck(
+      bundleToInternalBundle(bundle),
+      assetToAssetValue(asset),
+    );
+  }
+
+  getReferencedAssets(bundle: IBundle): Set<IAsset> {
+    let internalReferencedAssets = this.#graph.getReferencedAssets(
+      bundleToInternalBundle(bundle),
+    );
+
+    // Convert internal assets to public assets
+    let publicReferencedAssets = new Set<IAsset>();
+    for (let internalAsset of internalReferencedAssets) {
+      publicReferencedAssets.add(assetFromValue(internalAsset, this.#options));
+    }
+
+    return publicReferencedAssets;
+  }
+
   hasParentBundleOfType(bundle: IBundle, type: string): boolean {
     return this.#graph.hasParentBundleOfType(
       bundleToInternalBundle(bundle),
@@ -194,7 +228,9 @@ export default class BundleGraph<TBundle: IBundle>
 
   getBundlesInBundleGroup(
     bundleGroup: IBundleGroup,
-    opts?: {|includeInline: boolean|},
+    opts?: {
+      includeInline: boolean;
+    },
   ): Array<TBundle> {
     return this.#graph
       .getBundlesInBundleGroup(
@@ -204,7 +240,7 @@ export default class BundleGraph<TBundle: IBundle>
       .map((bundle) => this.#createBundle(bundle, this.#graph, this.#options));
   }
 
-  getBundles(opts?: {|includeInline: boolean|}): Array<TBundle> {
+  getBundles(opts?: {includeInline: boolean}): Array<TBundle> {
     return this.#graph
       .getBundles(opts)
       .map((bundle) => this.#createBundle(bundle, this.#graph, this.#options));
@@ -231,7 +267,7 @@ export default class BundleGraph<TBundle: IBundle>
   getSymbolResolution(
     asset: IAsset,
     symbol: Symbol,
-    boundary: ?IBundle,
+    boundary?: IBundle | null,
   ): SymbolResolution {
     let res = this.#graph.getSymbolResolution(
       assetToAssetValue(asset),
@@ -248,7 +284,7 @@ export default class BundleGraph<TBundle: IBundle>
 
   getExportedSymbols(
     asset: IAsset,
-    boundary: ?IBundle,
+    boundary?: IBundle | null,
   ): Array<ExportSymbolResolution> {
     let res = this.#graph.getExportedSymbols(
       assetToAssetValue(asset),
@@ -265,10 +301,13 @@ export default class BundleGraph<TBundle: IBundle>
 
   traverse<TContext>(
     visit: GraphVisitor<BundleGraphTraversable, TContext>,
-    start?: ?IAsset,
-    opts?: ?{|skipUnusedDependencies?: boolean|},
-  ): ?TContext {
+    start?: IAsset | null,
+    opts?: {
+      skipUnusedDependencies?: boolean;
+    } | null,
+  ): TContext | null | undefined {
     return this.#graph.traverse(
+      // @ts-expect-error TS2345
       mapVisitor((node, actions) => {
         // Skipping unused dependencies here is faster than doing an isDependencySkipped check inside the visitor
         // because the node needs to be re-looked up by id from the hashmap.
@@ -293,8 +332,8 @@ export default class BundleGraph<TBundle: IBundle>
 
   traverseBundles<TContext>(
     visit: GraphVisitor<TBundle, TContext>,
-    startBundle: ?IBundle,
-  ): ?TContext {
+    startBundle?: IBundle | null,
+  ): TContext | null | undefined {
     return this.#graph.traverseBundles(
       mapVisitor(
         (bundle) => this.#createBundle(bundle, this.#graph, this.#options),
@@ -316,7 +355,9 @@ export default class BundleGraph<TBundle: IBundle>
       .map((bundle) => this.#createBundle(bundle, this.#graph, this.#options));
   }
 
-  getUsedSymbols(v: IAsset | IDependency): ?$ReadOnlySet<Symbol> {
+  getUsedSymbols(
+    v: IAsset | IDependency,
+  ): ReadonlySet<Symbol> | null | undefined {
     if (v instanceof Asset) {
       return this.#graph.getUsedSymbolsAsset(assetToAssetValue(v));
     } else {
@@ -340,16 +381,16 @@ export default class BundleGraph<TBundle: IBundle>
   getConditionsForDependencies(
     deps: Array<IDependency>,
     bundle: NamedBundle,
-  ): Set<{|
-    publicId: string,
-    key: string,
-    ifTrueDependency: IDependency,
-    ifFalseDependency: IDependency,
-    ifTrueBundles: Array<TBundle>,
-    ifFalseBundles: Array<TBundle>,
-    ifTrueAssetId: string,
-    ifFalseAssetId: string,
-  |}> {
+  ): Set<{
+    publicId: string;
+    key: string;
+    ifTrueDependency: IDependency;
+    ifFalseDependency: IDependency;
+    ifTrueBundles: Array<TBundle>;
+    ifFalseBundles: Array<TBundle>;
+    ifTrueAssetId: string;
+    ifFalseAssetId: string;
+  }> {
     const conditions = new Set();
     const depIds = deps.map((dep) => dep.id);
     for (const condition of this.#graph._conditions.values()) {
@@ -437,6 +478,7 @@ export default class BundleGraph<TBundle: IBundle>
       }
     }
 
+    // @ts-expect-error TS2322
     return conditions;
   }
 
@@ -447,12 +489,12 @@ export default class BundleGraph<TBundle: IBundle>
     string,
     Map<
       string,
-      {|
-        bundle: TBundle,
-        ifTrueBundles: Array<TBundle>,
-        ifFalseBundles: Array<TBundle>,
-      |},
-    >,
+      {
+        bundle: TBundle;
+        ifTrueBundles: Array<TBundle>;
+        ifFalseBundles: Array<TBundle>;
+      }
+    >
   > {
     let bundleConditions = new Map();
 
@@ -462,15 +504,15 @@ export default class BundleGraph<TBundle: IBundle>
         nullthrows(this.getAssetById(asset.id)),
       );
       let bundles = new Set<TBundle>();
-      let ifTrueBundles = [];
-      let ifFalseBundles = [];
+      let ifTrueBundles: Array<TBundle> = [];
+      let ifFalseBundles: Array<TBundle> = [];
       for (const asset of assets) {
         const bundlesWithAsset = this.getBundlesWithAsset(asset);
         for (const bundle of bundlesWithAsset) {
           bundles.add(bundle);
         }
         const assetDeps = this.getDependencies(asset);
-        const depToBundles = (dep) => {
+        const depToBundles = (dep: Dependency) => {
           const publicDep = nullthrows(
             assetDeps.find((assetDep) => dep.id === assetDep.id),
           );
@@ -482,17 +524,27 @@ export default class BundleGraph<TBundle: IBundle>
           invariant(resolved.type === 'bundle_group');
           return this.getBundlesInBundleGroup(resolved.value);
         };
+        // @ts-expect-error TS2345
         ifTrueBundles.push(...depToBundles(cond.ifTrueDependency));
+        // @ts-expect-error TS2345
         ifFalseBundles.push(...depToBundles(cond.ifFalseDependency));
       }
 
       for (let bundle of bundles) {
         const conditions = bundleConditions.get(bundle.id) ?? new Map();
 
+        const currentCondition = conditions.get(cond.key);
+
         conditions.set(cond.key, {
           bundle,
-          ifTrueBundles,
-          ifFalseBundles,
+          ifTrueBundles: [
+            ...(currentCondition?.ifTrueBundles ?? []),
+            ...ifTrueBundles,
+          ],
+          ifFalseBundles: [
+            ...(currentCondition?.ifFalseBundles ?? []),
+            ...ifFalseBundles,
+          ],
         });
 
         bundleConditions.set(bundle.id, conditions);

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

@@ -1,4 +1,3 @@
-// @flow
 import type {
   BundleGroup as IBundleGroup,
   Target as ITarget,
@@ -13,11 +12,11 @@ import Target from './Target';
 
 const internalBundleGroupToBundleGroup: WeakMap<
   InternalBundleGroup,
-  BundleGroup,
+  BundleGroup
 > = new WeakMap();
 const _bundleGroupToInternalBundleGroup: WeakMap<
   IBundleGroup,
-  InternalBundleGroup,
+  InternalBundleGroup
 > = new WeakMap();
 export function bundleGroupToInternalBundleGroup(
   target: IBundleGroup,
@@ -28,13 +27,12 @@ export function bundleGroupToInternalBundleGroup(
 const inspect = Symbol.for('nodejs.util.inspect.custom');
 
 export default class BundleGroup implements IBundleGroup {
-  #bundleGroup /*: InternalBundleGroup */;
-  #options /*: AtlaspackOptions */;
+  // @ts-expect-error TS2564
+  #bundleGroup: InternalBundleGroup;
+  // @ts-expect-error TS2564
+  #options: AtlaspackOptions;
 
-  constructor(
-    bundleGroup: InternalBundleGroup,
-    options: AtlaspackOptions,
-  ): BundleGroup {
+  constructor(bundleGroup: InternalBundleGroup, options: AtlaspackOptions) {
     let existing = internalBundleGroupToBundleGroup.get(bundleGroup);
     if (existing != null) {
       return existing;
@@ -55,7 +53,6 @@ export default class BundleGroup implements IBundleGroup {
     return this.#bundleGroup.entryAssetId;
   }
 
-  // $FlowFixMe
   [inspect]() {
     return `BundleGroup(${this.entryAssetId})`;
   }