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

package/lib/MonolithicBundler.js

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.addJSMonolithBundle = addJSMonolithBundle;
+function _nullthrows() {
+  const data = _interopRequireDefault(require("nullthrows"));
+  _nullthrows = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function addJSMonolithBundle(bundleGraph, entryAsset, entryDep) {
+  let target = (0, _nullthrows().default)(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/lib/bundlerConfig.js

@@ -0,0 +1,178 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.loadBundlerConfig = loadBundlerConfig;
+function _diagnostic() {
+  const data = require("@atlaspack/diagnostic");
+  _diagnostic = function () {
+    return data;
+  };
+  return data;
+}
+function _utils() {
+  const data = require("@atlaspack/utils");
+  _utils = function () {
+    return data;
+  };
+  return data;
+}
+function _assert() {
+  const data = _interopRequireDefault(require("assert"));
+  _assert = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function resolveModeConfig(config, mode) {
+  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 = {
+  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
+};
+async function loadBundlerConfig(config, options, logger) {
+  let conf = await config.getConfig([], {
+    packageKey: '@atlaspack/bundler-default'
+  });
+  if (!conf) {
+    const modDefault = {
+      ...HTTP_OPTIONS['2'],
+      projectRoot: options.projectRoot
+    };
+    return modDefault;
+  }
+  (0, _assert().default)((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
+  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);
+    (0, _assert().default)(nameSet.size == nameArray.length, 'The name field must be unique for property manualSharedBundles');
+  }
+  _utils().validateSchema.diagnostic(CONFIG_SCHEMA, {
+    data: modeConfig,
+    source: await options.inputFS.readFile(conf.filePath, 'utf8'),
+    filePath: conf.filePath,
+    prependKey: `/${(0, _diagnostic().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/lib/decorateLegacyGraph.js

@@ -0,0 +1,175 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.decorateLegacyGraph = decorateLegacyGraph;
+function _graph() {
+  const data = require("@atlaspack/graph");
+  _graph = function () {
+    return data;
+  };
+  return data;
+}
+function _assert() {
+  const data = _interopRequireDefault(require("assert"));
+  _assert = function () {
+    return data;
+  };
+  return data;
+}
+function _nullthrows() {
+  const data = _interopRequireDefault(require("nullthrows"));
+  _nullthrows = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function decorateLegacyGraph(idealGraph, bundleGraph) {
+  let idealBundleToLegacyBundle = new Map();
+  let {
+    bundleGraph: idealBundleGraph,
+    dependencyBundleGraph,
+    bundleGroupBundleIds,
+    manualAssetToBundle
+  } = idealGraph;
+  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;
+    let bundleGroup;
+    let bundle;
+    if (bundleGroupBundleIds.has(bundleNodeId)) {
+      (0, _assert().default)(idealBundle.manualSharedBundle == null, 'Processing a manualSharedBundle as a BundleGroup');
+      let dependencies = dependencyBundleGraph.getNodeIdsConnectedTo(dependencyBundleGraph.getNodeIdByContentKey(String(bundleNodeId)), _graph().ALL_EDGE_TYPES).map(nodeId => {
+        let dependency = (0, _nullthrows().default)(dependencyBundleGraph.getNode(nodeId));
+        (0, _assert().default)(dependency.type === 'dependency');
+        return dependency.value;
+      });
+      (0, _assert().default)(entryAsset != null, 'Processing a bundleGroup with no entry asset');
+      for (let dependency of dependencies) {
+        bundleGroup = bundleGraph.createBundleGroup(dependency, idealBundle.target);
+      }
+      (0, _assert().default)(bundleGroup);
+      entryBundleToBundleGroup.set(bundleNodeId, bundleGroup);
+      bundle = (0, _nullthrows().default)(bundleGraph.createBundle({
+        entryAsset: (0, _nullthrows().default)(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 = (0, _nullthrows().default)(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 = (0, _nullthrows().default)(bundleGraph.createBundle({
+        uniqueKey: idealBundle.uniqueKey,
+        needsStableName: idealBundle.needsStableName,
+        bundleBehavior: idealBundle.bundleBehavior,
+        type: idealBundle.type,
+        target: idealBundle.target,
+        env: idealBundle.env,
+        manualSharedBundle: idealBundle.manualSharedBundle
+      }));
+    } else {
+      (0, _assert().default)(entryAsset != null);
+      bundle = (0, _nullthrows().default)(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 = (0, _nullthrows().default)(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 = (0, _nullthrows().default)(idealBundleGraph.getNode(nodeId));
+    (0, _assert().default)(entryBundle !== 'root');
+    let legacyEntryBundle = (0, _nullthrows().default)(idealBundleToLegacyBundle.get(entryBundle));
+    for (let id of outboundNodeIds) {
+      let siblingBundle = (0, _nullthrows().default)(idealBundleGraph.getNode(id));
+      (0, _assert().default)(siblingBundle !== 'root');
+      let legacySiblingBundle = (0, _nullthrows().default)(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 = (0, _nullthrows().default)(idealBundleToLegacyBundle.get(bundle));
+      bundleGraph.createAssetReference(dependency, asset, legacyBundle);
+    }
+  }
+  for (let {
+    from,
+    to
+  } of idealBundleGraph.getAllEdges()) {
+    let sourceBundle = (0, _nullthrows().default)(idealBundleGraph.getNode(from));
+    if (sourceBundle === 'root') {
+      continue;
+    }
+    (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;
+    }
+    (0, _assert().default)(targetBundle !== 'root');
+    let legacyTargetBundle = (0, _nullthrows().default)(idealBundleToLegacyBundle.get(targetBundle));
+    bundleGraph.createBundleReference(legacySourceBundle, legacyTargetBundle);
+  }
+}