@atlaspack/bundler-default 2.14.5-canary.14 → 2.14.5-canary.140

package/lib/bundlerConfig.js

@@ -11,6 +11,13 @@ function _diagnostic() {
   };
   return data;
 }
+function _featureFlags() {
+  const data = require("@atlaspack/feature-flags");
+  _featureFlags = function () {
+    return data;
+  };
+  return data;
+}
 function _utils() {
   const data = require("@atlaspack/utils");
   _utils = function () {
@@ -32,14 +39,13 @@ function resolveModeConfig(config, mode) {
   for (const key of Object.keys(config)) {
     if (key === 'development' || key === 'production') {
       if (key === mode) {
+        // @ts-expect-error TS2322
         modeConfig = config[key];
       }
     } else {
       generalConfig[key] = config[key];
     }
   }
-
-  // $FlowFixMe Not sure how to convince flow here...
   return {
     ...generalConfig,
     ...modeConfig
@@ -54,7 +60,7 @@ const HTTP_OPTIONS = {
     minBundleSize: 30000,
     maxParallelRequests: 6,
     disableSharedBundles: false,
-    sharedBundleMergeThreshold: 1
+    sharedBundleMerge: []
   },
   '2': {
     minBundles: 1,
@@ -62,7 +68,7 @@ const HTTP_OPTIONS = {
     minBundleSize: 20000,
     maxParallelRequests: 25,
     disableSharedBundles: false,
-    sharedBundleMergeThreshold: 1
+    sharedBundleMerge: []
   }
 };
 const CONFIG_SCHEMA = {
@@ -103,6 +109,30 @@ const CONFIG_SCHEMA = {
         additionalProperties: false
       }
     },
+    sharedBundleMerge: {
+      type: 'array',
+      items: {
+        type: 'object',
+        properties: {
+          overlapThreshold: {
+            type: 'number'
+          },
+          maxBundleSize: {
+            type: 'number'
+          },
+          sourceBundles: {
+            type: 'array',
+            items: {
+              type: 'string'
+            }
+          },
+          minBundlesInGroup: {
+            type: 'number'
+          }
+        },
+        additionalProperties: false
+      }
+    },
     minBundles: {
       type: 'number'
     },
@@ -125,17 +155,26 @@ const CONFIG_SCHEMA = {
   additionalProperties: false
 };
 async function loadBundlerConfig(config, options, logger) {
-  let conf = await config.getConfig([], {
-    packageKey: '@atlaspack/bundler-default'
-  });
+  var _conf;
+  let conf;
+  if ((0, _featureFlags().getFeatureFlag)('resolveBundlerConfigFromCwd')) {
+    conf = await config.getConfigFrom(`${process.cwd()}/index`, [], {
+      packageKey: '@atlaspack/bundler-default'
+    });
+  } else {
+    conf = await config.getConfig([], {
+      packageKey: '@atlaspack/bundler-default'
+    });
+  }
   if (!conf) {
     const modDefault = {
       ...HTTP_OPTIONS['2'],
       projectRoot: options.projectRoot
     };
+    // @ts-expect-error TS2322
     return modDefault;
   }
-  (0, _assert().default)((conf === null || conf === void 0 ? void 0 : conf.contents) != null);
+  (0, _assert().default)(((_conf = conf) === null || _conf === void 0 ? void 0 : _conf.contents) != null);
   let modeConfig = resolveModeConfig(conf.contents, options.mode);
 
   // minBundles will be ignored if shared bundles are disabled
@@ -173,11 +212,12 @@ async function loadBundlerConfig(config, options, logger) {
     prependKey: `/${(0, _diagnostic().encodeJSONKeyComponent)('@atlaspack/bundler-default')}`
   }, '@atlaspack/bundler-default', 'Invalid config for @atlaspack/bundler-default');
   let http = modeConfig.http ?? 2;
+  // @ts-expect-error TS7053
   let defaults = HTTP_OPTIONS[http];
   return {
     minBundles: modeConfig.minBundles ?? defaults.minBundles,
     minBundleSize: modeConfig.minBundleSize ?? defaults.minBundleSize,
-    sharedBundleMergeThreshold: modeConfig.sharedBundleMergeThreshold ?? defaults.sharedBundleMergeThreshold,
+    sharedBundleMerge: modeConfig.sharedBundleMerge ?? defaults.sharedBundleMerge,
     maxParallelRequests: modeConfig.maxParallelRequests ?? defaults.maxParallelRequests,
     projectRoot: options.projectRoot,
     disableSharedBundles: modeConfig.disableSharedBundles ?? defaults.disableSharedBundles,

package/lib/decorateLegacyGraph.d.ts

@@ -0,0 +1,3 @@
+import type { MutableBundleGraph } from '@atlaspack/types';
+import type { IdealGraph } from './idealGraph';
+export declare function decorateLegacyGraph(idealGraph: IdealGraph, bundleGraph: MutableBundleGraph): void;

package/lib/decorateLegacyGraph.js

@@ -42,11 +42,13 @@ function decorateLegacyGraph(idealGraph, bundleGraph) {
     bundleGroupBundleIds,
     manualAssetToBundle
   } = idealGraph;
+  // This line can be deleted once supportWebpackChunkName feature flag is removed.
   let entryBundleToBundleGroup = 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;
     if (bundleGroupBundleIds.has(bundleNodeId)) {
@@ -57,19 +59,33 @@ function decorateLegacyGraph(idealGraph, bundleGraph) {
         return dependency.value;
       });
       (0, _assert().default)(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 ((0, _featureFlags().getFeatureFlag)('supportWebpackChunkName')) {
+        (0, _assert().default)(bundleGroups.size > 0, 'No bundle groups created');
+      } else {
+        (0, _assert().default)(bundleGroup);
+        entryBundleToBundleGroup.set(bundleNodeId, bundleGroup);
       }
-      (0, _assert().default)(bundleGroup);
-      entryBundleToBundleGroup.set(bundleNodeId, bundleGroup);
       bundle = (0, _nullthrows().default)(bundleGraph.createBundle({
         entryAsset: (0, _nullthrows().default)(entryAsset),
+        bundleRoots: Array.from(idealBundle.bundleRoots),
         needsStableName: idealBundle.needsStableName,
         bundleBehavior: idealBundle.bundleBehavior,
         target: idealBundle.target,
         manualSharedBundle: idealBundle.manualSharedBundle
       }));
-      bundleGraph.addBundleToBundleGroup(bundle, bundleGroup);
+      if ((0, _featureFlags().getFeatureFlag)('supportWebpackChunkName')) {
+        for (let bundleGroup of bundleGroups.values()) {
+          bundleGraph.addBundleToBundleGroup(bundle, bundleGroup);
+        }
+      } else {
+        (0, _assert().default)(bundleGroup);
+        bundleGraph.addBundleToBundleGroup(bundle, bundleGroup);
+      }
     } else if (idealBundle.sourceBundles.size > 0 && !idealBundle.mainEntryAsset) {
       let uniqueKey = idealBundle.uniqueKey != null ? idealBundle.uniqueKey : [...idealBundle.assets].map(asset => asset.id).join(',');
       bundle = (0, _nullthrows().default)(bundleGraph.createBundle({
@@ -95,6 +111,7 @@ function decorateLegacyGraph(idealGraph, bundleGraph) {
       (0, _assert().default)(entryAsset != null);
       bundle = (0, _nullthrows().default)(bundleGraph.createBundle({
         entryAsset,
+        bundleRoots: Array.from(idealBundle.bundleRoots),
         needsStableName: idealBundle.needsStableName,
         bundleBehavior: idealBundle.bundleBehavior,
         target: idealBundle.target,
@@ -162,6 +179,8 @@ function decorateLegacyGraph(idealGraph, bundleGraph) {
       bundleGraph.createAssetReference(dependency, asset, legacyBundle);
     }
   }
+
+  // @ts-expect-error TS2488
   for (let {
     type,
     from,
@@ -171,12 +190,14 @@ function decorateLegacyGraph(idealGraph, bundleGraph) {
     if (sourceBundle === 'root') {
       continue;
     }
+    // @ts-expect-error TS2367
     (0, _assert().default)(sourceBundle !== 'root');
     let legacySourceBundle = (0, _nullthrows().default)(idealBundleToLegacyBundle.get(sourceBundle));
     let targetBundle = (0, _nullthrows().default)(idealBundleGraph.getNode(to));
     if (targetBundle === 'root') {
       continue;
     }
+    // @ts-expect-error TS2367
     (0, _assert().default)(targetBundle !== 'root');
     let legacyTargetBundle = (0, _nullthrows().default)(idealBundleToLegacyBundle.get(targetBundle));
     if ((0, _featureFlags().getFeatureFlag)('conditionalBundlingApi') && type === _idealGraph.idealBundleGraphEdges.conditional) {

package/lib/idealGraph.d.ts

@@ -0,0 +1,40 @@
+import { BitSet, ContentGraph, Graph, NodeId } from '@atlaspack/graph';
+import type { Asset, BundleBehavior, Dependency, Environment, MutableBundleGraph, Target, PluginLogger } from '@atlaspack/types';
+import { DefaultMap } from '@atlaspack/utils';
+import type { ResolvedBundlerConfig } from './bundlerConfig';
+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;
+};
+export type DependencyBundleGraph = ContentGraph<{
+    value: Bundle;
+    type: 'bundle';
+} | {
+    value: Dependency;
+    type: 'dependency';
+}, number>;
+export declare const idealBundleGraphEdges: Readonly<{
+    default: 1;
+    conditional: 2;
+}>;
+export type IdealBundleGraph = Graph<Bundle | 'root', (typeof idealBundleGraphEdges)[keyof typeof idealBundleGraphEdges]>;
+export type IdealGraph = {
+    assetReference: DefaultMap<Asset, Array<[Dependency, Bundle]>>;
+    assets: Array<Asset>;
+    bundleGraph: IdealBundleGraph;
+    bundleGroupBundleIds: Set<NodeId>;
+    dependencyBundleGraph: DependencyBundleGraph;
+    manualAssetToBundle: Map<Asset, NodeId>;
+};
+export declare function createIdealGraph(assetGraph: MutableBundleGraph, config: ResolvedBundlerConfig, entries: Map<Asset, Dependency>, logger: PluginLogger): IdealGraph;