@atlaspack/bundler-default 2.12.1-dev.3478 → 2.12.1-dev.3520

package/src/MonolithicBundler.js

@@ -0,0 +1,39 @@
+// @flow strict-local
+import type {Asset, Dependency, MutableBundleGraph} from '@atlaspack/types';
+import nullthrows from 'nullthrows';
+
+export function addJSMonolithBundle(
+  bundleGraph: MutableBundleGraph,
+  entryAsset: Asset,
+  entryDep: Dependency,
+): void {
+  let target = nullthrows(
+    entryDep.target,
+    'Expected dependency to have a valid target',
+  );
+
+  // Create a single bundle to hold all JS assets
+  let bundle = bundleGraph.createBundle({entryAsset, target});
+
+  bundleGraph.traverse(
+    (node) => {
+      // JS assets can be added to the bundle, but the rest are ignored
+      if (node.type === 'asset' && node.value.type === 'js') {
+        bundleGraph.addAssetToBundle(node.value, bundle);
+        return;
+      }
+
+      if (node.type === 'dependency' && node.value.priority === 'lazy') {
+        // Any async dependencies need to be internalized into the bundle, and will
+        // be included by the asset check above
+        bundleGraph.internalizeAsyncDependency(bundle, node.value);
+      }
+    },
+    entryAsset,
+    {skipUnusedDependencies: true},
+  );
+
+  let bundleGroup = bundleGraph.createBundleGroup(entryDep, target);
+
+  bundleGraph.addBundleToBundleGroup(bundle, bundleGroup);
+}

package/src/bundlerConfig.js

