@atlaspack/core 2.14.0 → 2.14.1-canary.3710

package/lib/AssetGraph.js

@@ -0,0 +1,521 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+exports.nodeFromAsset = nodeFromAsset;
+exports.nodeFromAssetGroup = nodeFromAssetGroup;
+exports.nodeFromDep = nodeFromDep;
+exports.nodeFromEntryFile = nodeFromEntryFile;
+exports.nodeFromEntrySpecifier = nodeFromEntrySpecifier;
+function _assert() {
+  const data = _interopRequireDefault(require("assert"));
+  _assert = function () {
+    return data;
+  };
+  return data;
+}
+function _rust() {
+  const data = require("@atlaspack/rust");
+  _rust = function () {
+    return data;
+  };
+  return data;
+}
+function _utils() {
+  const data = require("@atlaspack/utils");
+  _utils = function () {
+    return data;
+  };
+  return data;
+}
+function _nullthrows() {
+  const data = _interopRequireDefault(require("nullthrows"));
+  _nullthrows = function () {
+    return data;
+  };
+  return data;
+}
+function _graph() {
+  const data = require("@atlaspack/graph");
+  _graph = function () {
+    return data;
+  };
+  return data;
+}
+var _Dependency = require("./Dependency");
+var _projectPath = require("./projectPath");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function nodeFromDep(dep) {
+  return {
+    id: dep.id,
+    type: 'dependency',
+    value: dep,
+    deferred: false,
+    excluded: false,
+    usedSymbolsDown: new Set(),
+    usedSymbolsUp: new Map(),
+    usedSymbolsDownDirty: true,
+    usedSymbolsUpDirtyDown: true,
+    usedSymbolsUpDirtyUp: true
+  };
+}
+function nodeFromAssetGroup(assetGroup) {
+  return {
+    id: (0, _rust().hashString)((0, _projectPath.fromProjectPathRelative)(assetGroup.filePath) + assetGroup.env.id + String(assetGroup.isSource) + String(assetGroup.sideEffects) + (assetGroup.code ?? '') + ':' + (assetGroup.pipeline ?? '') + ':' + (assetGroup.query ?? '')),
+    type: 'asset_group',
+    value: assetGroup,
+    usedSymbolsDownDirty: true
+  };
+}
+function nodeFromAsset(asset) {
+  return {
+    id: asset.id,
+    type: 'asset',
+    value: asset,
+    usedSymbols: new Set(),
+    usedSymbolsDownDirty: true,
+    usedSymbolsUpDirty: true
+  };
+}
+function nodeFromEntrySpecifier(entry) {
+  return {
+    id: 'entry_specifier:' + (0, _projectPath.fromProjectPathRelative)(entry),
+    type: 'entry_specifier',
+    value: entry
+  };
+}
+function nodeFromEntryFile(entry) {
+  return {
+    id: 'entry_file:' + (0, _utils().hashObject)(entry),
+    type: 'entry_file',
+    value: entry
+  };
+}
+class AssetGraph extends _graph().ContentGraph {
+  safeToIncrementallyBundle = true;
+  constructor(opts) {
+    if (opts) {
+      let {
+        hash,
+        ...rest
+      } = opts;
+      super(rest);
+      this.hash = hash;
+    } else {
+      super();
+      this.setRootNodeId(this.addNode({
+        id: '@@root',
+        type: 'root',
+        value: null
+      }));
+    }
+    this.undeferredDependencies = new Set();
+    this.envCache = new Map();
+  }
+
+  // $FlowFixMe[prop-missing]
+  static deserialize(opts) {
+    return new AssetGraph(opts);
+  }
+
+  // $FlowFixMe[prop-missing]
+  serialize() {
+    return {
+      ...super.serialize(),
+      hash: this.hash
+    };
+  }
+
+  // Deduplicates Environments by making them referentially equal
+  normalizeEnvironment(input) {
+    let {
+      id,
+      context
+    } = input.env;
+    let idAndContext = `${id}-${context}`;
+    let env = this.envCache.get(idAndContext);
+    if (env) {
+      input.env = env;
+    } else {
+      this.envCache.set(idAndContext, input.env);
+    }
+  }
+  setRootConnections({
+    entries,
+    assetGroups
+  }) {
+    let nodes = [];
+    if (entries) {
+      for (let entry of entries) {
+        let node = nodeFromEntrySpecifier(entry);
+        nodes.push(node);
+      }
+    } else if (assetGroups) {
+      for (const assetGroup of assetGroups) {
+        // Adding nodes individually ensures we do not encounter a range stack size exceeded error
+        // when there are >100000 asset groups
+        nodes.push(nodeFromAssetGroup(assetGroup));
+      }
+    }
+    this.replaceNodeIdsConnectedTo((0, _nullthrows().default)(this.rootNodeId), nodes.map(node => this.addNode(node)));
+  }
+  addNode(node) {
+    this.hash = null;
+    let existing = this.getNodeByContentKey(node.id);
+    if (existing != null) {
+      (0, _assert().default)(existing.type === node.type);
+      // $FlowFixMe[incompatible-type] Checked above
+      // $FlowFixMe[prop-missing]
+      existing.value = node.value;
+      let existingId = this.getNodeIdByContentKey(node.id);
+      this.updateNode(existingId, existing);
+      return existingId;
+    }
+    return super.addNodeByContentKey(node.id, node);
+  }
+  removeNode(nodeId) {
+    this.hash = null;
+    this.onNodeRemoved && this.onNodeRemoved(nodeId);
+    return super.removeNode(nodeId);
+  }
+  resolveEntry(entry, resolved, correspondingRequest) {
+    let entrySpecifierNodeId = this.getNodeIdByContentKey(nodeFromEntrySpecifier(entry).id);
+    let entrySpecifierNode = (0, _nullthrows().default)(this.getNode(entrySpecifierNodeId));
+    (0, _assert().default)(entrySpecifierNode.type === 'entry_specifier');
+    entrySpecifierNode.correspondingRequest = correspondingRequest;
+    this.replaceNodeIdsConnectedTo(entrySpecifierNodeId, resolved.map(file => this.addNode(nodeFromEntryFile(file))));
+  }
+  resolveTargets(entry, targets, correspondingRequest) {
+    let depNodes = targets.map(target => {
+      let node = nodeFromDep(
+      // The passed project path is ignored in this case, because there is no `loc`
+      (0, _Dependency.createDependency)('', {
+        specifier: (0, _projectPath.fromProjectPathRelative)(entry.filePath),
+        specifierType: 'url',
+        pipeline: target.pipeline,
+        target: target,
+        env: target.env,
+        isEntry: true,
+        needsStableName: true,
+        symbols: target.env.isLibrary ? new Map([['*', {
+          local: '*',
+          isWeak: true,
+          loc: null
+        }]]) : undefined
+      }));
+      if (node.value.env.isLibrary) {
+        // in library mode, all of the entry's symbols are "used"
+        node.usedSymbolsDown.add('*');
+        node.usedSymbolsUp.set('*', undefined);
+      }
+      return node;
+    });
+    let entryNodeId = this.getNodeIdByContentKey(nodeFromEntryFile(entry).id);
+    let entryNode = (0, _nullthrows().default)(this.getNode(entryNodeId));
+    (0, _assert().default)(entryNode.type === 'entry_file');
+    entryNode.correspondingRequest = correspondingRequest;
+    this.replaceNodeIdsConnectedTo(entryNodeId, depNodes.map(node => this.addNode(node)));
+  }
+  resolveDependency(dependency, assetGroup, correspondingRequest) {
+    let depNodeId = this.getNodeIdByContentKey(dependency.id);
+    let depNode = (0, _nullthrows().default)(this.getNode(depNodeId));
+    (0, _assert().default)(depNode.type === 'dependency');
+    depNode.correspondingRequest = correspondingRequest;
+    if (!assetGroup) {
+      return;
+    }
+    let assetGroupNode = nodeFromAssetGroup(assetGroup);
+    let existing = this.getNodeByContentKey(assetGroupNode.id);
+    if (existing != null) {
+      (0, _assert().default)(existing.type === 'asset_group');
+      assetGroupNode.value.canDefer = assetGroupNode.value.canDefer && existing.value.canDefer;
+    }
+    let assetGroupNodeId = this.addNode(assetGroupNode);
+    this.replaceNodeIdsConnectedTo(this.getNodeIdByContentKey(dependency.id), [assetGroupNodeId]);
+    this.replaceNodeIdsConnectedTo(depNodeId, [assetGroupNodeId]);
+  }
+  shouldVisitChild(nodeId, childNodeId) {
+    let node = (0, _nullthrows().default)(this.getNode(nodeId));
+    let childNode = (0, _nullthrows().default)(this.getNode(childNodeId));
+    if (node.type !== 'dependency' || childNode.type !== 'asset_group' || childNode.deferred === false) {
+      return true;
+    }
+    // Node types are proved above
+    let dependencyNode = node;
+    let assetGroupNode = childNode;
+    let {
+      sideEffects,
+      canDefer = true
+    } = assetGroupNode.value;
+    let dependency = dependencyNode.value;
+    let dependencyPreviouslyDeferred = dependencyNode.hasDeferred;
+    let assetGroupPreviouslyDeferred = assetGroupNode.deferred;
+    let defer = this.shouldDeferDependency(dependency, sideEffects, canDefer);
+    dependencyNode.hasDeferred = defer;
+    assetGroupNode.deferred = defer;
+    if (!dependencyPreviouslyDeferred && defer) {
+      this.markParentsWithHasDeferred(nodeId);
+    } else if (assetGroupPreviouslyDeferred && !defer) {
+      this.unmarkParentsWithHasDeferred(childNodeId);
+    }
+    return !defer;
+  }
+
+  // Dependency: mark parent Asset <- AssetGroup with hasDeferred true
+  markParentsWithHasDeferred(nodeId) {
+    this.traverseAncestors(nodeId, (traversedNodeId, _, actions) => {
+      let traversedNode = (0, _nullthrows().default)(this.getNode(traversedNodeId));
+      if (traversedNode.type === 'asset') {
+        traversedNode.hasDeferred = true;
+      } else if (traversedNode.type === 'asset_group') {
+        traversedNode.hasDeferred = true;
+        actions.skipChildren();
+      } else if (nodeId !== traversedNodeId) {
+        actions.skipChildren();
+      }
+    });
+  }
+
+  // AssetGroup: update hasDeferred of all parent Dependency <- Asset <- AssetGroup
+  unmarkParentsWithHasDeferred(nodeId) {
+    this.traverseAncestors(nodeId, (traversedNodeId, ctx, actions) => {
+      let traversedNode = (0, _nullthrows().default)(this.getNode(traversedNodeId));
+      if (traversedNode.type === 'asset') {
+        let hasDeferred = this.getNodeIdsConnectedFrom(traversedNodeId).some(childNodeId => {
+          let childNode = (0, _nullthrows().default)(this.getNode(childNodeId));
+          return childNode.hasDeferred == null ? false : childNode.hasDeferred;
+        });
+        if (!hasDeferred) {
+          delete traversedNode.hasDeferred;
+        }
+        return {
+          hasDeferred
+        };
+      } else if (traversedNode.type === 'asset_group' && nodeId !== traversedNodeId) {
+        if (!(ctx !== null && ctx !== void 0 && ctx.hasDeferred)) {
+          this.safeToIncrementallyBundle = false;
+          delete traversedNode.hasDeferred;
+        }
+        actions.skipChildren();
+      } else if (traversedNode.type === 'dependency') {
+        this.safeToIncrementallyBundle = false;
+        traversedNode.hasDeferred = false;
+      } else if (nodeId !== traversedNodeId) {
+        actions.skipChildren();
+      }
+    });
+  }
+
+  // Defer transforming this dependency if it is marked as weak, there are no side effects,
+  // no re-exported symbols are used by ancestor dependencies and the re-exporting asset isn't
+  // using a wildcard and isn't an entry (in library mode).
+  // This helps with performance building large libraries like `lodash-es`, which re-exports
+  // a huge number of functions since we can avoid even transforming the files that aren't used.
+  shouldDeferDependency(dependency, sideEffects, canDefer) {
+    let dependencySymbols = dependency.symbols;
+
+    // Doing this separately keeps Flow happy further down
+    if (!dependencySymbols) {
+      return false;
+    }
+    let isDeferrable = [...dependencySymbols].every(([, {
+      isWeak
+    }]) => isWeak) && sideEffects === false && canDefer && !dependencySymbols.has('*');
+    if (!isDeferrable) {
+      return false;
+    }
+    let depNodeId = this.getNodeIdByContentKey(dependency.id);
+    let depNode = this.getNode(depNodeId);
+    (0, _assert().default)(depNode);
+    let assets = this.getNodeIdsConnectedTo(depNodeId);
+    let symbols = new Map([...dependencySymbols].map(([key, val]) => [val.local, key]));
+    (0, _assert().default)(assets.length === 1);
+    let firstAsset = (0, _nullthrows().default)(this.getNode(assets[0]));
+    (0, _assert().default)(firstAsset.type === 'asset');
+    let resolvedAsset = firstAsset.value;
+
+    // This doesn't change from here, so checking it now saves
+    // us some calls to `getIncomingDependency`
+    if (!resolvedAsset.symbols) {
+      return true;
+    }
+    let deps = this.getIncomingDependencies(resolvedAsset);
+    return deps.every(d => {
+      // If this dependency has already been through this process, and we
+      // know it's not deferrable, then there's no need to re-check
+      if (this.undeferredDependencies.has(d)) {
+        return false;
+      }
+      let depIsDeferrable = d.symbols && !(d.env.isLibrary && d.isEntry) && !d.symbols.has('*') && ![...d.symbols.keys()].some(symbol => {
+        var _resolvedAsset$symbol;
+        let assetSymbol = (_resolvedAsset$symbol = resolvedAsset.symbols) === null || _resolvedAsset$symbol === void 0 || (_resolvedAsset$symbol = _resolvedAsset$symbol.get(symbol)) === null || _resolvedAsset$symbol === void 0 ? void 0 : _resolvedAsset$symbol.local;
+        return assetSymbol != null && symbols.has(assetSymbol);
+      });
+      if (!depIsDeferrable) {
+        // Mark this dep as not deferrable so it doesn't have to be re-checked
+        this.undeferredDependencies.add(d);
+        return false;
+      }
+    });
+  }
+  resolveAssetGroup(assetGroup, assets, correspondingRequest) {
+    this.normalizeEnvironment(assetGroup);
+    let assetGroupNode = nodeFromAssetGroup(assetGroup);
+    assetGroupNode = this.getNodeByContentKey(assetGroupNode.id);
+    if (!assetGroupNode) {
+      return;
+    }
+    (0, _assert().default)(assetGroupNode.type === 'asset_group');
+    assetGroupNode.correspondingRequest = correspondingRequest;
+    let assetsByKey = new Map();
+    for (let asset of assets) {
+      if (asset.uniqueKey != null) {
+        assetsByKey.set(asset.uniqueKey, asset);
+      }
+    }
+    let dependentAssetKeys = new Set();
+    for (let asset of assets) {
+      for (let dep of asset.dependencies.values()) {
+        if (assetsByKey.has(dep.specifier)) {
+          dependentAssetKeys.add(dep.specifier);
+        }
+      }
+    }
+    let assetObjects = [];
+    let assetNodeIds = [];
+    for (let asset of assets) {
+      this.normalizeEnvironment(asset);
+      let isDirect = !dependentAssetKeys.has(asset.uniqueKey);
+      let dependentAssets = [];
+      for (let dep of asset.dependencies.values()) {
+        let dependentAsset = assetsByKey.get(dep.specifier);
+        if (dependentAsset) {
+          dependentAssets.push(dependentAsset);
+          if (dependentAsset.id === asset.id) {
+            // Don't orphan circular dependencies.
+            isDirect = true;
+          }
+        }
+      }
+      let id = this.addNode(nodeFromAsset(asset));
+      assetObjects.push({
+        assetNodeId: id,
+        dependentAssets
+      });
+      if (isDirect) {
+        assetNodeIds.push(id);
+      }
+    }
+    this.replaceNodeIdsConnectedTo(this.getNodeIdByContentKey(assetGroupNode.id), assetNodeIds);
+    for (let {
+      assetNodeId,
+      dependentAssets
+    } of assetObjects) {
+      // replaceNodesConnectedTo has merged the value into the existing node, retrieve
+      // the actual current node.
+      let assetNode = (0, _nullthrows().default)(this.getNode(assetNodeId));
+      (0, _assert().default)(assetNode.type === 'asset');
+      this.resolveAsset(assetNode, dependentAssets);
+    }
+  }
+  resolveAsset(assetNode, dependentAssets) {
+    let depNodeIds = [];
+    let depNodesWithAssets = [];
+    for (let dep of assetNode.value.dependencies.values()) {
+      this.normalizeEnvironment(dep);
+      let depNode = nodeFromDep(dep);
+      let existing = this.getNodeByContentKey(depNode.id);
+      if ((existing === null || existing === void 0 ? void 0 : existing.type) === 'dependency' && existing.value.resolverMeta != null) {
+        depNode.value.meta = {
+          ...depNode.value.meta,
+          ...existing.value.resolverMeta
+        };
+      }
+      let dependentAsset = dependentAssets.find(a => a.uniqueKey === dep.specifier);
+      if (dependentAsset) {
+        depNode.complete = true;
+        depNodesWithAssets.push([depNode, nodeFromAsset(dependentAsset)]);
+      }
+      depNode.value.sourceAssetType = assetNode.value.type;
+      depNodeIds.push(this.addNode(depNode));
+    }
+    assetNode.usedSymbolsUpDirty = true;
+    assetNode.usedSymbolsDownDirty = true;
+    this.replaceNodeIdsConnectedTo(this.getNodeIdByContentKey(assetNode.id), depNodeIds);
+    for (let [depNode, dependentAssetNode] of depNodesWithAssets) {
+      let depAssetNodeId = this.addNode(dependentAssetNode);
+      this.replaceNodeIdsConnectedTo(this.getNodeIdByContentKey(depNode.id), [depAssetNodeId]);
+    }
+  }
+  getIncomingDependencies(asset) {
+    let nodeId = this.getNodeIdByContentKey(asset.id);
+    let assetGroupIds = this.getNodeIdsConnectedTo(nodeId);
+    let dependencies = [];
+    for (let i = 0; i < assetGroupIds.length; i++) {
+      let assetGroupId = assetGroupIds[i];
+
+      // Sometimes assets are connected directly to dependencies
+      // rather than through an asset group. This happens due to
+      // inline dependencies on assets via uniqueKey. See resolveAsset.
+      let node = this.getNode(assetGroupId);
+      if ((node === null || node === void 0 ? void 0 : node.type) === 'dependency') {
+        dependencies.push(node.value);
+        continue;
+      }
+      let assetIds = this.getNodeIdsConnectedTo(assetGroupId);
+      for (let j = 0; j < assetIds.length; j++) {
+        let node = this.getNode(assetIds[j]);
+        if (!node || node.type !== 'dependency') {
+          continue;
+        }
+        dependencies.push(node.value);
+      }
+    }
+    return dependencies;
+  }
+  traverseAssets(visit, startNodeId) {
+    return this.filteredTraverse(nodeId => {
+      let node = (0, _nullthrows().default)(this.getNode(nodeId));
+      return node.type === 'asset' ? node.value : null;
+    }, visit, startNodeId);
+  }
+  getEntryAssetGroupNodes() {
+    let entryNodes = [];
+    this.traverse((nodeId, _, actions) => {
+      let node = (0, _nullthrows().default)(this.getNode(nodeId));
+      if (node.type === 'asset_group') {
+        entryNodes.push(node);
+        actions.skipChildren();
+      }
+    });
+    return entryNodes;
+  }
+  getEntryAssets() {
+    let entries = [];
+    this.traverseAssets((asset, ctx, traversal) => {
+      entries.push(asset);
+      traversal.skipChildren();
+    });
+    return entries;
+  }
+  getHash() {
+    if (this.hash != null) {
+      return this.hash;
+    }
+    let hash = new (_rust().Hash)();
+    // TODO: sort??
+    this.traverse(nodeId => {
+      let node = (0, _nullthrows().default)(this.getNode(nodeId));
+      if (node.type === 'asset') {
+        hash.writeString((0, _nullthrows().default)(node.value.outputHash));
+      } else if (node.type === 'dependency' && node.value.target) {
+        hash.writeString(JSON.stringify(node.value.target));
+      }
+    });
+    this.hash = hash.finish();
+    return this.hash;
+  }
+}
+exports.default = AssetGraph;