@1stg/rollup-config/lib/esm.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';

function _slicedToArray(arr, i) {
  return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest();
}

function _arrayWithHoles(arr) {
  if (Array.isArray(arr)) return arr;
}

function _iterableToArrayLimit(arr, i) {
  if (!(Symbol.iterator in Object(arr) || Object.prototype.toString.call(arr) === "[object Arguments]")) {
    return;
  }

  var _arr = [];
  var _n = true;
  var _d = false;
  var _e = undefined;

  try {
    for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
      _arr.push(_s.value);

      if (i && _arr.length === i) break;
    }
  } catch (err) {
    _d = true;
    _e = err;
  } finally {
    try {
      if (!_n && _i["return"] != null) _i["return"]();
    } finally {
      if (_d) throw _e;
    }
  }

  return _arr;
}

function _nonIterableRest() {
  throw new TypeError("Invalid attempt to destructure non-iterable instance");
}

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 _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
      deps = _ref.deps,
      node = _ref.node;

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

var cjs = function cjs(sourceMap) {
  return 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: namedExports,
    sourceMap: sourceMap
  });
};

var BASIC_PLUGINS = [json(), url({
  include: IMAGE_EXTENSIONS.map(function (ext) {
    return "**/*".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 = function tryExtensions(filepath) {
  var ext = EXTENSIONS.find(function (ext) {
    return fs.existsSync(filepath + ext);
  });
  return ext ? filepath + ext : filepath;
};

var tryRegExp = function 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 = function onwarn(warning, warn) {
  if (warning.code === 'THIS_IS_UNDEFINED') {
    return;
  }

  warn(warning);
};

var config = function config() {
  var _ref2 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
      formats = _ref2.formats,
      monorepo = _ref2.monorepo,
      input = _ref2.input,
      _ref2$outputDir = _ref2.outputDir,
      outputDir = _ref2$outputDir === void 0 ? 'lib' : _ref2$outputDir,
      exports = _ref2.exports,
      _ref2$externals = _ref2.externals,
      externals = _ref2$externals === void 0 ? [] : _ref2$externals,
      umdGlobals = _ref2.globals,
      _ref2$aliases = _ref2.aliases,
      aliases = _ref2$aliases === void 0 ? [] : _ref2$aliases,
      _ref2$sourceMap = _ref2.sourceMap,
      sourceMap = _ref2$sourceMap === void 0 ? false : _ref2$sourceMap,
      postcssOpts = _ref2.postcss,
      _ref2$prod = _ref2.prod,
      prod = _ref2$prod === void 0 ? process.env.NODE_ENV === PRODUCTION : _ref2$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 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(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 + '/');
          });
        },
        onwarn: onwarn,
        plugins: [alias({
          resolve: EXTENSIONS.concat(ASSETS_EXTENSIONS),
          entries: Array.isArray(aliases) ? aliases.map(function (_ref3) {
            var find = _ref3.find,
                replacement = _ref3.replacement;
            return {
              find: tryRegExp(find),
              replacement: replacement
            };
          }) : Object.entries(aliases).map(function (_ref4) {
            var _ref5 = _slicedToArray(_ref4, 2),
                find = _ref5[0],
                replacement = _ref5[1];

            return {
              find: tryRegExp(find),
              replacement: 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: 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;