preconstruct/lib/package.js

"use strict";

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

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

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

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

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

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

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

var _entrypoint = require("./entrypoint");

var _utils = require("./utils");

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

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

/*::
import {Project} from './project'
*/
class Package extends _item.Item {
  constructor(...args) {
    super(...args);

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

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

  get configEntrypoints() {
    return (0, _sarcastic.default)(this._config.entrypoints, _sarcastic.default.default(_sarcastic.default.arrayOf(_sarcastic.default.string), ["."]));
  }

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

    let contents = await fs.readFile(filePath, "utf-8");
    let pkg = new Package(filePath, contents);
    let entrypointDirectories = await (0, _globby.default)(pkg.configEntrypoints, {
      cwd: pkg.directory,
      onlyDirectories: true,
      absolute: true,
      expandDirectories: false
    });
    pkg.entrypoints = await Promise.all(entrypointDirectories.map(async directory => {
      let filename = _path.default.join(directory, "package.json");

      let contents = null;

      try {
        contents = await fs.readFile(filename, "utf-8");
      } catch (e) {
        if (e.code !== "ENOENT") {
          throw e;
        }
      }

      return {
        filename,
        contents
      };
    })).then(descriptors => {
      let getPlainEntrypointContent = () => {
        let plainEntrypointObj = {
          main: (0, _utils.getValidStringFieldContentForBuildType)("main", pkg.name)
        };

        for (let descriptor of descriptors) {
          if (descriptor.contents !== null) {
            let parsed = JSON.parse(descriptor.contents);

            for (let field of ["module", "umd:main"]) {
              if (parsed[field] !== undefined) {
                plainEntrypointObj[field] = (0, _utils.getValidStringFieldContentForBuildType)(field, pkg.name);
              }
            }

            for (let field of ["browser", "react-native"]) {
              if (parsed[field] !== undefined) {
                plainEntrypointObj[field] = (0, _utils.getValidObjectFieldContentForBuildType)(field, pkg.name, plainEntrypointObj.module !== undefined);
              }
            }
          }
        }

        let plainEntrypointContents = JSON.stringify(plainEntrypointObj);

        getPlainEntrypointContent = () => plainEntrypointContents;

        return plainEntrypointContents;
      };

      return Promise.all(descriptors.map(async ({
        filename,
        contents
      }) => {
        if (contents === null) {
          let shouldCreateEntrypointPkgJson = await _messages.confirms.createEntrypointPkgJson({
            name: _path.default.join(pkg.name, _path.default.relative(pkg.directory, directory))
          });

          if (!shouldCreateEntrypointPkgJson) {
            throw new _errors.FatalError(_messages.errors.noEntrypointPkgJson, _path.default.join(pkg.name, _path.default.relative(pkg.directory, directory)));
          }

          contents = getPlainEntrypointContent();
          await fs.writeFile(filename, contents);
        }

        return new _entrypoint.Entrypoint(filename, contents, pkg);
      }));
    });
    return pkg;
  }

  setFieldOnEntrypoints(field) {
    this.entrypoints.forEach(entrypoint => {
      switch (field) {
        case "main":
          {
            entrypoint.main = (0, _utils.getValidStringFieldContentForBuildType)("main", this.name);
            break;
          }

        case "module":
          {
            entrypoint.module = (0, _utils.getValidStringFieldContentForBuildType)("module", this.name);
            break;
          }

        case "browser":
          {
            entrypoint.browser = (0, _utils.getValidObjectFieldContentForBuildType)("browser", this.name, entrypoint.module !== null);
            break;
          }

        case "umdMain":
          {
            entrypoint.umdMain = (0, _utils.getValidStringFieldContentForBuildType)("umd:main", this.name);
            break;
          }

        case "reactNative":
          {
            entrypoint.reactNative = (0, _utils.getValidObjectFieldContentForBuildType)("react-native", this.name, entrypoint.module !== null);
            break;
          }
      }
    });
  }

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

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

  get dependencies() {
    return (0, _sarcastic.default)(this.json.dependencies, _sarcastic.default.maybe(_sarcastic.default.objectOf(_sarcastic.default.string)));
  }

  get peerDependencies() {
    return (0, _sarcastic.default)(this.json.peerDependencies, _sarcastic.default.maybe(_sarcastic.default.objectOf(_sarcastic.default.string)));
  }

}

exports.Package = Package;

class StrictPackage extends Package {
  constructor(...args) {
    super(...args);

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

}

exports.StrictPackage = StrictPackage;