@parcel/core/lib/EntryResolver.js

"use strict";

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

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

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

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 EntryResolver {
  constructor(options) {
    _defineProperty(this, "fs", void 0);

    this.fs = options.inputFS;
  }

  async resolveEntry(entry) {
    if ((0, _utils.isGlob)(entry)) {
      let files = await (0, _utils.glob)(entry, this.fs, {
        absolute: true,
        onlyFiles: false
      });
      let results = await Promise.all(files.map(f => this.resolveEntry(f)));
      return results.reduce((p, res) => ({
        entries: p.entries.concat(res.entries),
        files: p.files.concat(res.files)
      }), {
        entries: [],
        files: []
      });
    }

    let stat;

    try {
      stat = await this.fs.stat(entry);
    } catch (err) {
      throw new Error(`Entry ${entry} does not exist`);
    }

    if (stat.isDirectory()) {
      let pkg = await this.readPackage(entry);

      if (pkg && typeof pkg.source === 'string') {
        let source = _path.default.join(_path.default.dirname(pkg.filePath), pkg.source);

        try {
          stat = await this.fs.stat(source);
        } catch (err) {
          throw new Error(`${pkg.source} in ${_path.default.relative(this.fs.cwd(), pkg.filePath)}#source does not exist`);
        }

        if (!stat.isFile()) {
          throw new Error(`${pkg.source} in ${_path.default.relative(this.fs.cwd(), pkg.filePath)}#source is not a file`);
        }

        return {
          entries: [{
            filePath: source,
            packagePath: entry
          }],
          files: [{
            filePath: pkg.filePath
          }]
        };
      }

      throw new Error(`Could not find entry: ${entry}`);
    } else if (stat.isFile()) {
      return {
        entries: [{
          filePath: entry
        }],
        files: []
      };
    }

    throw new Error(`Unknown entry ${entry}`);
  }

  async readPackage(entry) {
    let content, pkg;

    let pkgFile = _path.default.join(entry, 'package.json');

    try {
      content = await this.fs.readFile(pkgFile, 'utf8');
    } catch (err) {
      return null;
    }

    try {
      pkg = JSON.parse(content);
    } catch (err) {
      throw new Error(`Error parsing ${_path.default.relative(this.fs.cwd(), pkgFile)}: ${err.message}`);
    }

    pkg.filePath = pkgFile;
    return pkg;
  }

}

exports.EntryResolver = EntryResolver;