@1stg/rollup-config/lib/esm.js

import fs from 'fs';
import path from 'path';
import builtins from 'builtin-modules';
import debug from 'debug';
import { flatMap } from 'lodash';
import { terser } from 'rollup-plugin-terser';
import babel from 'rollup-plugin-babel';
import commonjs from 'rollup-plugin-commonjs';
import json from 'rollup-plugin-json';
import replace from 'rollup-plugin-replace';
import nodeResolve from 'rollup-plugin-node-resolve';
import typescript from 'rollup-plugin-typescript';
import { getGlobals, upperCamelCase, normalizePkg } from '@pkgr/umd-globals';
import { namedExports } from '@pkgr/named-exports';

var info = debug('r:info');
var PRODUCTION = 'production';
var BASIC_PLUGINS = [nodeResolve({
  mainFields: ['esnext', 'es2015', 'esm2015', 'fesm2015', 'esm5', 'fesm5', 'module', 'main']
}), commonjs({
  namedExports: namedExports
}), json()];
var DEFAULT_FORMATS = ['cjs', 'es2015', 'esm'];
var isTsAvailable = false;

try {
  isTsAvailable = !!require.resolve('typescript');
} catch (e) {} // eslint-disable-next-line node/no-deprecated-api


var EXTENSIONS = Object.keys(require.extensions);

if (isTsAvailable) {
  EXTENSIONS.unshift('.ts', '.tsx');
}

var tryExtensions = function tryExtensions(filepath) {
  var ext = EXTENSIONS.find(function (ext) {
    return fs.existsSync(filepath + ext);
  });
  return ext ? filepath + ext : filepath;
};

var configBase = function configBase() {
  var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
      formats = _ref.formats,
      monorepo = _ref.monorepo,
      input = _ref.input,
      _ref$outputDir = _ref.outputDir,
      outputDir = _ref$outputDir === void 0 ? 'lib' : _ref$outputDir,
      exports = _ref.exports,
      _ref$externals = _ref.externals,
      externals = _ref$externals === void 0 ? [] : _ref$externals,
      umdGlobals = _ref.globals,
      _ref$prod = _ref.prod,
      prod = _ref$prod === void 0 ? process.env.NODE_ENV === PRODUCTION : _ref$prod;

  var pkgsPath = path.resolve(typeof monorepo === 'string' ? monorepo : 'packages');

  if (monorepo !== false) {
    monorepo = fs.existsSync(pkgsPath);
  }

  var pkgs = monorepo ? fs.readdirSync(pkgsPath) : [''];
  var globals = getGlobals({
    globals: umdGlobals
  });
  var configs = flatMap(pkgs, function (pkg) {
    var pkgPath = path.resolve(monorepo ? pkgsPath : '', pkg);
    var srcPath = path.resolve(pkgPath, 'src');
    var pkgInput = input;
    var pkgOutputDir = outputDir;

    if (!fs.existsSync(srcPath) && pkgInput == null) {
      pkgInput = 'index';
    }

    pkgInput = tryExtensions(path.resolve(pkgPath, pkgInput || 'src/index'));
    var isAbsolute = path.isAbsolute(pkgInput);

    if (pkgOutputDir && !pkgOutputDir.endsWith('/')) {
      pkgOutputDir = pkgOutputDir + '/';
    }

    if (!fs.existsSync(pkgInput) || isAbsolute && !pkgInput.startsWith(pkgPath)) {
      return [];
    }

    var _require = require(path.resolve(pkgPath, 'package.json')),
        name = _require.name,
        _require$engines = _require.engines;

    _require$engines = _require$engines === void 0 ? {} : _require$engines;
    var node = _require$engines.node,
        _require$dependencies = _require.dependencies,
        dependencies = _require$dependencies === void 0 ? {} : _require$dependencies,
        _require$peerDependen = _require.peerDependencies,
        peerDependencies = _require$peerDependen === void 0 ? {} : _require$peerDependen;

    var _external = externals.concat(Object.keys(peerDependencies), node ? Object.keys(dependencies).concat(builtins) : []);

    var isTsInput = /\.tsx?/.test(pkgInput);
    var pkgFormats = formats && formats.length ? formats : DEFAULT_FORMATS.concat(node ? [] : 'umd');

    var pkgGlobals = _external.reduce(function (pkgGlobals, pkg) {
      if (pkgGlobals[pkg] == null) {
        pkgGlobals[pkg] = upperCamelCase(normalizePkg(pkg));
      }

      return pkgGlobals;
    }, globals);

    return pkgFormats.map(function (format) {
      var isEsVersion = /^es(\d+|next)$/.test(format) && format !== 'es5';
      return {
        input: pkgInput,
        output: {
          file: path.resolve(pkgPath, "".concat(pkgOutputDir).concat(format).concat(prod ? '.min' : '', ".js")),
          format: isEsVersion ? 'esm' : format,
          name: pkgGlobals[name] || upperCamelCase(normalizePkg(name)),
          globals: globals,
          exports: exports
        },
        external: function external(id) {
          return _external.some(function (pkg) {
            return id === pkg || id.startsWith(pkg + '/');
          });
        },
        plugins: [isTsAvailable && isTsInput ? typescript({
          target: isEsVersion ? format : 'es5'
        }) : babel({
          exclude: ['*.min.js', '*.production.js'],
          presets: [['@babel/preset-env', isEsVersion ? {
            targets: {
              esmodules: true
            }
          } : undefined]]
        })].concat(BASIC_PLUGINS, prod ? [replace({
          'process.env.NODE_ENV': JSON.stringify(PRODUCTION)
        }), terser()] : [])
      };
    });
  });
  console.assert(configs.length, "No configuration resolved, mark sure you've setup correctly");
  return configs;
};

var config = (function () {
  var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
  var configs = configBase(options).concat(options.prod ? configBase(Object.assign({}, options, {
    prod: false
  })) : []);
  info('configs: %O', configs);
  return configs;
});

export default config;