@parcel/core/lib/AssetGraph.js

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.nodeFromDep = nodeFromDep;
exports.nodeFromAssetGroup = nodeFromAssetGroup;
exports.nodeFromAsset = nodeFromAsset;
exports.nodeFromEntrySpecifier = nodeFromEntrySpecifier;
exports.nodeFromEntryFile = nodeFromEntryFile;
exports.default = void 0;

var _assert = _interopRequireDefault(require("assert"));

var _crypto = _interopRequireDefault(require("crypto"));

var _utils = require("@parcel/utils");

var _Graph = _interopRequireDefault(require("./Graph"));

var _Dependency = require("./Dependency");

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

function nodeFromDep(dep) {
  return {
    id: dep.id,
    type: 'dependency',
    value: dep
  };
}

function nodeFromAssetGroup(assetGroup, deferred = false) {
  return {
    id: (0, _utils.md5FromObject)(assetGroup),
    type: 'asset_group',
    value: assetGroup,
    deferred
  };
}

function nodeFromAsset(asset) {
  return {
    id: asset.id,
    type: 'asset',
    value: asset
  };
}

function nodeFromEntrySpecifier(entry) {
  return {
    id: 'entry_specifier:' + entry,
    type: 'entry_specifier',
    value: entry
  };
}

function nodeFromEntryFile(entry) {
  return {
    id: 'entry_file:' + (0, _utils.md5FromObject)(entry),
    type: 'entry_file',
    value: entry
  };
} // Types that are considered incomplete when they don't have a child node


const INCOMPLETE_TYPES = ['entry_specifier', 'entry_file', 'dependency', 'asset_group'];

class AssetGraph extends _Graph.default {
  constructor(...args) {
    super(...args);

    _defineProperty(this, "onNodeAdded", void 0);

    _defineProperty(this, "onNodeRemoved", void 0);

    _defineProperty(this, "onIncompleteNode", void 0);

    _defineProperty(this, "incompleteNodeIds", new Set());

    _defineProperty(this, "hash", void 0);
  }

  // $FlowFixMe
  static deserialize(opts) {
    let res = new AssetGraph(opts);
    res.incompleteNodeIds = opts.incompleteNodeIds;
    res.hash = opts.hash;
    return res;
  } // $FlowFixMe


  serialize() {
    return _objectSpread({}, super.serialize(), {
      incompleteNodeIds: this.incompleteNodeIds,
      hash: this.hash
    });
  }

  initOptions({
    onNodeAdded,
    onNodeRemoved,
    onIncompleteNode
  } = {}) {
    this.onNodeAdded = onNodeAdded;
    this.onNodeRemoved = onNodeRemoved;
    this.onIncompleteNode = onIncompleteNode;
  }

  initialize({
    entries,
    assetGroups
  }) {
    let rootNode = {
      id: '@@root',
      type: 'root',
      value: null
    };
    this.setRootNode(rootNode);
    let nodes = [];

    if (entries) {
      for (let entry of entries) {
        let node = nodeFromEntrySpecifier(entry);
        nodes.push(node);
      }
    } else if (assetGroups) {
      nodes.push(...assetGroups.map(assetGroup => nodeFromAssetGroup(assetGroup)));
    }

    this.replaceNodesConnectedTo(rootNode, nodes);
  }

  addNode(node) {
    this.hash = null;
    let existingNode = this.getNode(node.id);

    if (INCOMPLETE_TYPES.includes(node.type) && !node.complete && !node.deferred && (!existingNode || existingNode.deferred)) {
      this.markIncomplete(node);
    }

    this.onNodeAdded && this.onNodeAdded(node);
    return super.addNode(node);
  }

  removeNode(node) {
    this.hash = null;
    this.incompleteNodeIds.delete(node.id);
    this.onNodeRemoved && this.onNodeRemoved(node);
    return super.removeNode(node);
  }

  markIncomplete(node) {
    this.incompleteNodeIds.add(node.id);

    if (this.onIncompleteNode) {
      this.onIncompleteNode(node);
    }
  }

  hasIncompleteNodes() {
    return this.incompleteNodeIds.size > 0;
  }

