babelrc.ts

import { safeLocalRequire } from '@jgbjs/shared';
import { warning } from '@jgbjs/shared/lib/Logger';
import { localResolve } from '@jgbjs/shared/lib/utils';
import BabelAsset from 'BabelAsset';
import * as fs from 'fs';
import * as path from 'path';
import { promisify } from 'util';

const micromatch = require('micromatch');
const semver = require('semver');

async function loadPlugin(name: string, assetName: string) {
  const plugin = await safeLocalRequire(name, assetName, () => require(name));

  if (plugin && plugin.default) {
    return plugin.default;
  }
  return plugin;
}

export default async function getBabelConfig(
  asset: BabelAsset,
  isSource: boolean
) {
  let config = await getBabelRc(asset, isSource);
  if (!config) {
    return null;
  }

  // Ignore if the config is empty.
  if (
    (!config.plugins || config.plugins.length === 0) &&
    (!config.presets || config.presets.length === 0)
  ) {
    return null;
  }

  let plugins = await installPlugins(asset, config);
  let babelVersion = await getBabelVersion(asset, plugins);

  return {
    babelVersion,
    config
  };
}

/**
 * Finds a .babelrc for an asset. By default, .babelrc files inside node_modules are not used.
 * However, there are some exceptions:
 *   - if `browserify.transforms` includes "babelify" in package.json (for legacy module compat)
 *   - the `source` field in package.json is used by the resolver
 */
async function getBabelRc(asset, isSource) {
  // Support legacy browserify packages
  let pkg = await asset.getPackage();
  let browserify = pkg && pkg.browserify;
  if (browserify && Array.isArray(browserify.transform)) {
    // Look for babelify in the browserify transform list
    let babelify = browserify.transform.find(
      t => (Array.isArray(t) ? t[0] : t) === 'babelify'
    );

    // If specified as an array, override the config with the one specified
    if (Array.isArray(babelify) && babelify[1]) {
      return babelify[1];
    }

    // Otherwise, return the .babelrc if babelify was found
    return babelify ? await findBabelRc(asset) : null;
  }

  // If this asset is not in node_modules, always use the .babelrc
  if (isSource) {
    return await findBabelRc(asset);
  }

  // Otherwise, don't load .babelrc for node_modules.
  // See https://github.com/jgb-cli-bundler/jgb-cli/issues/13.
  return null;
}

async function findBabelRc(asset) {
  // TODO: use the babel API to do this config resolution and support all of its features.
  // This is not currently possible because babel tries to actually load plugins and presets
  // while resolving the config, but those plugins might not be installed yet.
  let config = await asset.getConfig(['.babelrc', '.babelrc.js'], {
    packageKey: 'babel'
  });

  if (!config) {
    return null;
  }

  if (typeof config === 'function') {
    // We cannot support function configs since there is no exposed method in babel
    // to create the API that is passed to them...
    throw new Error(
      'jgb-cli does not support function configs in .babelrc.js yet.'
    );
  }

  for (let key of ['extends', 'overrides', 'test', 'include', 'exclude']) {
    if (config[key]) {
      throw new Error(
        `jgb-cli does not support babel 7 advanced configuration option "${key}" yet.`
      );
    }
  }

  const { source, target, lib } = asset.options;

  // 但两个都指定值且不相同时
  const isDifferenceTarget = source && target && source !== target;

  // 移除node_modules相关的忽略
  config.ignore = generateIgnore(config.ignore || [], isDifferenceTarget);
  // Support ignore/only config options.
  if (shouldIgnore(asset, config)) {
    return null;
  }

  // Support .babelignore
  let ignoreConfig = await getIgnoreConfig(asset, isDifferenceTarget);
  if (ignoreConfig && shouldIgnore(asset, ignoreConfig)) {
    return null;
  }

  if (isDifferenceTarget) {
    config.plugins = [].concat(config.plugins, [
      [
        // require('babel-plugin-transform-miniprogram'),
        'babel-plugin-transform-miniprogram',
        {
          source,
          target,
          lib
        }
      ]
    ]);
  }

  return config;
}