@@ -0,0 +1,234 @@
+// @flow strict-local
+
+import {encodeJSONKeyComponent} from '@atlaspack/diagnostic';
+import type {
+  Config,
+  PluginOptions,
+  BuildMode,
+  PluginLogger,
+} from '@atlaspack/types';
+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 BaseBundlerConfig = {|
+  http?: number,
+  minBundles?: number,
+  minBundleSize?: number,
+  maxParallelRequests?: number,
+  disableSharedBundles?: boolean,
+  manualSharedBundles?: ManualSharedBundles,
+  loadConditionalBundlesInParallel?: boolean,
+|};
+
+type BundlerConfig = {|
+  [mode: BuildMode]: BaseBundlerConfig,
+|} & BaseBundlerConfig;
+
+export type ResolvedBundlerConfig = {|
+  minBundles: number,
+  minBundleSize: number,
+  maxParallelRequests: number,
+  projectRoot: string,
+  disableSharedBundles: boolean,
+  manualSharedBundles: ManualSharedBundles,
+  loadConditionalBundlesInParallel?: boolean,
+|};
+
+function resolveModeConfig(
+  config: BundlerConfig,
+  mode: BuildMode,
+): BaseBundlerConfig {
+  let generalConfig = {};
+  let modeConfig = {};
+
+  for (const key of Object.keys(config)) {
+    if (key === 'development' || key === 'production') {
+      if (key === mode) {
+        modeConfig = config[key];
+      }
+    } else {
+      generalConfig[key] = config[key];
+    }
+  }
+
+  // $FlowFixMe Not sure how to convince flow here...
+  return {
+    ...generalConfig,
+    ...modeConfig,
+  };
+}
+
+// Default options by http version.
+const HTTP_OPTIONS = {
+  '1': {
+    minBundles: 1,
+    manualSharedBundles: [],
+    minBundleSize: 30000,
+    maxParallelRequests: 6,
+    disableSharedBundles: false,
+  },
+  '2': {
+    minBundles: 1,
+    manualSharedBundles: [],
+    minBundleSize: 20000,
+    maxParallelRequests: 25,
+    disableSharedBundles: false,
+  },
+};
+
+const CONFIG_SCHEMA: SchemaEntity = {
+  type: 'object',
+  properties: {
+    http: {
+      type: 'number',
+      enum: Object.keys(HTTP_OPTIONS).map((k) => Number(k)),
+    },
+    manualSharedBundles: {
+      type: 'array',
+      items: {
+        type: 'object',
+        properties: {
+          name: {
+            type: 'string',
+          },
+          assets: {
+            type: 'array',
+            items: {
+              type: 'string',
+            },
+          },
+          types: {
+            type: 'array',
+            items: {
+              type: 'string',
+            },
+          },
+          root: {
+            type: 'string',
+          },
+          split: {
+            type: 'number',
+          },
+        },
+        required: ['name', 'assets'],
+        additionalProperties: false,
+      },
+    },
+    minBundles: {
+      type: 'number',
+    },
+    minBundleSize: {
+      type: 'number',
+    },
+    maxParallelRequests: {
+      type: 'number',
+    },
+    disableSharedBundles: {
+      type: 'boolean',
+    },
+  },
+  additionalProperties: false,
+};
+
+export async function loadBundlerConfig(
+  config: Config,
+  options: PluginOptions,
+  logger: PluginLogger,
+): Promise<ResolvedBundlerConfig> {
+  let conf = await config.getConfig<BundlerConfig>([], {
+    packageKey: '@atlaspack/bundler-default',
+  });
+
+  if (!conf) {
+    const modDefault = {
+      ...HTTP_OPTIONS['2'],
+      projectRoot: options.projectRoot,
+    };
+    return modDefault;
+  }
+
+  invariant(conf?.contents != null);
+
+  let modeConfig = resolveModeConfig(conf.contents, options.mode);
+
+  // minBundles will be ignored if shared bundles are disabled
+  if (
+    modeConfig.minBundles != null &&
+    modeConfig.disableSharedBundles === true
+  ) {
+    logger.warn({
+      origin: '@atlaspack/bundler-default',
+      message: `The value of "${modeConfig.minBundles}" set for minBundles will not be used as shared bundles have been disabled`,
+    });
+  }
+
+  // minBundleSize will be ignored if shared bundles are disabled
+  if (
+    modeConfig.minBundleSize != null &&
+    modeConfig.disableSharedBundles === true
+  ) {
+    logger.warn({
+      origin: '@atlaspack/bundler-default',
+      message: `The value of "${modeConfig.minBundleSize}" set for minBundleSize will not be used as shared bundles have been disabled`,
+    });
+  }
+
+  // maxParallelRequests will be ignored if shared bundles are disabled
+  if (
+    modeConfig.maxParallelRequests != null &&
+    modeConfig.disableSharedBundles === true
+  ) {
+    logger.warn({
+      origin: '@atlaspack/bundler-default',
+      message: `The value of "${modeConfig.maxParallelRequests}" set for maxParallelRequests will not be used as shared bundles have been disabled`,
+    });
+  }
+
+  if (modeConfig.manualSharedBundles) {
+    let nameArray = modeConfig.manualSharedBundles.map((a) => a.name);
+    let nameSet = new Set(nameArray);
+    invariant(
+      nameSet.size == nameArray.length,
+      'The name field must be unique for property manualSharedBundles',
+    );
+  }
+
+  validateSchema.diagnostic(
+    CONFIG_SCHEMA,
+    {
+      data: modeConfig,
+      source: await options.inputFS.readFile(conf.filePath, 'utf8'),
+      filePath: conf.filePath,
+      prependKey: `/${encodeJSONKeyComponent('@atlaspack/bundler-default')}`,
+    },
+    '@atlaspack/bundler-default',
+    'Invalid config for @atlaspack/bundler-default',
+  );
+
+  let http = modeConfig.http ?? 2;
+  let defaults = HTTP_OPTIONS[http];
+
+  return {
+    minBundles: modeConfig.minBundles ?? defaults.minBundles,
+    minBundleSize: modeConfig.minBundleSize ?? defaults.minBundleSize,
+    maxParallelRequests:
+      modeConfig.maxParallelRequests ?? defaults.maxParallelRequests,
+    projectRoot: options.projectRoot,
+    disableSharedBundles:
+      modeConfig.disableSharedBundles ?? defaults.disableSharedBundles,
+    manualSharedBundles:
+      modeConfig.manualSharedBundles ?? defaults.manualSharedBundles,
+    loadConditionalBundlesInParallel:
+      modeConfig.loadConditionalBundlesInParallel,
+  };
+}

