preconstruct/lib/project.js

"use strict";

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

var _sarcastic = _interopRequireDefault(require("sarcastic"));

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

var _prompt = require("./prompt");

var _pLimit = _interopRequireDefault(require("p-limit"));

var _resolveFrom = _interopRequireDefault(require("resolve-from"));

var _globby = _interopRequireDefault(require("globby"));

var fs = _interopRequireWildcard(require("fs-extra"));

var _item = require("./item");

var _package = require("./package");

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

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; 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; }

let unsafeRequire = require;
let askGlobalLimit = (0, _pLimit.default)(1);

class Project extends _item.Item {
  constructor(...args) {
    super(...args);

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

  get configPackages() {
    return (0, _sarcastic.default)(this._config.packages, _sarcastic.default.default(_sarcastic.default.arrayOf(_sarcastic.default.string), ["."]));
  } // probably gonna be irrelevant later but i want it for now


  get isBolt() {
    // we only want to return true when there is bolt config
    // AND no yarn workspaces config
    // because emotion has a bolt config and yarn workspaces
    // and if you have both, you probably want workspaces
    let hasBolt = !!this.json.bolt;
    let hasYarnWorkspaces = !!this.json.workspaces;
    return hasBolt && !hasYarnWorkspaces;
  }

  static async create(directory) {
    let filePath = _path.default.join(directory, "package.json");

    let contents = await fs.readFile(filePath, "utf-8");
    let project = new Project(filePath, contents);
    project.packages = await project._packages();
    return project;
  }

  get name() {
    return (0, _sarcastic.default)(this.json.name, _sarcastic.default.string);
  }

  set name(name) {
    this.json.name = name;
  }

  async _packages() {
    // suport bolt later probably
    // maybe lerna too though probably not
    if (!this._config.packages && this.json.workspaces) {
      let _workspaces;

      if (Array.isArray(this.json.workspaces)) {
        _workspaces = this.json.workspaces;
      } else if (Array.isArray(this.json.workspaces.packages)) {
        _workspaces = this.json.workspaces.packages;
      }

      let workspaces = (0, _sarcastic.default)(_workspaces, _sarcastic.default.arrayOf(_sarcastic.default.string));
      let packages = await (0, _prompt.promptInput)("what packages should preconstruct build?", this, workspaces.join(","));
      this._config.packages = packages.split(",");
      await this.save();
    }

    try {
      let filenames = await (0, _globby.default)(this.configPackages, {
        cwd: this.directory,
        onlyDirectories: true,
        absolute: true,
        expandDirectories: false
      });
      let packages = await Promise.all(filenames.map(async x => {
        let pkg = await _package.Package.create(x);
        pkg.project = this;
        return pkg;
      }));
      return packages;
    } catch (error) {
      if (error instanceof _sarcastic.default.AssertionError) {
        return [];
      }

      throw error;
    }
  }

  global(pkg) {
    if (this._config.globals !== undefined && this._config.globals[pkg]) {
      return this._config.globals[pkg];
    } else {
      try {
        let pkgJson = unsafeRequire((0, _resolveFrom.default)(this.directory, _path.default.join(pkg, "package.json")));

        if (pkgJson && pkgJson[_constants.PKG_JSON_CONFIG_FIELD] && pkgJson[_constants.PKG_JSON_CONFIG_FIELD].umdName) {
          return pkgJson[_constants.PKG_JSON_CONFIG_FIELD].umdName;
        }
      } catch (err) {
        if (err.code !== "MODULE_NOT_FOUND") {
          throw err;
        }
      }

      throw askGlobalLimit(() => (async () => {
        // if while we were waiting, that global was added, return
        if (this._config.globals !== undefined && this._config.globals[pkg]) {
          return;
        }

        let response = await (0, _prompt.promptInput)(`What should the umdName of ${pkg} be?`, this);

        this._addGlobal(pkg, response);

        await this.save();
      })());
    }
  }

  _addGlobal(pkg, name) {
    if (!this._config.globals) {
      this._config.globals = {};
    }

    this._config.globals[pkg] = name;
  }

}

exports.Project = Project;