preconstruct/lib/init.js

"use strict";

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

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

var _project = require("./project");

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

var _errors = require("./errors");

var _logger = require("./logger");

var _messages = require("./messages");

var _validate = require("./validate");

async function doInit(pkg) {
  pkg.entrypoints.forEach(entrypoint => {
    (0, _validate.validateEntrypointSource)(entrypoint);
  });

  if (pkg.entrypoints.every(entrypoint => (0, _validate.isMainFieldValid)(entrypoint))) {
    (0, _logger.info)(_messages.infos.validMainField, pkg.name);
  } else {
    let canWriteMainField = await _messages.confirms.writeMainField(pkg);

    if (!canWriteMainField) {
      throw new _errors.FatalError(_messages.errors.deniedWriteMainField, pkg.name);
    }

    pkg.setFieldOnEntrypoints("main");
  }

  let allEntrypointsAreMissingAModuleField = pkg.entrypoints.every(entrypoint => entrypoint.module === null);
  let someEntrypointsAreNotValid = pkg.entrypoints.some(entrypoint => !(0, _validate.isModuleFieldValid)(entrypoint));

  if (allEntrypointsAreMissingAModuleField || someEntrypointsAreNotValid) {
    let canWriteModuleField = await _messages.confirms.writeModuleField(pkg);

    if (canWriteModuleField) {
      pkg.setFieldOnEntrypoints("module");
    } else if (!allEntrypointsAreMissingAModuleField) {
      throw new _errors.FixableError(_messages.errors.invalidModuleField, pkg.name);
    }
  } else {
    (0, _logger.info)(_messages.infos.validModuleField, pkg.name);
  }

  let someEntrypointsHaveAMaybeInvalidUmdBuild = pkg.entrypoints.some(entrypoint => entrypoint.umdMain !== null);
  let someUmdMainFieldsAreInvalid = pkg.entrypoints.some(entrypoint => !(0, _validate.isUmdMainFieldValid)(entrypoint));
  let someUmdNamesAreNotSpecified = pkg.entrypoints.some(entrypoint => !(0, _validate.isUmdNameSpecified)(entrypoint));

  if (someEntrypointsHaveAMaybeInvalidUmdBuild && (someUmdMainFieldsAreInvalid || someUmdNamesAreNotSpecified)) {
    let shouldWriteUMDBuilds = await _messages.confirms.fixUmdBuild(pkg);

    if (shouldWriteUMDBuilds) {
      pkg.setFieldOnEntrypoints("umdMain");

      for (let entrypoint of pkg.entrypoints) {
        let umdName = await (0, _prompt.promptInput)(_messages.inputs.getUmdName, entrypoint);
        entrypoint.umdName = umdName;
      }
    } else {
      throw new _errors.FixableError(_messages.errors.invalidUmdMainField, pkg.name);
    }
  }

  let someEntrypointsHaveABrowserField = pkg.entrypoints.some(entrypoint => entrypoint.browser !== null);
  let someEntrypointsHaveAnInvalidBrowserField = pkg.entrypoints.some(entrypoint => !(0, _validate.isBrowserFieldValid)(entrypoint));

  if (someEntrypointsHaveABrowserField && someEntrypointsHaveAnInvalidBrowserField) {
    let shouldFixBrowserField = await _messages.confirms.fixBrowserField(pkg);

    if (shouldFixBrowserField) {
      pkg.setFieldOnEntrypoints("browser");
    } else {
      throw new _errors.FixableError(_messages.errors.invalidBrowserField, pkg.name);
    }
  }

  await Promise.all(pkg.entrypoints.map(x => x.save()));
}

async function init(directory) {
  let project = await _project.Project.create(directory);
  await Promise.all(project.packages.map(doInit));
  (0, _logger.success)("initialised project!");
}