  resolveEntry(entry, resolved) {
    let entrySpecifierNode = nodeFromEntrySpecifier(entry);
    let entryFileNodes = resolved.map(file => nodeFromEntryFile(file));
    this.replaceNodesConnectedTo(entrySpecifierNode, entryFileNodes);
    this.incompleteNodeIds.delete(entrySpecifierNode.id);
  }

  resolveTargets(entry, targets) {
    let depNodes = targets.map(target => nodeFromDep((0, _Dependency.createDependency)({
      moduleSpecifier: entry.filePath,
      pipeline: target.name,
      target: target,
      env: target.env,
      isEntry: true
    })));
    let entryNode = nodeFromEntryFile(entry);

    if (this.hasNode(entryNode.id)) {
      this.replaceNodesConnectedTo(entryNode, depNodes);
      this.incompleteNodeIds.delete(entryNode.id);
    }
  }

  resolveDependency(dependency, assetGroupNode) {
    let depNode = this.nodes.get(dependency.id);
    if (!depNode) return;
    this.incompleteNodeIds.delete(depNode.id);

    if (assetGroupNode) {
      this.replaceNodesConnectedTo(depNode, [assetGroupNode]);
    }
  }

  resolveAssetGroup(assetGroup, assets) {
    let assetGroupNode = nodeFromAssetGroup(assetGroup);
    this.incompleteNodeIds.delete(assetGroupNode.id);

    if (!this.hasNode(assetGroupNode.id)) {
      return;
    }

    let dependentAssetKeys = [];
    let assetObjects = [];

    for (let asset of assets) {
      let isDirect = !dependentAssetKeys.includes(asset.uniqueKey);
      let dependentAssets = [];

      for (let dep of asset.dependencies.values()) {
        let dependentAsset = assets.find(a => a.uniqueKey === dep.moduleSpecifier);

        if (dependentAsset) {
          dependentAssetKeys.push(dependentAsset.uniqueKey);
          dependentAssets.push(dependentAsset);
        }
      }

      assetObjects.push({
        assetNode: nodeFromAsset(asset),
        dependentAssets,
        isDirect
      });
    }

    this.replaceNodesConnectedTo(assetGroupNode, assetObjects.filter(a => a.isDirect).map(a => a.assetNode));

    for (let {
      assetNode,
      dependentAssets
    } of assetObjects) {
      this.resolveAsset(assetNode, dependentAssets);
    }
  }

  resolveAsset(assetNode, dependentAssets) {
    let depNodes = [];
    let depNodesWithAssets = [];

    for (let dep of assetNode.value.dependencies.values()) {
      var _this$nodes$get;

      let depNode = nodeFromDep(dep);
      depNodes.push((_this$nodes$get = this.nodes.get(depNode.id)) !== null && _this$nodes$get !== void 0 ? _this$nodes$get : depNode);
      let dependentAsset = dependentAssets.find(a => a.uniqueKey === dep.moduleSpecifier);

      if (dependentAsset) {
        depNode.complete = true;
        depNodesWithAssets.push([depNode, nodeFromAsset(dependentAsset)]);
      }
    }

    this.replaceNodesConnectedTo(assetNode, depNodes);

    for (let [depNode, dependentAssetNode] of depNodesWithAssets) {
      this.replaceNodesConnectedTo(depNode, [dependentAssetNode]);
    }
  }

  getIncomingDependencies(asset) {
    let node = this.getNode(asset.id);

    if (!node) {
      return [];
    }

    return this.findAncestors(node, node => node.type === 'dependency').map(node => {
      (0, _assert.default)(node.type === 'dependency');
      return node.value;
    });
  }

  traverseAssets(visit, startNode) {
    return this.filteredTraverse(node => node.type === 'asset' ? node.value : null, visit, startNode);
  }

  getEntryAssetGroupNodes() {
    let entryNodes = [];
    this.traverse((node, _, actions) => {
      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 = _crypto.default.createHash('md5'); // TODO: sort??


    this.traverse(node => {
      if (node.type === 'asset') {
        hash.update(node.value.outputHash);
      } else if (node.type === 'dependency' && node.value.target) {
        hash.update(JSON.stringify(node.value.target));
      }
    });
    this.hash = hash.digest('hex');
    return this.hash;
  }

}

exports.default = AssetGraph;