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

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

var info = debug('r:info');
var PRODUCTION = 'production';
var STYLE_EXTENSIONS = ['.css', '.less', 'sass', '.scss', '.styl', '.stylus'];
var IMAGE_EXTENSIONS = ['.gif', '.jpeg', '.jpg', '.png', '.svg', '.webp'];
var ASSETS_EXTENSIONS = STYLE_EXTENSIONS.concat(IMAGE_EXTENSIONS);

var resolve = function resolve() {
  var {
    deps,
    node
  } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
  return nodeResolve({
    dedupe: node ? undefined : deps,
    mainFields: [!node && 'browser', 'esnext', 'es2015', 'esm2015', 'fesm2015', 'esm5', 'fesm5', 'module', 'jsnext:main', 'main'].filter(Boolean)
  });
};

var cjs = sourceMap => commonjs({
  // TODO: add package @pkgr/cjs-ignore ?
  // see also: https://github.com/rollup/rollup-plugin-commonjs/issues/244#issuecomment-536168280
  // hard-coded temporarily
  ignore: ['react-draggable'],
  namedExports,
  sourceMap
});

var BASIC_PLUGINS = [json(), url({
  include: IMAGE_EXTENSIONS.map(ext => "**/*".concat(ext))
})];
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 tryRegExp = exp => {
  if (typeof exp !== 'string' || !(exp = exp.trim())) {
    return exp;
  }

  var matched = /^\/(.*)\/([gimsuy]*)$/.exec(exp);

  if (matched) {
    try {
      return new RegExp(matched[1], matched[2]);
    } catch (_unused) {}
  }

  return exp;
};

var onwarn = (warning, warn) => {
  if (warning.code === 'THIS_IS_UNDEFINED') {
    return;
  }

  warn(warning);
};

var config = function config() {
  var {
    formats,
    monorepo,
    input,
    outputDir = 'lib',
    exports,
    externals = [],
    globals: umdGlobals,
    aliases = [],
    sourceMap = false,
    postcss: postcssOpts,
    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 deps = Object.keys(dependencies);

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

    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 + '/')),
        onwarn,
        plugins: [alias({
          resolve: EXTENSIONS.concat(ASSETS_EXTENSIONS),
          entries: Array.isArray(aliases) ? aliases.map((_ref) => {
            var {
              find,
              replacement
            } = _ref;
            return {
              find: tryRegExp(find),
              replacement
            };
          }) : Object.entries(aliases).map((_ref2) => {
            var [find, replacement] = _ref2;
            return {
              find: tryRegExp(find),
              replacement
            };
          })
        }), isTsAvailable && isTsInput ? typescript({
          target: isEsVersion ? format : 'es5'
        }) : babel({
          exclude: ['*.min.js', '*.production.js'],
          presets: [['@babel/preset-env', isEsVersion ? {
            targets: {
              esmodules: true
            }
          } : undefined]]
        })].concat(!node && [nodeGlobals(), nodeBuiltins({
          crypto: true
        })], resolve({
          deps,
          node: !!node
        }), cjs(sourceMap), BASIC_PLUGINS, postcss(postcssOpts), prod && [replace({
          'process.env.NODE_ENV': JSON.stringify(PRODUCTION)
        }), terser()]).filter(Boolean)
      };
    });
  });
  console.assert(configs.length, "No configuration resolved, mark sure you've setup correctly");
  return configs;
};

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

export default config$1;