@atlaspack/bundler-default 3.1.2 → 3.1.3-typescript-80839fbd5.0

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

@@ -1,5 +1,3 @@
-// @flow strict-local
-
 import invariant from 'assert';
 import nullthrows from 'nullthrows';
 import {ContentGraph} from '@atlaspack/graph';
@@ -14,6 +12,7 @@ function getBundlesForBundleGroup(
 ): number {
   let count = 0;
   bundleGraph.traverse((nodeId) => {
+    // @ts-expect-error TS2339
     if (bundleGraph.getNode(nodeId)?.bundleBehavior !== 'inline') {
       count++;
     }
@@ -125,7 +124,7 @@ function getMergeClusters(
   graph: ContentGraph<NodeId, EdgeType>,
   candidates: Map<NodeId, EdgeType>,
 ): Array<Array<NodeId>> {
-  let clusters = [];
+  let clusters: Array<Array<NodeId>> = [];
 
   for (let [candidate, edgeType] of candidates.entries()) {
     let cluster: Array<NodeId> = [];
@@ -145,11 +144,11 @@ function getMergeClusters(
   return clusters;
 }
 
-type MergeCandidate = {|
-  bundle: Bundle,
-  id: NodeId,
-  contentKey: string,
-|};
+type MergeCandidate = {
+  bundle: Bundle;
+  id: NodeId;
+  contentKey: string;
+};
 function getPossibleMergeCandidates(
   bundleGraph: IdealBundleGraph,
   bundles: Array<NodeId>,
@@ -165,17 +164,15 @@ function getPossibleMergeCandidates(
     };
   });
 
-  const uniquePairs = [];
+  const uniquePairs: Array<[MergeCandidate, MergeCandidate]> = [];
 
   for (let i = 0; i < mergeCandidates.length; i++) {
     for (let j = i + 1; j < mergeCandidates.length; j++) {
       let a = mergeCandidates[i];
       let b = mergeCandidates[j];
 
-      if (
-        // $FlowFixMe both bundles will always have internalizedAssets
-        a.bundle.internalizedAssets.equals(b.bundle.internalizedAssets)
-      ) {
+      // @ts-expect-error TS18048
+      if (a.bundle.internalizedAssets.equals(b.bundle.internalizedAssets)) {
         uniquePairs.push([a, b]);
       }
     }
@@ -183,12 +180,12 @@ function getPossibleMergeCandidates(
   return uniquePairs;
 }
 
-export type MergeGroup = {|
-  overlapThreshold?: number,
-  maxBundleSize?: number,
-  sourceBundles?: Array<NodeId>,
-  minBundlesInGroup?: number,
-|};
+export type MergeGroup = {
+  overlapThreshold?: number;
+  maxBundleSize?: number;
+  sourceBundles?: Array<NodeId>;
+  minBundlesInGroup?: number;
+};
 type EdgeType = number;
 
 export function findMergeCandidates(

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

@@ -1,5 +1,3 @@
-// @flow strict-local
-
 import {encodeJSONKeyComponent} from '@atlaspack/diagnostic';
 import type {
   Config,
@@ -8,62 +6,62 @@ import type {
   PluginLogger,
 } from '@atlaspack/types';
 import {getFeatureFlag} from '@atlaspack/feature-flags';
-import {type SchemaEntity, validateSchema} from '@atlaspack/utils';
+import {SchemaEntity, validateSchema} from '@atlaspack/utils';
 import invariant from 'assert';
 
 type Glob = string;
 
-type ManualSharedBundles = Array<{|
-  name: string,
-  assets: Array<Glob>,
-  types?: Array<string>,
-  root?: string,
-  split?: number,
-|}>;
+type ManualSharedBundles = Array<{
+  name: string;
+  assets: Array<Glob>;
+  types?: Array<string>;
+  root?: string;
+  split?: number;
+}>;
 
-export type MergeCandidates = Array<{|
-  overlapThreshold?: number,
-  maxBundleSize?: number,
-  sourceBundles?: Array<string>,
-  minBundlesInGroup?: number,
-|}>;
+export type MergeCandidates = Array<{
+  overlapThreshold?: number;
+  maxBundleSize?: number;
+  sourceBundles?: Array<string>;
+  minBundlesInGroup?: number;
+}>;
 
-type BaseBundlerConfig = {|
-  http?: number,
-  minBundles?: number,
-  minBundleSize?: number,
-  maxParallelRequests?: number,
-  disableSharedBundles?: boolean,
-  manualSharedBundles?: ManualSharedBundles,
-  loadConditionalBundlesInParallel?: boolean,
-  sharedBundleMerge?: MergeCandidates,
-|};
+type BaseBundlerConfig = {
+  http?: number;
+  minBundles?: number;
+  minBundleSize?: number;
+  maxParallelRequests?: number;
+  disableSharedBundles?: boolean;
+  manualSharedBundles?: ManualSharedBundles;
+  loadConditionalBundlesInParallel?: boolean;
+  sharedBundleMerge?: MergeCandidates;
+};
 
-type BundlerConfig = {|
-  [mode: BuildMode]: BaseBundlerConfig,
-|} & BaseBundlerConfig;
+type BundlerConfig = Partial<Record<BuildMode, BaseBundlerConfig>> &
+  BaseBundlerConfig;
 
-export type ResolvedBundlerConfig = {|
-  minBundles: number,
-  minBundleSize: number,
-  maxParallelRequests: number,
-  projectRoot: string,
-  disableSharedBundles: boolean,
-  manualSharedBundles: ManualSharedBundles,
-  loadConditionalBundlesInParallel?: boolean,
-  sharedBundleMerge?: MergeCandidates,
-|};
+export type ResolvedBundlerConfig = {
+  minBundles: number;
+  minBundleSize: number;
+  maxParallelRequests: number;
+  projectRoot: string;
+  disableSharedBundles: boolean;
+  manualSharedBundles: ManualSharedBundles;
+  loadConditionalBundlesInParallel?: boolean;
+  sharedBundleMerge?: MergeCandidates;
+};
 
 function resolveModeConfig(
   config: BundlerConfig,
   mode: BuildMode,
 ): BaseBundlerConfig {
-  let generalConfig = {};
-  let modeConfig = {};
+  let generalConfig: Record<string, any> = {};
+  let modeConfig: Record<string, any> = {};
 
   for (const key of Object.keys(config)) {
     if (key === 'development' || key === 'production') {
       if (key === mode) {
+        // @ts-expect-error TS2322
         modeConfig = config[key];
       }
     } else {
@@ -71,7 +69,6 @@ function resolveModeConfig(
     }
   }
 
-  // $FlowFixMe Not sure how to convince flow here...
   return {
     ...generalConfig,
     ...modeConfig,
@@ -96,7 +93,7 @@ const HTTP_OPTIONS = {
     disableSharedBundles: false,
     sharedBundleMerge: [],
   },
-};
+} as const;
 
 const CONFIG_SCHEMA: SchemaEntity = {
   type: 'object',
@@ -203,7 +200,8 @@ export async function loadBundlerConfig(
     const modDefault = {
       ...HTTP_OPTIONS['2'],
       projectRoot: options.projectRoot,
-    };
+    } as const;
+    // @ts-expect-error TS2322
     return modDefault;
   }
 
@@ -266,6 +264,7 @@ export async function loadBundlerConfig(
   );
 
   let http = modeConfig.http ?? 2;
+  // @ts-expect-error TS7053
   let defaults = HTTP_OPTIONS[http];
 
   return {

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

@@ -1,6 +1,4 @@
-// @flow strict-local
-
-import {ALL_EDGE_TYPES, type NodeId} from '@atlaspack/graph';
+import {ALL_EDGE_TYPES, NodeId} from '@atlaspack/graph';
 import type {
   Bundle as LegacyBundle,
   BundleGroup,
@@ -195,11 +193,13 @@ export function decorateLegacyGraph(
     }
   }
 
+  // @ts-expect-error TS2488
   for (let {type, from, to} of idealBundleGraph.getAllEdges()) {
     let sourceBundle = nullthrows(idealBundleGraph.getNode(from));
     if (sourceBundle === 'root') {
       continue;
     }
+    // @ts-expect-error TS2367
     invariant(sourceBundle !== 'root');
 
     let legacySourceBundle = nullthrows(
@@ -210,6 +210,7 @@ export function decorateLegacyGraph(
     if (targetBundle === 'root') {
       continue;
     }
+    // @ts-expect-error TS2367
     invariant(targetBundle !== 'root');
     let legacyTargetBundle = nullthrows(
       idealBundleToLegacyBundle.get(targetBundle),