@1stg/rollup-config/lib/es2015.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
}), 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 = filepath => {
  var ext = EXTENSIONS.find(ext => fs.existsSync(filepath + ext));
  return ext ? filepath + ext : filepath;
};

var configBase = function configBase() {
  var {
    formats,
    monorepo,
    input,
    outputDir = 'lib',
    exports,
    externals = [],
    globals: umdGlobals,
    prod = process.env.NODE_ENV === PRODUCTION
  } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
  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, 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 {
      name,
      engines: {
        node
      } = {},
      dependencies = {},
      peerDependencies = {}
    } = require(path.resolve(pkgPath, 'package.json'));

    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((pkgGlobals, pkg) => {
      if (pkgGlobals[pkg] == null) {
        pkgGlobals[pkg] = upperCamelCase(normalizePkg(pkg));
      }

      return pkgGlobals;
    }, globals);

    return pkgFormats.map(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,
          exports
        },
        external: id => _external.some(pkg => 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;