async function getIgnoreConfig(asset, isDifferenceTarget = false) {
  let ignoreFile = await asset.getConfig(['.babelignore'], {
    load: false
  });

  if (!ignoreFile) {
    return null;
  }

  let data = await promisify(fs.readFile)(ignoreFile, 'utf8');
  let patterns = data
    .split('\n')
    .map(line => line.replace(/#.*$/, '').trim())
    .filter(Boolean);

  if (isDifferenceTarget) {
    // 移除node_modules相关的忽略
    patterns = patterns.filter(l => !l.includes('node_modules'));
  }

  return { ignore: patterns };
}

function shouldIgnore(asset, config) {
  if (config.ignore && matchesPatterns(config.ignore, asset.name)) {
    return true;
  }

  if (config.only && !matchesPatterns(config.only, asset.name)) {
    return true;
  }

  return false;
}

function matchesPatterns(patterns, path) {
  return patterns.some(pattern => {
    if (typeof pattern === 'function') {
      return !!pattern(path);
    }

    if (typeof pattern === 'string') {
      return micromatch.isMatch(path, '**/' + pattern + '/**');
    }

    return pattern.test(path);
  });
}

async function getBabelVersion(asset: BabelAsset, plugins) {
  // Check the package.json to determine the babel version that is installed
  let pkg = await asset.getPackage();
  let babelLegacy = getDependency(pkg, 'babel-core');
  let babelModern = getDependency(pkg, '@babel/core');

  if (babelModern) {
    return getMaxMajor(babelModern);
  }

  if (babelLegacy) {
    return 6;
  }

  // No version was installed. This is either an old app where we didn't require a version to be installed,
  // or a new app that just added a .babelrc without manually installing a version of babel core.
  // We will attempt to infer a verison of babel and install it based on the dependencies of the plugins
  // in the config. This should only happen once since we save babel core into package.json for subsequent runs.
  let inferred = await inferBabelVersion(asset, plugins);
  let name = inferred === 6 ? 'babel-core' : `@babel/core`;
  warning(`should install package [${name}]`);
  // await installPackage(name, asset.name);
  return inferred;
}

function getDependency(pkg, dep) {
  return (
    (pkg.dependencies && pkg.dependencies[dep]) ||
    (pkg.peerDependencies && pkg.peerDependencies[dep]) ||
    (pkg.devDependencies && pkg.devDependencies[dep])
  );
}

// Core babel packages we use to infer the major version of babel to use.
const CORE_DEPS = new Set([
  '@babel/core',
  '@babel/runtime',
  '@babel/template',
  '@babel/traverse',
  '@babel/types',
  '@babel/parser',
  '@babel/cli',
  '@babel/register',
  '@babel/generator',
  'babel-core',
  'babel-runtime',
  'babel-template',
  'babel-traverse',
  'babel-types',
  'babylon',
  'babel-cli',
  'babel-register',
  'babel-generator'
]);

async function inferBabelVersion(asset, plugins) {
  // Attempt to determine version based on dependencies of plugins
  let version;

  for (let pkg of plugins) {
    if (!pkg) {
      continue;
    }

    for (let name of CORE_DEPS) {
      let dep = getDependency(pkg, name);
      if (dep) {
        // Parse version range (ignore prerelease), and ensure it overlaps with the existing version (if any)
        let range = new semver.Range(dep.replace(/-.*(\s|\|\||$)?/, ''));
        if (version && !version.intersects(range)) {
          warning(
            'Conflicting babel versions found in .babelrc. Make sure all of your plugins and presets depend on the same major version of babel.'
          );
        }

        version = range;
        break;
      }
    }
  }

  // Find the maximum major version allowed in the range and use that.
  // e.g. if ^6 || ^7 were specified, use 7.
  version = getMaxMajor(version);
  // if (!version) {
  //   warning(
  //     `Could not infer babel version. Defaulting to babel 7. Please add either babel-core or @babel/core as a dependency.`
  //   );
  //   version = 7;
  // }

  return version;
}

function getPluginName(p) {
  return Array.isArray(p) ? p[0] : p;
}

function getMaxMajor(version) {
  try {
    let range = new semver.Range(version);
    let sorted = range.set.sort((a, b) => a[0].semver.compare(b[0].semver));
    return semver.major(sorted.pop()[0].semver.version);
  } catch (err) {
    return null;
  }
}

async function installPlugins(asset, babelrc) {
  let presets = (babelrc.presets || []).map(p =>
    resolveModule('preset', getPluginName(p), asset.name)
  );
  let plugins = (babelrc.plugins || []).map(p =>
    resolveModule('plugin', getPluginName(p), asset.name)
  );
  return await Promise.all([...presets, ...plugins]);
}

async function resolveModule(type, name, path) {
  if (typeof name === 'function') {
    return name;
  }

  if (typeof name.default === 'function') {
    return name.default;
  }

  try {
    name = standardizeName(type, name);
    let [, pkg] = await localResolve(name, path);
    return pkg;
  } catch (err) {
    return null;
  }
}

// Copied from https://github.com/babel/babel/blob/3a399d1eb907df520f2b85bf9ddbc6533e256f6d/packages/babel-core/src/config/files/plugins.js#L61

const EXACT_RE = /^module:/;
const BABEL_PLUGIN_PREFIX_RE = /^(?!@|module:|[^/]+\/|babel-plugin-)/;
const BABEL_PRESET_PREFIX_RE = /^(?!@|module:|[^/]+\/|babel-preset-)/;
const BABEL_PLUGIN_ORG_RE = /^(@babel\/)(?!plugin-|[^/]+\/)/;
const BABEL_PRESET_ORG_RE = /^(@babel\/)(?!preset-|[^/]+\/)/;
const OTHER_PLUGIN_ORG_RE = /^(@(?!babel\/)[^/]+\/)(?![^/]*babel-plugin(?:-|\/|$)|[^/]+\/)/;
const OTHER_PRESET_ORG_RE = /^(@(?!babel\/)[^/]+\/)(?![^/]*babel-preset(?:-|\/|$)|[^/]+\/)/;
const OTHER_ORG_DEFAULT_RE = /^(@(?!babel$)[^/]+)$/;

function standardizeName(type, name) {
  // Let absolute and relative paths through.
  if (path.isAbsolute(name)) return name;

  const isPreset = type === 'preset';

  return (
    name
      // foo -> babel-preset-foo
      .replace(
        isPreset ? BABEL_PRESET_PREFIX_RE : BABEL_PLUGIN_PREFIX_RE,
        `babel-${type}-`
      )
      // @babel/es2015 -> @babel/preset-es2015
      .replace(
        isPreset ? BABEL_PRESET_ORG_RE : BABEL_PLUGIN_ORG_RE,
        `$1${type}-`
      )
      // @foo/mypreset -> @foo/babel-preset-mypreset
      .replace(
        isPreset ? OTHER_PRESET_ORG_RE : OTHER_PLUGIN_ORG_RE,
        `$1babel-${type}-`
      )
      // @foo -> @foo/babel-preset
      .replace(OTHER_ORG_DEFAULT_RE, `$1/babel-${type}`)
      // module:mypreset -> mypreset
      .replace(EXACT_RE, '')
  );
}

function generateIgnore(ignores = [] as string[], isDifferenceTarget) {
  // if (isDifferenceTarget) {
  //   // 移除node_modules相关的忽略
  //   return ignores.filter(ig => !ig.includes('node_modules'));
  // }
  return [...new Set(ignores.concat('node_modules'))];
}