@parcel/core/lib/ConfigLoader.js

"use strict";

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

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

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

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

var _logger = require("@parcel/logger");

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

var _InternalConfig = require("./InternalConfig");

var _Config = _interopRequireDefault(require("./public/Config"));

var _loadParcelConfig = _interopRequireDefault(require("./loadParcelConfig"));

var _loadParcelPlugin = _interopRequireDefault(require("./loadParcelPlugin"));

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

class ConfigLoader {
  constructor(options) {
    _defineProperty(this, "options", void 0);

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

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

    this.options = options;
    this.queue = new _utils.PromiseQueue({
      maxConcurrent: 32
    });
  }

  load(configRequest) {
    let promise = this.queue.add(() => this._load(configRequest));
    this.queue.run();
    return promise;
  }

  _load(configRequest) {
    if (!configRequest.plugin) {
      return this.loadParcelConfig(configRequest);
    }

    return this.loadPluginConfig(configRequest);
  }

  async loadParcelConfig(configRequest) {
    let {
      filePath,
      isSource,
      env,
      pipeline
    } = configRequest;
    let dir = isSource ? _path.default.dirname(filePath) : this.options.projectRoot;

    let searchPath = _path.default.join(dir, 'index');

    let config = (0, _InternalConfig.createConfig)({
      isSource,
      searchPath,
      env
    });
    let publicConfig = new _Config.default(config, this.options);
    let {
      config: parcelConfig,
      extendedFiles
    } = (0, _nullthrows.default)((await (0, _loadParcelConfig.default)(searchPath, this.options)));
    publicConfig.setResolvedPath(parcelConfig.filePath);
    publicConfig.setResult(parcelConfig.getConfig());
    this.parcelConfig = parcelConfig;
    let devDeps = [];

    switch (configRequest.meta.actionType) {
      case 'transformation':
        devDeps = parcelConfig.getTransformerNames(filePath, pipeline);
        break;

      case 'validation':
        devDeps = parcelConfig.getValidatorNames(filePath);
        break;

      case 'dependency':
        devDeps = parcelConfig.getResolverNames();
        break;
    }

    devDeps.forEach(devDep => publicConfig.addDevDependency(devDep));
    publicConfig.setResultHash((0, _utils.md5FromString)(JSON.stringify(devDeps)));
    publicConfig.setWatchGlob('**/.parcelrc'); // TODO: if extended config comes from a package, yarn.lock change should invalidate config request

    for (let extendedFile of extendedFiles) {
      publicConfig.addIncludedFile(extendedFile);
    }

    return config;
  }

  async loadPluginConfig({
    plugin,
    env,
    isSource,
    filePath,
    meta: {
      parcelConfigPath
    }
  }) {
    let config = (0, _InternalConfig.createConfig)({
      isSource,
      searchPath: filePath,
      env
    });
    (0, _assert.default)(typeof parcelConfigPath === 'string');
    let pluginInstance = await (0, _loadParcelPlugin.default)(this.options.packageManager, (0, _nullthrows.default)(plugin), parcelConfigPath);

    if (pluginInstance.loadConfig != null) {
      await pluginInstance.loadConfig({
        config: new _Config.default(config, this.options),
        options: this.options,
        logger: new _logger.PluginLogger({
          origin: (0, _nullthrows.default)(plugin)
        })
      });
    }

    return config;
  }

}

exports.default = ConfigLoader;