rollup-plugin-multi-entry/dist/rollup-plugin-multi-entry.cjs.js

'use strict';

var glob = require('glob');
glob = 'default' in glob ? glob['default'] : glob;

var babelHelpers = {};

babelHelpers.slicedToArray = (function () {
  function sliceIterator(arr, i) {
    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"]) _i["return"]();
      } finally {
        if (_d) throw _e;
      }
    }

    return _arr;
  }

  return function (arr, i) {
    if (Array.isArray(arr)) {
      return arr;
    } else if (Symbol.iterator in Object(arr)) {
      return sliceIterator(arr, i);
    } else {
      throw new TypeError("Invalid attempt to destructure non-iterable instance");
    }
  };
})();

babelHelpers;
var entry = 'rollup-plugin-multi-entry:entry-point';

function multiEntry(config) {
  var include = [];
  var exclude = [];

  if (typeof config === 'string') {
    include = [config];
  } else if (Array.isArray(config)) {
    include = config;
  } else {
    include = config.include;
    exclude = config.exclude;
  }

  return {
    resolveId: function resolveId(id) {
      if (id === entry) {
        return entry;
      }
    },
    load: function load(id) {
      if (id === entry) {
        return Promise.all([matchPaths(include), matchPaths(exclude)]).then(function (_ref) {
          var _ref2 = babelHelpers.slicedToArray(_ref, 2);

          var includePaths = _ref2[0];
          var excludePaths = _ref2[1];

          return includePaths.filter(function (path) {
            return excludePaths.indexOf(path) < 0;
          });
        }).then(function (paths) {
          return paths.map(function (path) {
            return 'export * from ' + JSON.stringify(path) + ';';
          }).join('\n');
        });
      }
    }
  };
}

function matchPaths(patterns) {
  return Promise.all(patterns.map(function (pattern) {
    return new Promise(function (resolve, reject) {
      return glob(pattern, { realpath: true }, function (err, files) {
        if (err) {
          reject(err);
        } else {
          resolve(files);
        }
      });
    });
  })).then(function (lists) {
    return lists.reduce(function (result, list) {
      return result.concat(list);
    }, []);
  });
}

exports.entry = entry;
exports['default'] = multiEntry;