package/src/decorateLegacyGraph.js

@@ -0,0 +1,217 @@
+// @flow strict-local
+
+import {ALL_EDGE_TYPES, type NodeId} from '@atlaspack/graph';
+import type {
+  Bundle as LegacyBundle,
+  BundleGroup,
+  MutableBundleGraph,
+} from '@atlaspack/types';
+import invariant from 'assert';
+import nullthrows from 'nullthrows';
+
+import type {Bundle, IdealGraph} from './idealGraph';
+
+export function decorateLegacyGraph(
+  idealGraph: IdealGraph,
+  bundleGraph: MutableBundleGraph,
+): void {
+  let idealBundleToLegacyBundle: Map<Bundle, LegacyBundle> = new Map();
+
+  let {
+    bundleGraph: idealBundleGraph,
+    dependencyBundleGraph,
+    bundleGroupBundleIds,
+    manualAssetToBundle,
+  } = idealGraph;
+  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;
+    let bundleGroup;
+    let bundle;
+
+    if (bundleGroupBundleIds.has(bundleNodeId)) {
+      invariant(
+        idealBundle.manualSharedBundle == null,
+        'Processing a manualSharedBundle as a BundleGroup',
+      );
+      let dependencies = dependencyBundleGraph
+        .getNodeIdsConnectedTo(
+          dependencyBundleGraph.getNodeIdByContentKey(String(bundleNodeId)),
+          ALL_EDGE_TYPES,
+        )
+        .map((nodeId) => {
+          let dependency = nullthrows(dependencyBundleGraph.getNode(nodeId));
+          invariant(dependency.type === 'dependency');
+          return dependency.value;
+        });
+      invariant(
+        entryAsset != null,
+        'Processing a bundleGroup with no entry asset',
+      );
+      for (let dependency of dependencies) {
+        bundleGroup = bundleGraph.createBundleGroup(
+          dependency,
+          idealBundle.target,
+        );
+      }
+      invariant(bundleGroup);
+      entryBundleToBundleGroup.set(bundleNodeId, bundleGroup);
+
+      bundle = nullthrows(
+        bundleGraph.createBundle({
+          entryAsset: nullthrows(entryAsset),
+          needsStableName: idealBundle.needsStableName,
+          bundleBehavior: idealBundle.bundleBehavior,
+          target: idealBundle.target,
+          manualSharedBundle: idealBundle.manualSharedBundle,
+        }),
+      );
+
+      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 = nullthrows(
+        bundleGraph.createBundle({
+          uniqueKey,
+          needsStableName: idealBundle.needsStableName,
+          bundleBehavior: idealBundle.bundleBehavior,
+          type: idealBundle.type,
+          target: idealBundle.target,
+          env: idealBundle.env,
+          manualSharedBundle: idealBundle.manualSharedBundle,
+        }),
+      );
+    } else if (idealBundle.uniqueKey != null) {
+      bundle = nullthrows(
+        bundleGraph.createBundle({
+          uniqueKey: idealBundle.uniqueKey,
+          needsStableName: idealBundle.needsStableName,
+          bundleBehavior: idealBundle.bundleBehavior,
+          type: idealBundle.type,
+          target: idealBundle.target,
+          env: idealBundle.env,
+          manualSharedBundle: idealBundle.manualSharedBundle,
+        }),
+      );
+    } else {
+      invariant(entryAsset != null);
+      bundle = nullthrows(
+        bundleGraph.createBundle({
+          entryAsset,
+          needsStableName: idealBundle.needsStableName,
+          bundleBehavior: idealBundle.bundleBehavior,
+          target: idealBundle.target,
+          manualSharedBundle: idealBundle.manualSharedBundle,
+        }),
+      );
+    }
+
+    idealBundleToLegacyBundle.set(idealBundle, bundle);
+
+    for (let asset of idealBundle.assets) {
+      bundleGraph.addAssetToBundle(asset, bundle);
+    }
+  }
+  // Step Internalization: Internalize dependencies for bundles
+  for (let idealBundle of idealBundleGraph.nodes) {
+    if (!idealBundle || idealBundle === 'root') continue;
+    let bundle = nullthrows(idealBundleToLegacyBundle.get(idealBundle));
+    if (idealBundle.internalizedAssets) {
+      idealBundle.internalizedAssets.forEach((internalized) => {
+        let incomingDeps = bundleGraph.getIncomingDependencies(
+          idealGraph.assets[internalized],
+        );
+        for (let incomingDep of incomingDeps) {
+          if (
+            incomingDep.priority === 'lazy' &&
+            incomingDep.specifierType !== 'url' &&
+            bundle.hasDependency(incomingDep)
+          ) {
+            bundleGraph.internalizeAsyncDependency(bundle, incomingDep);
+          }
+        }
+      });
+    }
+  }
+  // Manual Shared Bundles
+  // NOTE: This only works under the assumption that manual shared bundles would have
+  // always already been loaded before the bundle that requires internalization.
+  for (let manualSharedAsset of manualAssetToBundle.keys()) {
+    let incomingDeps = bundleGraph.getIncomingDependencies(manualSharedAsset);
+    for (let incomingDep of incomingDeps) {
+      if (
+        incomingDep.priority === 'lazy' &&
+        incomingDep.specifierType !== 'url'
+      ) {
+        let bundles = bundleGraph.getBundlesWithDependency(incomingDep);
+        for (let bundle of bundles) {
+          bundleGraph.internalizeAsyncDependency(bundle, incomingDep);
+        }
+      }
+    }
+  }
+
+  // Step Add to BundleGroups: Add bundles to their bundle groups
+  idealBundleGraph.traverse((nodeId, _, actions) => {
+    let node = idealBundleGraph.getNode(nodeId);
+    if (node === 'root') {
+      return;
+    }
+    actions.skipChildren();
+
+    let outboundNodeIds = idealBundleGraph.getNodeIdsConnectedFrom(nodeId);
+    let entryBundle = nullthrows(idealBundleGraph.getNode(nodeId));
+    invariant(entryBundle !== 'root');
+    let legacyEntryBundle = nullthrows(
+      idealBundleToLegacyBundle.get(entryBundle),
+    );
+
+    for (let id of outboundNodeIds) {
+      let siblingBundle = nullthrows(idealBundleGraph.getNode(id));
+      invariant(siblingBundle !== 'root');
+      let legacySiblingBundle = nullthrows(
+        idealBundleToLegacyBundle.get(siblingBundle),
+      );
+      bundleGraph.createBundleReference(legacyEntryBundle, legacySiblingBundle);
+    }
+  });
+
+  // Step References: Add references to all bundles
+  for (let [asset, references] of idealGraph.assetReference) {
+    for (let [dependency, bundle] of references) {
+      let legacyBundle = nullthrows(idealBundleToLegacyBundle.get(bundle));
+      bundleGraph.createAssetReference(dependency, asset, legacyBundle);
+    }
+  }
+
+  for (let {from, to} of idealBundleGraph.getAllEdges()) {
+    let sourceBundle = nullthrows(idealBundleGraph.getNode(from));
+    if (sourceBundle === 'root') {
+      continue;
+    }
+    invariant(sourceBundle !== 'root');
+
+    let legacySourceBundle = nullthrows(
+      idealBundleToLegacyBundle.get(sourceBundle),
+    );
+
+    let targetBundle = nullthrows(idealBundleGraph.getNode(to));
+    if (targetBundle === 'root') {
+      continue;
+    }
+    invariant(targetBundle !== 'root');
+    let legacyTargetBundle = nullthrows(
+      idealBundleToLegacyBundle.get(targetBundle),
+    );
+    bundleGraph.createBundleReference(legacySourceBundle, legacyTargetBundle);
+  }
+}