@parcel/core/lib/AssetGraphBuilder.js

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = void 0;

var _events = _interopRequireDefault(require("events"));

var _nullthrows = _interopRequireDefault(require("nullthrows"));

var _path = _interopRequireDefault(require("path"));

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

var _AssetGraph = _interopRequireDefault(require("./AssetGraph"));

var _RequestTracker = _interopRequireWildcard(require("./RequestTracker"));

var _constants = require("./constants");

var _requests = require("./requests");

var _dumpGraphToGraphViz = _interopRequireDefault(require("./dumpGraphToGraphViz"));

function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }

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

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; }

const requestPriorities = [['entry_request'], ['target_request'], ['dep_path_request', 'asset_request']];

class AssetGraphBuilder extends _events.default {
  constructor(...args) {
    super(...args);

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

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

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

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

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

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

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

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

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

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

    _defineProperty(this, "changedAssets", new Map());

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

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

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

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

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

  async init({
    config,
    options,
    entries,
    name,
    assetRequests,
    workerFarm
  }) {
    this.options = options;
    this.assetRequests = [];
    let {
      minify,
      hot,
      scopeHoist
    } = options;
    this.cacheKey = (0, _utils.md5FromObject)({
      parcelVersion: _constants.PARCEL_VERSION,
      name,
      options: {
        minify,
        hot,
        scopeHoist
      },
      entries
    });
    this.queue = new _utils.PromiseQueue();
    this.runValidate = workerFarm.createHandle('runValidate');
    this.handle = workerFarm.createReverseHandle(() => {// Do nothing, this is here because there is a bug in `@parcel/workers`
    });
    let changes = await this.readFromCache();

    if (!changes) {
      this.assetGraph = new _AssetGraph.default();
      this.requestGraph = new _RequestTracker.RequestGraph();
    }

    this.assetGraph.initOptions({
      onNodeRemoved: node => this.handleNodeRemovedFromAssetGraph(node),
      onIncompleteNode: node => this.handleIncompleteNode(node)
    });
    let assetGraph = this.assetGraph;
    this.requestTracker = new _RequestTracker.default({
      graph: this.requestGraph
    });
    let tracker = this.requestTracker;
    this.entryRequestRunner = new _requests.EntryRequestRunner({
      tracker,
      options,
      assetGraph
    });
    this.targetRequestRunner = new _requests.TargetRequestRunner({
      tracker,
      options,
      assetGraph
    });
    this.assetRequestRunner = new _requests.AssetRequestRunner({
      tracker,
      options,
      workerFarm,
      assetGraph
    });
    this.depPathRequestRunner = new _requests.DepPathRequestRunner({
      tracker,
      options,
      config,
      assetGraph
    });

    if (changes) {
      this.requestGraph.invalidateUnpredictableNodes();
      this.requestTracker.respondToFSEvents(changes);
    } else {
      this.assetGraph.initialize({
        entries,
        assetGroups: assetRequests
      });
    }
  }

  async build(signal) {
    let lastQueueError;

    for (let currPriorities of requestPriorities) {
      if (!this.requestTracker.hasInvalidRequests()) {
        break;
      }

      let promises = [];

      for (let request of this.requestTracker.getInvalidRequests()) {
        // $FlowFixMe
        if (currPriorities.includes(request.type)) {
          promises.push(this.runRequest(request, {
            signal
          }));
        }
      }

      await Promise.all(promises);

      if (lastQueueError) {
        throw lastQueueError;
      }

      this.queue.run().catch(e => {
        lastQueueError = e;
      });
    }

    if (this.assetGraph.hasIncompleteNodes()) {
      for (let id of this.assetGraph.incompleteNodeIds) {
        this.processIncompleteAssetGraphNode((0, _nullthrows.default)(this.assetGraph.getNode(id)), signal);
      }

      await this.queue.run();
    }

    (0, _dumpGraphToGraphViz.default)(this.assetGraph, 'AssetGraph');
    (0, _dumpGraphToGraphViz.default)(this.requestGraph, 'RequestGraph');
    let changedAssets = this.changedAssets;
    this.changedAssets = new Map();
    return {
      assetGraph: this.assetGraph,
      changedAssets: changedAssets
    };
  }

  async validate() {
    let promises = this.assetRequests.map(request => this.runValidate({
      request,
      options: this.options
    }));
    this.assetRequests = [];
    await Promise.all(promises);
  }

  async runRequest(request, runOpts) {
    switch (request.type) {
      case 'entry_request':
        return this.entryRequestRunner.runRequest(request.request, runOpts);

      case 'target_request':
        return this.targetRequestRunner.runRequest(request.request, runOpts);

      case 'dep_path_request':
        return this.depPathRequestRunner.runRequest(request.request, runOpts);

      case 'asset_request':
        {
          this.assetRequests.push(request.request);
          let result = await this.assetRequestRunner.runRequest(request.request, runOpts);

          if (result != null) {
            for (let asset of result.assets) {
              this.changedAssets.set(asset.id, asset); // ? Is this right?
            }
          }

          return result;
        }
    }
  }

  getCorrespondingRequest(node) {
    switch (node.type) {
      case 'entry_specifier':
        {
          let type = 'entry_request';
          return {
            type,
            request: node.value,
            id: (0, _RequestTracker.generateRequestId)(type, node.value)
          };
        }

      case 'entry_file':
        {
          let type = 'target_request';
          return {
            type,
            request: node.value,
            id: (0, _RequestTracker.generateRequestId)(type, node.value)
          };
        }

      case 'dependency':
        {
          let type = 'dep_path_request';
          return {
            type,
            request: node.value,
            id: (0, _RequestTracker.generateRequestId)(type, node.value)
          };
        }

      case 'asset_group':
        {
          let type = 'asset_request';
          return {
            type,
            request: node.value,
            id: (0, _RequestTracker.generateRequestId)(type, node.value)
          };
        }
    }
  }

  processIncompleteAssetGraphNode(node, signal) {
    let request = (0, _nullthrows.default)(this.getCorrespondingRequest(node));

    if (!this.requestTracker.isTracked(request.id)) {
      this.queue.add(() => this.runRequest(request, {
        signal
      })).catch(() => {// Do nothing, the individual promise is not being awaited, but the queue is and will throw
      });
    }
  }

  handleIncompleteNode(node) {
    this.processIncompleteAssetGraphNode(node);
  }

  handleNodeRemovedFromAssetGraph(node) {
    let request = this.getCorrespondingRequest(node);

    if (request != null) {
      this.requestTracker.untrackRequest(request.id);
    }
  }

  respondToFSEvents(events) {
    return this.requestGraph.respondToFSEvents(events);
  }

  getWatcherOptions() {
    let vcsDirs = ['.git', '.hg'].map(dir => _path.default.join(this.options.projectRoot, dir));
    let ignore = [this.options.cacheDir, ...vcsDirs];
    return {
      ignore
    };
  }

  getCacheKeys() {
    let assetGraphKey = (0, _utils.md5FromString)(`${this.cacheKey}:assetGraph`);
    let requestGraphKey = (0, _utils.md5FromString)(`${this.cacheKey}:requestGraph`);
    let snapshotKey = (0, _utils.md5FromString)(`${this.cacheKey}:snapshot`);
    return {
      assetGraphKey,
      requestGraphKey,
      snapshotKey
    };
  }

  async readFromCache() {
    if (this.options.disableCache) {
      return null;
    }

    let {
      assetGraphKey,
      requestGraphKey,
      snapshotKey
    } = this.getCacheKeys();
    let assetGraph = await this.options.cache.get(assetGraphKey);
    let requestGraph = await this.options.cache.get(requestGraphKey);

    if (assetGraph && requestGraph) {
      this.assetGraph = assetGraph;
      this.requestGraph = requestGraph;
      let opts = this.getWatcherOptions();

      let snapshotPath = this.options.cache._getCachePath(snapshotKey, '.txt');

      return this.options.inputFS.getEventsSince(this.options.projectRoot, snapshotPath, opts);
    }

    return null;
  }

  async writeToCache() {
    if (this.options.disableCache) {
      return;
    }

    let {
      assetGraphKey,
      requestGraphKey,
      snapshotKey
    } = this.getCacheKeys();
    await this.options.cache.set(assetGraphKey, this.assetGraph);
    await this.options.cache.set(requestGraphKey, this.requestGraph);
    let opts = this.getWatcherOptions();

    let snapshotPath = this.options.cache._getCachePath(snapshotKey, '.txt');

    await this.options.inputFS.writeSnapshot(this.options.projectRoot, snapshotPath, opts);
  }

}

exports.default = AssetGraphBuilder;