@atlaspack/bundler-default 3.1.3-typescript-5b4d3ad41.0 → 3.2.0

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

@@ -1,3 +1,5 @@
+// @flow strict-local
+
 import {Bundler} from '@atlaspack/plugin';
 import type {Asset, Dependency, MutableBundleGraph} from '@atlaspack/types';
 import {DefaultMap} from '@atlaspack/utils';
@@ -23,15 +25,14 @@ import {addJSMonolithBundle} from './MonolithicBundler';
  *  will have two or more distDirs, or output folders.) Then calls create IdealGraph and Decorate per target.
  *
  */
-export default new Bundler({
+export default (new Bundler({
   loadConfig({config, options, logger}) {
     return loadBundlerConfig(config, options, logger);
   },
 
   bundle({bundleGraph, config, logger}) {
     let targetMap = getEntryByTarget(bundleGraph); // Organize entries by target output folder/ distDir
-    // @ts-expect-error TS2304
-    let graphs: Array<IdealGraph> = [];
+    let graphs = [];
 
     for (let entries of targetMap.values()) {
       let singleFileEntries = new Map();
@@ -48,6 +49,7 @@ export default new Bundler({
 
       // Create separate bundleGraphs per distDir
       graphs.push(
+        // $FlowFixMe
         createIdealGraph(bundleGraph, config, idealGraphEntries, logger),
       );
 
@@ -63,7 +65,7 @@ export default new Bundler({
     }
   },
   optimize() {},
-}) as Bundler<unknown>;
+}): Bundler<mixed>);
 
 function getEntryByTarget(
   bundleGraph: MutableBundleGraph,
@@ -73,23 +75,7 @@ function getEntryByTarget(
     () => new Map(),
   );
   bundleGraph.traverse({
-    enter(
-      // @ts-expect-error TS2304
-      node: BundleGraphTraversable,
-      context:
-        | {
-            readonly type: 'asset';
-            value: Asset;
-          }
-        | null
-        | undefined
-        | {
-            readonly type: 'dependency';
-            value: Dependency;
-          },
-      // @ts-expect-error TS2304
-      actions: TraversalActions,
-    ) {
+    enter(node, context, actions) {
       if (node.type !== 'asset') {
         return node;
       }

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

@@ -1,3 +1,4 @@
+// @flow strict-local
 import type {Asset, Dependency, MutableBundleGraph} from '@atlaspack/types';
 import nullthrows from 'nullthrows';
 

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

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

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

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

@@ -1,4 +1,6 @@
-import {ALL_EDGE_TYPES, NodeId} from '@atlaspack/graph';
+// @flow strict-local
+
+import {ALL_EDGE_TYPES, type NodeId} from '@atlaspack/graph';
 import type {
   Bundle as LegacyBundle,
   BundleGroup,
@@ -23,11 +25,13 @@ export function decorateLegacyGraph(
     bundleGroupBundleIds,
     manualAssetToBundle,
   } = idealGraph;
+  // This line can be deleted once supportWebpackChunkName feature flag is removed.
   let entryBundleToBundleGroup: Map<NodeId, BundleGroup> = new Map();
   // Step Create Bundles: Create bundle groups, bundles, and shared bundles and add assets to them
   for (let [bundleNodeId, idealBundle] of idealBundleGraph.nodes.entries()) {
     if (!idealBundle || idealBundle === 'root') continue;
     let entryAsset = idealBundle.mainEntryAsset;
+    // This line can be deleted once supportWebpackChunkName feature flag is removed.
     let bundleGroup;
     let bundle;
 
@@ -50,18 +54,26 @@ export function decorateLegacyGraph(
         entryAsset != null,
         'Processing a bundleGroup with no entry asset',
       );
+
+      let bundleGroups = new Map();
       for (let dependency of dependencies) {
         bundleGroup = bundleGraph.createBundleGroup(
           dependency,
           idealBundle.target,
         );
+        bundleGroups.set(bundleGroup.entryAssetId, bundleGroup);
+      }
+      if (getFeatureFlag('supportWebpackChunkName')) {
+        invariant(bundleGroups.size > 0, 'No bundle groups created');
+      } else {
+        invariant(bundleGroup);
+        entryBundleToBundleGroup.set(bundleNodeId, bundleGroup);
       }
-      invariant(bundleGroup);
-      entryBundleToBundleGroup.set(bundleNodeId, bundleGroup);
 
       bundle = nullthrows(
         bundleGraph.createBundle({
           entryAsset: nullthrows(entryAsset),
+          bundleRoots: Array.from(idealBundle.bundleRoots),
           needsStableName: idealBundle.needsStableName,
           bundleBehavior: idealBundle.bundleBehavior,
           target: idealBundle.target,
@@ -69,7 +81,14 @@ export function decorateLegacyGraph(
         }),
       );
 
-      bundleGraph.addBundleToBundleGroup(bundle, bundleGroup);
+      if (getFeatureFlag('supportWebpackChunkName')) {
+        for (let bundleGroup of bundleGroups.values()) {
+          bundleGraph.addBundleToBundleGroup(bundle, bundleGroup);
+        }
+      } else {
+        invariant(bundleGroup);
+        bundleGraph.addBundleToBundleGroup(bundle, bundleGroup);
+      }
     } else if (
       idealBundle.sourceBundles.size > 0 &&
       !idealBundle.mainEntryAsset
@@ -107,6 +126,7 @@ export function decorateLegacyGraph(
       bundle = nullthrows(
         bundleGraph.createBundle({
           entryAsset,
+          bundleRoots: Array.from(idealBundle.bundleRoots),
           needsStableName: idealBundle.needsStableName,
           bundleBehavior: idealBundle.bundleBehavior,
           target: idealBundle.target,
@@ -193,13 +213,11 @@ 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,7 +228,6 @@ export function decorateLegacyGraph(
     if (targetBundle === 'root') {
       continue;
     }
-    // @ts-expect-error TS2367
     invariant(targetBundle !== 'root');
     let legacyTargetBundle = nullthrows(
       idealBundleToLegacyBundle.get(targetBundle),