webpack-babel-env-deps
Version:
Find dependencies to transpile with Babel.
511 lines (420 loc) • 17.7 kB
JavaScript
module.exports =
/******/ (function(modules) { // webpackBootstrap
/******/ // The module cache
/******/ var installedModules = {};
/******/
/******/ // The require function
/******/ function __webpack_require__(moduleId) {
/******/
/******/ // Check if module is in cache
/******/ if(installedModules[moduleId]) {
/******/ return installedModules[moduleId].exports;
/******/ }
/******/ // Create a new module (and put it into the cache)
/******/ var module = installedModules[moduleId] = {
/******/ i: moduleId,
/******/ l: false,
/******/ exports: {}
/******/ };
/******/
/******/ // Execute the module function
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/
/******/ // Flag the module as loaded
/******/ module.l = true;
/******/
/******/ // Return the exports of the module
/******/ return module.exports;
/******/ }
/******/
/******/
/******/ // expose the modules object (__webpack_modules__)
/******/ __webpack_require__.m = modules;
/******/
/******/ // expose the module cache
/******/ __webpack_require__.c = installedModules;
/******/
/******/ // define getter function for harmony exports
/******/ __webpack_require__.d = function(exports, name, getter) {
/******/ if(!__webpack_require__.o(exports, name)) {
/******/ Object.defineProperty(exports, name, { enumerable: true, get: getter });
/******/ }
/******/ };
/******/
/******/ // define __esModule on exports
/******/ __webpack_require__.r = function(exports) {
/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
/******/ }
/******/ Object.defineProperty(exports, '__esModule', { value: true });
/******/ };
/******/
/******/ // create a fake namespace object
/******/ // mode & 1: value is a module id, require it
/******/ // mode & 2: merge all properties of value into the ns
/******/ // mode & 4: return value when already ns object
/******/ // mode & 8|1: behave like require
/******/ __webpack_require__.t = function(value, mode) {
/******/ if(mode & 1) value = __webpack_require__(value);
/******/ if(mode & 8) return value;
/******/ if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
/******/ var ns = Object.create(null);
/******/ __webpack_require__.r(ns);
/******/ Object.defineProperty(ns, 'default', { enumerable: true, value: value });
/******/ if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
/******/ return ns;
/******/ };
/******/
/******/ // getDefaultExport function for compatibility with non-harmony modules
/******/ __webpack_require__.n = function(module) {
/******/ var getter = module && module.__esModule ?
/******/ function getDefault() { return module['default']; } :
/******/ function getModuleExports() { return module; };
/******/ __webpack_require__.d(getter, 'a', getter);
/******/ return getter;
/******/ };
/******/
/******/ // Object.prototype.hasOwnProperty.call
/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
/******/
/******/ // __webpack_public_path__
/******/ __webpack_require__.p = "";
/******/
/******/
/******/ // Load entry module and return exports
/******/ return __webpack_require__(__webpack_require__.s = 9);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ (function(module, exports) {
module.exports = require("semver");
/***/ }),
/* 1 */
/***/ (function(module, exports) {
module.exports = require("lodash");
/***/ }),
/* 2 */
/***/ (function(module, exports) {
module.exports = require("debug");
/***/ }),
/* 3 */
/***/ (function(module, exports) {
module.exports = require("read-pkg-up");
/***/ }),
/* 4 */
/***/ (function(module, exports) {
module.exports = require("@babel/preset-env/data/plugins");
/***/ }),
/* 5 */
/***/ (function(module, exports) {
module.exports = require("resolve-pkg");
/***/ }),
/* 6 */
/***/ (function(module, exports) {
module.exports = require("pkg-dir");
/***/ }),
/* 7 */
/***/ (function(module, exports) {
module.exports = require("path");
/***/ }),
/* 8 */
/***/ (function(module, exports) {
function webpackEmptyContext(req) {
var e = new Error("Cannot find module '" + req + "'");
e.code = 'MODULE_NOT_FOUND';
throw e;
}
webpackEmptyContext.keys = function() { return []; };
webpackEmptyContext.resolve = webpackEmptyContext;
module.exports = webpackEmptyContext;
webpackEmptyContext.id = 8;
/***/ }),
/* 9 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
;
// ESM COMPAT FLAG
__webpack_require__.r(__webpack_exports__);
// EXPORTS
__webpack_require__.d(__webpack_exports__, "getPluginSatisfiesModuleRange", function() { return /* binding */ getPluginSatisfiesModuleRange; });
__webpack_require__.d(__webpack_exports__, "getPluginsThatDontSatisfyModuleRange", function() { return /* binding */ getPluginsThatDontSatisfyModuleRange; });
__webpack_require__.d(__webpack_exports__, "getModuleNeedsBabel", function() { return /* binding */ getModuleNeedsBabel; });
__webpack_require__.d(__webpack_exports__, "esNextFields", function() { return /* binding */ esNextFields; });
__webpack_require__.d(__webpack_exports__, "isESNextField", function() { return /* binding */ isESNextField; });
__webpack_require__.d(__webpack_exports__, "getHasESNextField", function() { return /* binding */ getHasESNextField; });
__webpack_require__.d(__webpack_exports__, "getIndexOfESNextField", function() { return /* binding */ getIndexOfESNextField; });
__webpack_require__.d(__webpack_exports__, "isESNextFieldBeforeMainField", function() { return /* binding */ isESNextFieldBeforeMainField; });
__webpack_require__.d(__webpack_exports__, "getHasESNextInMainFields", function() { return /* binding */ getHasESNextInMainFields; });
__webpack_require__.d(__webpack_exports__, "getNeedBabel", function() { return /* binding */ getNeedBabel; });
__webpack_require__.d(__webpack_exports__, "getNeedBabelFromPackageAndDependencies", function() { return /* binding */ getNeedBabelFromPackageAndDependencies; });
__webpack_require__.d(__webpack_exports__, "exclude", function() { return /* binding */ src_exclude; });
__webpack_require__.d(__webpack_exports__, "include", function() { return /* binding */ src_include; });
// EXTERNAL MODULE: external "lodash"
var external_lodash_ = __webpack_require__(1);
var external_lodash_default = /*#__PURE__*/__webpack_require__.n(external_lodash_);
// EXTERNAL MODULE: external "semver"
var external_semver_ = __webpack_require__(0);
var external_semver_default = /*#__PURE__*/__webpack_require__.n(external_semver_);
// EXTERNAL MODULE: external "debug"
var external_debug_ = __webpack_require__(2);
var external_debug_default = /*#__PURE__*/__webpack_require__.n(external_debug_);
// EXTERNAL MODULE: external "read-pkg-up"
var external_read_pkg_up_ = __webpack_require__(3);
var external_read_pkg_up_default = /*#__PURE__*/__webpack_require__.n(external_read_pkg_up_);
// EXTERNAL MODULE: external "@babel/preset-env/data/plugins"
var plugins_ = __webpack_require__(4);
var plugins_default = /*#__PURE__*/__webpack_require__.n(plugins_);
// CONCATENATED MODULE: ./src/semver-min-for-range.js
function minForRange(range) {
return minForRangeHelper('0.0.0', range);
}
function dots(major, minor, patch) {
return `${major}.${minor}.${patch}`;
}
const max = 999999;
function minForRangeHelper(current, range) {
let major = external_semver_default.a.major(current);
let minor = external_semver_default.a.minor(current);
let patch = external_semver_default.a.patch(current);
let down;
while (!external_semver_default.a.satisfies(dots(major, 0, 0), range)) {
major++;
}
down = Math.max(major - 1, 0);
if (external_semver_default.a.satisfies(dots(down, max, max), range)) {
major = down;
}
while (!external_semver_default.a.satisfies(dots(major, minor, 0), range)) {
minor++;
}
down = Math.max(minor - 1, 0);
if (external_semver_default.a.satisfies(dots(major, down, max), range)) {
minor = down;
}
while (!external_semver_default.a.satisfies(dots(major, minor, patch), range)) {
patch++;
}
down = Math.max(patch - 1, 0);
if (external_semver_default.a.satisfies(dots(major, minor, down), range)) {
patch = down;
}
return dots(major, minor, patch);
}
// EXTERNAL MODULE: external "resolve-pkg"
var external_resolve_pkg_ = __webpack_require__(5);
var external_resolve_pkg_default = /*#__PURE__*/__webpack_require__.n(external_resolve_pkg_);
// EXTERNAL MODULE: external "pkg-dir"
var external_pkg_dir_ = __webpack_require__(6);
var external_pkg_dir_default = /*#__PURE__*/__webpack_require__.n(external_pkg_dir_);
// EXTERNAL MODULE: external "path"
var external_path_ = __webpack_require__(7);
var external_path_default = /*#__PURE__*/__webpack_require__.n(external_path_);
// CONCATENATED MODULE: ./src/non-webpack-require.js
// eslint-disable-next-line camelcase, no-undef
/* harmony default export */ var non_webpack_require = (path => typeof require !== 'undefined' ? require(path) : __webpack_require__(8)(path));
// CONCATENATED MODULE: ./src/require-package.js
function requirePackage(pkgRoot) {
const pkgPath = external_path_default.a.join(pkgRoot, 'package.json');
return non_webpack_require(pkgPath);
}
// CONCATENATED MODULE: ./src/package-walk.js
function walkDeps(deps, it, root) {
external_lodash_default.a.forEach(deps, (__, name) => {
let depPath;
try {
depPath = external_resolve_pkg_default()(name, {
cwd: root
});
} catch (err) {
// maybe `name` module doesn't have a `main` field in its `package.json`
console.error(name, err);
return;
}
walk(depPath, it);
});
}
function walk(pathInPkg, it) {
let pkgRoot;
try {
pkgRoot = external_pkg_dir_default.a.sync(pathInPkg);
} catch (err) {
console.error(pathInPkg, err);
return;
}
const pkg = requirePackage(pkgRoot);
if (it(pkg)) return;
walkDeps(pkg.dependencies, it, pkgRoot);
}
// CONCATENATED MODULE: ./src/get-dependencies.js
// TODO: Implement depth option.
function getDependencies(pathInPkg) {
const dependencies = {};
const it = pkg => {
if (Object.prototype.hasOwnProperty.call(dependencies, pkg.name)) return true;
dependencies[pkg.name] = pkg;
};
try {
walk(pathInPkg, it);
} catch (err) {
console.error(pathInPkg, err);
}
return dependencies;
}
// CONCATENATED MODULE: ./src/node-modules-regex.js
const sepRex = '(/|\\\\)';
function group(names) {
return `(${names.join('|')})`;
}
function excludeAsString(names, {
except
}) {
if (except) {
if (typeof except === 'string') names = names.slice().concat(except);else names = names.slice().concat(except);
}
return names.length === 0 ? `node_modules/.*` : `node_modules(?!${sepRex}${group(names)}${sepRex})`;
}
function includeAsString(names, {
except
}) {
const filterFn = name => {
if (typeof except === 'function') return !except(name);
if (typeof except === 'string') return except !== name;
return !external_lodash_default.a.includes(except, name);
};
return `node_modules${sepRex}${group(names.filter(filterFn))}${sepRex}.*`;
}
function includeAsRegExp(names, options) {
return new RegExp(includeAsString(names, options));
}
function excludeAsRegExp(names, options) {
return new RegExp(excludeAsString(names, options));
}
function include(names = [], options = {}) {
return includeAsRegExp(names, options);
}
function exclude(names = [], options = {}) {
return excludeAsRegExp(names, options);
}
/* harmony default export */ var node_modules_regex = (exclude);
// CONCATENATED MODULE: ./src/semver-normalize.js
function normalizeSemver(version) {
version = `${version}`;
const dots = version.split('.');
if (dots.length === 3) return version;
if (dots.length === 2) return `${version}.0`;
return `${version}.0.0`;
}
// CONCATENATED MODULE: ./src/index.js
function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
function getPluginSatisfiesModuleRange(plugin, range) {
const {
node
} = plugin;
if (!node) {
return true;
}
return external_semver_default.a.satisfies(normalizeSemver(node), range);
}
function getPluginsThatDontSatisfyModuleRange(plugins, range) {
return external_lodash_default.a.pickBy(plugins, plugin => !getPluginSatisfiesModuleRange(plugin, range));
}
function getModuleNeedsBabel(pkg, {
hasEsNextInMainFields,
hostEngines,
defaultEngines
} = {}) {
let {
engines
} = pkg;
const hasEsNextField = getHasESNextField(Object.keys(pkg)); // always transpile if we have an esnext field
if (hasEsNextInMainFields && hasEsNextField) {
return true;
}
if (!engines) {
if (defaultEngines) {
if (typeof defaultEngines !== 'object') {
return true;
}
engines = defaultEngines;
} else {
return false;
}
}
const range = engines.node;
if (!range) return false;
if (range === '*') return false;
if (hostEngines && hostEngines.node) {
const minVersionForEngines = minForRange(range);
const minVersionForHostEngines = minForRange(hostEngines.node);
return external_semver_default.a.gt(minVersionForEngines, minVersionForHostEngines);
}
const pluginsThatDontSatisfyModuleRange = getPluginsThatDontSatisfyModuleRange(plugins_default.a, range);
const namesOfPluginsThatDontSatisfyRange = external_lodash_default.a.map(pluginsThatDontSatisfyModuleRange, (plugin, name) => ({
name,
node: plugin.node
}));
const somePluginsDontSatisfyModuleRange = !external_lodash_default.a.isEmpty(pluginsThatDontSatisfyModuleRange);
if (somePluginsDontSatisfyModuleRange && external_debug_default.a.enabled) {
external_debug_default()('plugins')(`name "${pkg.name} range "${range}" doesn't satisfy plugins ` + `${namesOfPluginsThatDontSatisfyRange.map(p => `${p.name} ${p.node}`)}`);
}
return somePluginsDontSatisfyModuleRange;
}
/**
* `module` in webpack 3, maybe also `jsnext:main` in webpack 2
*/
const esNextFields = ['module', 'jsnext:main'];
const isESNextField = field => external_lodash_default.a.includes(esNextFields, field);
function getHasESNextField(mainFields = []) {
return mainFields.some(mainField => external_lodash_default.a.includes(esNextFields, mainField));
}
function getIndexOfESNextField(mainFields = []) {
return mainFields.findIndex(isESNextField);
}
function isESNextFieldBeforeMainField(mainFields = []) {
return mainFields.length >= 0 && (!external_lodash_default.a.includes(mainFields, 'main') || getHasESNextField(mainFields) && getIndexOfESNextField(mainFields) < mainFields.indexOf('main'));
}
function getHasESNextInMainFields(options = {}) {
const {
mainFields
} = options;
if (mainFields === false) return false;
const usesDefaultMainFields = !mainFields;
return usesDefaultMainFields || isESNextFieldBeforeMainField(mainFields);
}
function getNeedBabel(options) {
const pathInPkg = options.path || process.cwd();
const pkg = external_read_pkg_up_default.a.sync({
cwd: pathInPkg,
normalize: false // Support projects with invalid package versions.
});
const dependencies = getDependencies(pathInPkg, options);
return getNeedBabelFromPackageAndDependencies(pkg, dependencies, options);
}
function getNeedBabelFromPackageAndDependencies(pkg, dependencies, options) {
const hostEngines = options.engines === false ? null : typeof options.engines === 'object' && options.engines || pkg.engines;
const hasEsNextInMainFields = getHasESNextInMainFields(options);
const needBabel = external_lodash_default()(dependencies).map(pkg => _objectSpread(_objectSpread({}, pkg), {}, {
needsBabel: !!getModuleNeedsBabel(pkg, _objectSpread(_objectSpread({}, options), {}, {
hasEsNextInMainFields,
hostEngines
}))
})).compact().filter(({
needsBabel
}) => needsBabel).value(); // console.log(`Of ${_.size(modules)} modules, ${_.size(needBabel)} need babel`)
return needBabel.map(mod => mod.name).sort();
}
function src_exclude(options = {}) {
const names = getNeedBabel(options);
return exclude(names, options);
}
function src_include(options = {}) {
const names = getNeedBabel(options);
return include(names, options);
}
/* harmony default export */ var src = __webpack_exports__["default"] = ({
exclude: src_exclude
});
/***/ })
/******/ ]);