@atlaspack/bundler-default 3.2.0 → 3.2.1-typescript-17c3d1dec.0

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

@@ -1,5 +1,3 @@
-// @flow strict-local
-
 import path from 'path';
 
 import {getFeatureFlag} from '@atlaspack/feature-flags';
@@ -8,7 +6,7 @@ import {
   BitSet,
   ContentGraph,
   Graph,
-  type NodeId,
+  NodeId,
 } from '@atlaspack/graph';
 import type {
   Asset,
@@ -23,38 +21,38 @@ import {DefaultMap, globToRegex} from '@atlaspack/utils';
 import invariant from 'assert';
 import nullthrows from 'nullthrows';
 
-import {findMergeCandidates, type MergeGroup} from './bundleMerge';
+import {findMergeCandidates, MergeGroup} from './bundleMerge';
 import type {ResolvedBundlerConfig, MergeCandidates} from './bundlerConfig';
 
 /* BundleRoot - An asset that is the main entry of a Bundle. */
 type BundleRoot = Asset;
 
-export type Bundle = {|
-  uniqueKey: ?string,
-  assets: Set<Asset>,
-  internalizedAssets?: BitSet,
-  bundleBehavior?: ?BundleBehavior,
-  needsStableName: boolean,
-  mainEntryAsset: ?Asset,
-  bundleRoots: Set<Asset>,
-  size: number,
-  sourceBundles: Set<NodeId>,
-  target: Target,
-  env: Environment,
-  type: string,
-  manualSharedBundle: ?string, // for naming purposes
-|};
+export type Bundle = {
+  uniqueKey: string | null | undefined;
+  assets: Set<Asset>;
+  internalizedAssets?: BitSet;
+  bundleBehavior?: BundleBehavior | null | undefined;
+  needsStableName: boolean;
+  mainEntryAsset: Asset | null | undefined;
+  bundleRoots: Set<Asset>;
+  size: number;
+  sourceBundles: Set<NodeId>;
+  target: Target;
+  env: Environment;
+  type: string;
+  manualSharedBundle: string | null | undefined; // for naming purposes;
+};
 
 export type DependencyBundleGraph = ContentGraph<
-  | {|
-      value: Bundle,
-      type: 'bundle',
-    |}
-  | {|
-      value: Dependency,
-      type: 'dependency',
-    |},
-  number,
+  | {
+      value: Bundle;
+      type: 'bundle';
+    }
+  | {
+      value: Dependency;
+      type: 'dependency';
+    },
+  number
 >;
 
 const dependencyPriorityEdges = {
@@ -62,7 +60,7 @@ const dependencyPriorityEdges = {
   parallel: 2,
   lazy: 3,
   conditional: 4,
-};
+} as const;
 
 export const idealBundleGraphEdges = Object.freeze({
   default: 1,
@@ -71,20 +69,20 @@ export const idealBundleGraphEdges = Object.freeze({
 
 export type IdealBundleGraph = Graph<
   Bundle | 'root',
-  $Values<typeof idealBundleGraphEdges>,
+  (typeof idealBundleGraphEdges)[keyof typeof idealBundleGraphEdges]
 >;
 
 // IdealGraph is the structure we will pass to decorate,
 // which mutates the assetGraph into the bundleGraph we would
 // expect from default bundler
-export type IdealGraph = {|
-  assetReference: DefaultMap<Asset, Array<[Dependency, Bundle]>>,
-  assets: Array<Asset>,
-  bundleGraph: IdealBundleGraph,
-  bundleGroupBundleIds: Set<NodeId>,
-  dependencyBundleGraph: DependencyBundleGraph,
-  manualAssetToBundle: Map<Asset, NodeId>,
-|};
+export type IdealGraph = {
+  assetReference: DefaultMap<Asset, Array<[Dependency, Bundle]>>;
+  assets: Array<Asset>;
+  bundleGraph: IdealBundleGraph;
+  bundleGroupBundleIds: Set<NodeId>;
+  dependencyBundleGraph: DependencyBundleGraph;
+  manualAssetToBundle: Map<Asset, NodeId>;
+};
 
 function isNonRootBundle(
   bundle?: Bundle | 'root' | null,
@@ -108,7 +106,7 @@ export function createIdealGraph(
   let dependencyBundleGraph: DependencyBundleGraph = new ContentGraph();
   let assetReference: DefaultMap<
     Asset,
-    Array<[Dependency, Bundle]>,
+    Array<[Dependency, Bundle]>
   > = new DefaultMap(() => []);
 
   // A Graph of Bundles and a root node (dummy string), which models only Bundles, and connections to their
@@ -122,8 +120,9 @@ export function createIdealGraph(
   };
   // Graph that models bundleRoots, with parallel & async deps only to inform reachability
   let bundleRootGraph: Graph<
-    number, // asset index
-    $Values<typeof bundleRootEdgeTypes>,
+    // asset index
+    number,
+    (typeof bundleRootEdgeTypes)[keyof typeof bundleRootEdgeTypes]
   > = new Graph();
   let assetToBundleRootNodeId = new Map<BundleRoot, number>();
 
@@ -157,7 +156,7 @@ export function createIdealGraph(
     bundleGroupBundleIds.add(nodeId);
   }
 
-  let assets = [];
+  let assets: Array<Asset> = [];
   let assetToIndex = new Map<Asset, number>();
 
   function makeManualAssetToConfigLookup() {
@@ -172,6 +171,7 @@ export function createIdealGraph(
 
     for (let c of config.manualSharedBundles) {
       if (c.root != null) {
+        // @ts-expect-error TS2345
         parentsToConfig.get(path.join(config.projectRoot, c.root)).push(c);
       }
     }
@@ -219,6 +219,7 @@ export function createIdealGraph(
           // We track all matching MSB's for constant modules as they are never duplicated
           // and need to be assigned to all matching bundles
           if (node.value.meta.isConstantModule === true) {
+            // @ts-expect-error TS2345
             constantModuleToMSB.get(node.value).push(c);
           }
 
@@ -252,14 +253,14 @@ export function createIdealGraph(
     makeManualAssetToConfigLookup();
   let manualBundleToInternalizedAsset: DefaultMap<
     NodeId,
-    Array<Asset>,
+    Array<Asset>
   > = new DefaultMap(() => []);
 
   let mergeSourceBundleLookup = new Map<string, NodeId>();
   let mergeSourceBundleAssets = new Set(
     config.sharedBundleMerge?.flatMap(
       (c) =>
-        c.sourceBundles?.map((assetMatch) =>
+        c.sourceBundles?.map((assetMatch: string) =>
           path.join(config.projectRoot, assetMatch),
         ) ?? [],
     ),
@@ -272,7 +273,27 @@ export function createIdealGraph(
    */
   assetGraph.traverse(
     {
-      enter(node, context, actions) {
+      enter(
+        node: // @ts-expect-error TS2304
+        | BundleGraphTraversable
+          | {
+              readonly type: 'dependency';
+              value: Dependency;
+            },
+        context:
+          | {
+              readonly type: 'asset';
+              value: Asset;
+            }
+          | null
+          | undefined
+          | {
+              readonly type: 'dependency';
+              value: Dependency;
+            },
+        // @ts-expect-error TS2304
+        actions: TraversalActions,
+      ) {
         if (node.type === 'asset') {
           if (
             context?.type === 'dependency' &&
@@ -399,6 +420,7 @@ export function createIdealGraph(
                     type: 'bundle',
                   },
                 ),
+                // @ts-expect-error TS7053
                 dependencyPriorityEdges[dependency.priority],
               );
 
@@ -510,6 +532,7 @@ export function createIdealGraph(
 
               assetReference.get(childAsset).push([dependency, bundle]);
             } else {
+              // @ts-expect-error TS2322
               bundleId = null;
             }
             if (manualSharedObject && bundleId != null) {
@@ -517,6 +540,7 @@ export function createIdealGraph(
               // add the asset if it doesn't already have it and set key
 
               invariant(
+                // @ts-expect-error TS2367
                 bundle !== 'root' && bundle != null && bundleId != null,
               );
 
@@ -543,7 +567,8 @@ export function createIdealGraph(
         }
         return node;
       },
-      exit(node) {
+      // @ts-expect-error TS2322
+      exit(node: BundleGraphTraversable) {
         if (stack[stack.length - 1]?.[0] === node.value) {
           stack.pop();
         }
@@ -592,20 +617,20 @@ export function createIdealGraph(
 
   // reachableRoots is an array of bit sets for each asset. Each bit set
   // indicates which bundle roots are reachable from that asset synchronously.
-  let reachableRoots = [];
+  let reachableRoots: Array<BitSet> = [];
   for (let i = 0; i < assets.length; i++) {
     reachableRoots.push(new BitSet(bundleRootGraph.nodes.length));
   }
 
   // reachableAssets is the inverse mapping of reachableRoots. For each bundle root,
   // it contains a bit set that indicates which assets are reachable from it.
-  let reachableAssets = [];
+  let reachableAssets: Array<BitSet> = [];
 
   // ancestorAssets maps bundle roots to the set of all assets available to it at runtime,
   // including in earlier parallel bundles. These are intersected through all paths to
   // the bundle to ensure that the available assets are always present no matter in which
   // order the bundles are loaded.
-  let ancestorAssets = [];
+  let ancestorAssets: Array<null | BitSet> = [];
 
   let inlineConstantDeps = new DefaultMap(() => new Set());
 
@@ -834,8 +859,11 @@ export function createIdealGraph(
 
   function assignInlineConstants(parentAsset: Asset, bundle: Bundle) {
     for (let inlineConstant of inlineConstantDeps.get(parentAsset)) {
+      // @ts-expect-error TS2345
       if (!bundle.assets.has(inlineConstant)) {
+        // @ts-expect-error TS2345
         bundle.assets.add(inlineConstant);
+        // @ts-expect-error TS18046
         bundle.size += inlineConstant.stats.size;
       }
     }
@@ -895,7 +923,7 @@ export function createIdealGraph(
       let bundle;
       let bundleId;
       let manualSharedBundleKey = manualSharedObject.name + ',' + asset.type;
-      let sourceBundles = [];
+      let sourceBundles: Array<NodeId> = [];
       reachable.forEach((id) => {
         sourceBundles.push(nullthrows(bundleRoots.get(assets[id]))[0]);
       });
@@ -1010,7 +1038,7 @@ export function createIdealGraph(
       });
     }
 
-    let reachableArray = [];
+    let reachableArray: Array<Asset> = [];
     reachable.forEach((id) => {
       reachableArray.push(assets[id]);
     });
@@ -1105,9 +1133,9 @@ export function createIdealGraph(
       if (modNum != null) {
         for (let a of [...manualBundle.assets]) {
           let numRep = getBigIntFromContentKey(a.id);
-          // $FlowFixMe Flow doesn't know about BigInt
           let r = Number(numRep % BigInt(modNum));
 
+          // @ts-expect-error TS2345
           remainderMap.get(r).push(a);
         }
 
@@ -1130,8 +1158,10 @@ export function createIdealGraph(
           }
           for (let sp of remainderMap.get(i)) {
             bundle.assets.add(sp);
+            // @ts-expect-error TS2339
             bundle.size += sp.stats.size;
             manualBundle.assets.delete(sp);
+            // @ts-expect-error TS2339
             manualBundle.size -= sp.stats.size;
           }
         }
@@ -1144,6 +1174,7 @@ export function createIdealGraph(
   // match multiple MSB's
   for (let [asset, msbs] of constantModuleToMSB.entries()) {
     for (let manualSharedObject of msbs) {
+      // @ts-expect-error TS2339
       let bundleId = manualSharedMap.get(manualSharedObject.name + ',js');
       if (bundleId == null) continue;
       let bundle = nullthrows(bundleGraph.getNode(bundleId));
@@ -1152,8 +1183,11 @@ export function createIdealGraph(
         'We tried to use the root incorrectly',
       );
 
+      // @ts-expect-error TS2345
       if (!bundle.assets.has(asset)) {
+        // @ts-expect-error TS2345
         bundle.assets.add(asset);
+        // @ts-expect-error TS18046
         bundle.size += asset.stats.size;
       }
     }
@@ -1227,6 +1261,7 @@ export function createIdealGraph(
       // Merge all bundles with the same chunk name into the first one.
       let [firstBundleId, ...rest] = Array.from(bundleIds);
       for (let bundleId of rest) {
+        // @ts-expect-error TS2345
         mergeBundles(firstBundleId, bundleId);
       }
     }
@@ -1267,6 +1302,7 @@ export function createIdealGraph(
       let numBundlesContributingToPRL = bundleIdsInGroup.reduce((count, b) => {
         let bundle = nullthrows(bundleGraph.getNode(b));
         invariant(bundle !== 'root');
+        // @ts-expect-error TS2365
         return count + (bundle.bundleBehavior !== 'inline');
       }, 0);
 
@@ -1302,7 +1338,9 @@ export function createIdealGraph(
           numBundlesContributingToPRL > config.maxParallelRequests
         ) {
           let bundleTuple = sharedBundlesInGroup.pop();
+          // @ts-expect-error TS18048
           let bundleToRemove = bundleTuple.bundle;
+          // @ts-expect-error TS18048
           let bundleIdToRemove = bundleTuple.id;
           //TODO add integration test where bundles in bunlde group > max parallel request limit & only remove a couple shared bundles
           // but total # bundles still exceeds limit due to non shared bundles
@@ -1374,10 +1412,11 @@ export function createIdealGraph(
 
       let newAssetReference = assetReference
         .get(asset)
-        .map(([dep, bundle]) =>
+        .map(([dep, bundle]: [any, any]) =>
           bundle === bundleToRemove ? [dep, bundleToKeep] : [dep, bundle],
         );
 
+      // @ts-expect-error TS2345
       assetReference.set(asset, newAssetReference);
     }
 
@@ -1541,20 +1580,22 @@ export function createIdealGraph(
     let clusters = findMergeCandidates(
       bundleGraph,
       Array.from(sharedBundles),
-      mergeConfig.map((config): MergeGroup => ({
-        ...config,
-        sourceBundles: config.sourceBundles?.map((assetMatch) => {
-          let sourceBundleNodeId = mergeSourceBundleLookup.get(assetMatch);
-
-          if (sourceBundleNodeId == null) {
-            throw new Error(
-              `Source bundle ${assetMatch} not found in merge source bundle lookup`,
-            );
-          }
+      mergeConfig.map(
+        (config): MergeGroup => ({
+          ...config,
+          sourceBundles: config.sourceBundles?.map((assetMatch: string) => {
+            let sourceBundleNodeId = mergeSourceBundleLookup.get(assetMatch);
+
+            if (sourceBundleNodeId == null) {
+              throw new Error(
+                `Source bundle ${assetMatch} not found in merge source bundle lookup`,
+              );
+            }
 
-          return sourceBundleNodeId;
+            return sourceBundleNodeId;
+          }),
         }),
-      })),
+      ),
     );
 
     let mergedBundles = new Set();
@@ -1574,10 +1615,9 @@ export function createIdealGraph(
     }
   }
 
-  function getBigIntFromContentKey(contentKey) {
+  function getBigIntFromContentKey(contentKey: string) {
     let b = Buffer.alloc(64);
     b.write(contentKey);
-    // $FlowFixMe Flow doesn't have BigInt types in this version
     return b.readBigInt64BE();
   }
   // Fix asset order in source bundles as they are likely now incorrect after shared bundle deletion
@@ -1604,8 +1644,8 @@ export function createIdealGraph(
       bundleRootGraph.removeNode(bundleRootId);
     }
   }
-  function getBundlesForBundleGroup(bundleGroupId) {
-    let bundlesInABundleGroup = [];
+  function getBundlesForBundleGroup(bundleGroupId: NodeId) {
+    let bundlesInABundleGroup: Array<NodeId> = [];
     bundleGraph.traverse((nodeId) => {
       bundlesInABundleGroup.push(nodeId);
     }, bundleGroupId);
@@ -1686,17 +1726,17 @@ export function createIdealGraph(
   };
 }
 
-function createBundle(opts: {|
-  asset?: Asset,
-  bundleBehavior?: ?BundleBehavior,
-  env?: Environment,
-  manualSharedBundle?: ?string,
-  needsStableName?: boolean,
-  sourceBundles?: Set<NodeId>,
-  target: Target,
-  type?: string,
-  uniqueKey?: string,
-|}): Bundle {
+function createBundle(opts: {
+  asset?: Asset;
+  bundleBehavior?: BundleBehavior | null | undefined;
+  env?: Environment;
+  manualSharedBundle?: string | null | undefined;
+  needsStableName?: boolean;
+  sourceBundles?: Set<NodeId>;
+  target: Target;
+  type?: string;
+  uniqueKey?: string;
+}): Bundle {
   if (opts.asset == null) {
     return {
       assets: new Set(),

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

@@ -1,9 +1,6 @@
-// @flow strict
-
-// $FlowFixMe
 import ManyKeysMap from 'many-keys-map';
 
-let caches = [];
+let caches: Array<any> = [];
 
 export function clearCaches() {
   for (let cache of caches) {
@@ -11,7 +8,7 @@ export function clearCaches() {
   }
 }
 
-export function memoize<Args: Array<mixed>, Return>(
+export function memoize<Args extends Array<unknown>, Return>(
   fn: (...args: Args) => Return,
 ): (...args: Args) => Return {
   let cache = new ManyKeysMap();
@@ -26,8 +23,8 @@ export function memoize<Args: Array<mixed>, Return>(
     }
 
     // Calculate the result and cache it
+    // @ts-expect-error TS2683
     const result = fn.apply(this, args);
-    // $FlowFixMe
     cache.set(args, result);
 
     return result;

package/tsconfig.json

@@ -0,0 +1,4 @@
+{
+  "extends": "../../../tsconfig.json",
+  "include": ["src"]
+}