'use strict';

Object.defineProperty(exports, '__esModule', {
  value: true
});
exports.default = normalize;

var _crypto;

function _load_crypto() {
  return (_crypto = _interopRequireDefault(require('crypto')));
}

var _glob;

function _load_glob() {
  return (_glob = _interopRequireDefault(require('glob')));
}

var _path;

function _load_path() {
  return (_path = _interopRequireDefault(require('path')));
}

var _jestValidate;

function _load_jestValidate() {
  return (_jestValidate = require('jest-validate'));
}

var _validatePattern;

function _load_validatePattern() {
  return (_validatePattern = _interopRequireDefault(
    require('./validatePattern')
  ));
}

var _jestUtil;

function _load_jestUtil() {
  return (_jestUtil = require('jest-util'));
}

var _chalk;

function _load_chalk() {
  return (_chalk = _interopRequireDefault(require('chalk')));
}

var _getMaxWorkers;

function _load_getMaxWorkers() {
  return (_getMaxWorkers = _interopRequireDefault(require('./getMaxWorkers')));
}

var _micromatch;

function _load_micromatch() {
  return (_micromatch = _interopRequireDefault(require('micromatch')));
}

var _jestResolve;

function _load_jestResolve() {
  return (_jestResolve = _interopRequireDefault(require('jest-resolve')));
}

var _jestRegexUtil;

function _load_jestRegexUtil() {
  return (_jestRegexUtil = require('jest-regex-util'));
}

var _utils;

function _load_utils() {
  return (_utils = require('./utils'));
}

var _constants;

function _load_constants() {
  return (_constants = require('./constants'));
}

var _ReporterValidationErrors;

function _load_ReporterValidationErrors() {
  return (_ReporterValidationErrors = require('./ReporterValidationErrors'));
}

var _Defaults;

function _load_Defaults() {
  return (_Defaults = _interopRequireDefault(require('./Defaults')));
}

var _Deprecated;

function _load_Deprecated() {
  return (_Deprecated = _interopRequireDefault(require('./Deprecated')));
}

var _setFromArgv;

function _load_setFromArgv() {
  return (_setFromArgv = _interopRequireDefault(require('./setFromArgv')));
}

var _ValidConfig;

function _load_ValidConfig() {
  return (_ValidConfig = _interopRequireDefault(require('./ValidConfig')));
}

function _interopRequireDefault(obj) {
  return obj && obj.__esModule ? obj : {default: obj};
}

function _toConsumableArray(arr) {
  if (Array.isArray(arr)) {
    for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++)
      arr2[i] = arr[i];
    return arr2;
  } else {
    return Array.from(arr);
  }
}
/**
 * Copyright (c) 2014-present, Facebook, Inc. All rights reserved.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 *
 *
 */

const ERROR = `${(_utils || _load_utils()).BULLET}Validation Error`;
const PRESET_EXTENSIONS = ['.json', '.js'];
const PRESET_NAME = 'jest-preset';

const createConfigError = message =>
  new (_jestValidate || _load_jestValidate()).ValidationError(
    ERROR,
    message,
    (_utils || _load_utils()).DOCUMENTATION_NOTE
  );

const mergeOptionWithPreset = (options, preset, optionName) => {
  if (options[optionName] && preset[optionName]) {
    options[optionName] = Object.assign(
      {},
      options[optionName],
      preset[optionName],
      options[optionName]
    );
  }
};

const setupPreset = (options, optionsPreset) => {
  let preset;
  const presetPath = (0, (_utils || _load_utils()).replaceRootDirInPath)(
    options.rootDir,
    optionsPreset
  );
  const presetModule = (
    _jestResolve || _load_jestResolve()
  ).default.findNodeModule(
    presetPath.startsWith('.')
      ? presetPath
      : (_path || _load_path()).default.join(presetPath, PRESET_NAME),
    {
      basedir: options.rootDir,
      extensions: PRESET_EXTENSIONS
    }
  );

  try {
    // Force re-evaluation to support multiple projects
    try {
      if (presetModule) {
        delete require.cache[require.resolve(presetModule)];
      }
    } catch (e) {}

    // $FlowFixMe
    preset = require(presetModule);
  } catch (error) {
    if (error instanceof SyntaxError) {
      throw createConfigError(
        `  Preset ${(_chalk || _load_chalk()).default.bold(
          presetPath
        )} is invalid:\n  ${error.message}`
      );
    }

    const preset = (_jestResolve || _load_jestResolve()).default.findNodeModule(
      presetPath,
      {
        basedir: options.rootDir
      }
    );

    if (preset) {
      throw createConfigError(
        `  Module ${(_chalk || _load_chalk()).default.bold(
          presetPath
        )} should have "jest-preset.js" or "jest-preset.json" file at the root.`
      );
    }

    throw createConfigError(
      `  Preset ${(_chalk || _load_chalk()).default.bold(
        presetPath
      )} not found.`
    );
  }

  if (options.setupFiles) {
    options.setupFiles = (preset.setupFiles || []).concat(options.setupFiles);
  }
  if (options.modulePathIgnorePatterns && preset.modulePathIgnorePatterns) {
    options.modulePathIgnorePatterns = preset.modulePathIgnorePatterns.concat(
      options.modulePathIgnorePatterns
    );
  }
  mergeOptionWithPreset(options, preset, 'moduleNameMapper');
  mergeOptionWithPreset(options, preset, 'transform');

  return Object.assign({}, preset, options);
};

const setupBabelJest = options => {
  const transform = options.transform;
  let babelJest;
  if (transform) {
    const customJSPattern = Object.keys(transform).find(pattern => {
      const regex = new RegExp(pattern);
      return regex.test('a.js') || regex.test('a.jsx');
    });

    if (customJSPattern) {
      const customJSTransformer = transform[customJSPattern];

      if (customJSTransformer === 'babel-jest') {
        babelJest = require.resolve('babel-jest');
        transform[customJSPattern] = babelJest;
      } else if (customJSTransformer.includes('babel-jest')) {
        babelJest = customJSTransformer;
      }
    }
  } else {
    babelJest = require.resolve('babel-jest');
    options.transform = {
      [(_constants || _load_constants()).DEFAULT_JS_PATTERN]: babelJest
    };
  }

  return babelJest;
};

const normalizeCollectCoverageOnlyFrom = (options, key) => {
  const collectCoverageOnlyFrom = Array.isArray(options[key])
    ? options[key] // passed from argv
    : Object.keys(options[key]); // passed from options
  return collectCoverageOnlyFrom.reduce((map, filePath) => {
    filePath = (_path || _load_path()).default.resolve(
      options.rootDir,
      (0, (_utils || _load_utils()).replaceRootDirInPath)(
        options.rootDir,
        filePath
      )
    );
    map[filePath] = true;
    return map;
  }, Object.create(null));
};

const normalizeCollectCoverageFrom = (options, key) => {
  let value;
  if (!options[key]) {
    value = [];
  }

  if (!Array.isArray(options[key])) {
    try {
      value = JSON.parse(options[key]);
    } catch (e) {}

    Array.isArray(value) || (value = [options[key]]);
  } else {
    value = options[key];
  }

  if (value) {
    value = value.map(filePath =>
      filePath.replace(/^(!?)(<rootDir>\/)(.*)/, '$1$3')
    );
  }

  return value;
};

const normalizeUnmockedModulePathPatterns = (
  options,
  key
  // _replaceRootDirTags is specifically well-suited for substituting
  // <rootDir> in paths (it deals with properly interpreting relative path
  // separators, etc).
  //
  // For patterns, direct global substitution is far more ideal, so we
  // special case substitutions for patterns here.
) =>
  options[key].map(pattern =>
    (0, (_jestRegexUtil || _load_jestRegexUtil()).replacePathSepForRegex)(
      pattern.replace(/<rootDir>/g, options.rootDir)
    )
  );

const normalizePreprocessor = options => {
  if (options.scriptPreprocessor && options.transform) {
    throw createConfigError(`  Options: ${(
      _chalk || _load_chalk()
    ).default.bold('scriptPreprocessor')} and ${(
      _chalk || _load_chalk()
    ).default.bold('transform')} cannot be used together.
  Please change your configuration to only use ${(
    _chalk || _load_chalk()
  ).default.bold('transform')}.`);
  }

  if (options.preprocessorIgnorePatterns && options.transformIgnorePatterns) {
    throw createConfigError(`  Options ${(_chalk || _load_chalk()).default.bold(
      'preprocessorIgnorePatterns'
    )} and ${(_chalk || _load_chalk()).default.bold(
      'transformIgnorePatterns'
    )} cannot be used together.
  Please change your configuration to only use ${(
    _chalk || _load_chalk()
  ).default.bold('transformIgnorePatterns')}.`);
  }

  if (options.scriptPreprocessor) {
    options.transform = {
      '.*': options.scriptPreprocessor
    };
  }

  if (options.preprocessorIgnorePatterns) {
    options.transformIgnorePatterns = options.preprocessorIgnorePatterns;
  }

  delete options.scriptPreprocessor;
  delete options.preprocessorIgnorePatterns;
  return options;
};

const normalizeMissingOptions = options => {
  if (!options.name) {
    options.name = (_crypto || _load_crypto()).default
      .createHash('md5')
      .update(options.rootDir)
      .digest('hex');
  }

  if (!options.setupFiles) {
    options.setupFiles = [];
  }

  return options;
};

const normalizeRootDir = options => {
  // Assert that there *is* a rootDir
  if (!options.hasOwnProperty('rootDir')) {
    throw createConfigError(
      `  Configuration option ${(_chalk || _load_chalk()).default.bold(
        'rootDir'
      )} must be specified.`
    );
  }
  options.rootDir = (_path || _load_path()).default.normalize(options.rootDir);
  return options;
};

const normalizeReporters = (options, basedir) => {
  const reporters = options.reporters;
  if (!reporters || !Array.isArray(reporters)) {
    return options;
  }

  (0,
  (_ReporterValidationErrors || _load_ReporterValidationErrors())
    .validateReporters)(reporters);
  options.reporters = reporters.map(reporterConfig => {
    const normalizedReporterConfig =
      typeof reporterConfig === 'string' // if reporter config is a string, we wrap it in an array
        ? // and pass an empty object for options argument, to normalize
          // the shape.
          [reporterConfig, {}]
        : reporterConfig;

    const reporterPath = (0, (_utils || _load_utils()).replaceRootDirInPath)(
      options.rootDir,
      normalizedReporterConfig[0]
    );

    if (
      reporterPath !== (_constants || _load_constants()).DEFAULT_REPORTER_LABEL
    ) {
      const reporter = (
        _jestResolve || _load_jestResolve()
      ).default.findNodeModule(reporterPath, {
        basedir: options.rootDir
      });
      if (!reporter) {
        throw new Error(
          `Could not resolve a module for a custom reporter.\n` +
            `  Module name: ${reporterPath}`
        );
      }
      normalizedReporterConfig[0] = reporter;
    }
    return normalizedReporterConfig;
  });

  return options;
};

const buildTestPathPattern = argv => {
  const patterns = [];

  if (argv._) {
    patterns.push.apply(patterns, _toConsumableArray(argv._));
  }
  if (argv.testPathPattern) {
    patterns.push.apply(patterns, _toConsumableArray(argv.testPathPattern));
  }

  const replacePosixSep = pattern => {
    if ((_path || _load_path()).default.sep === '/') {
      return pattern;
    }
    return pattern.replace(/\//g, '\\\\');
  };

  const testPathPattern = patterns.map(replacePosixSep).join('|');
  if (
    (0, (_validatePattern || _load_validatePattern()).default)(testPathPattern)
  ) {
    return testPathPattern;
  } else {
    showTestPathPatternError(testPathPattern);
    return '';
  }
};

const showTestPathPatternError = testPathPattern => {
  (0, (_jestUtil || _load_jestUtil()).clearLine)(process.stdout);

  console.log(
    (_chalk || _load_chalk()).default.red(
      `  Invalid testPattern ${testPathPattern} supplied. ` +
        `Running all tests instead.`
    )
  );
};

function normalize(options, argv) {
  var _validate = (0, (_jestValidate || _load_jestValidate()).validate)(
    options,
    {
      comment: (_utils || _load_utils()).DOCUMENTATION_NOTE,
      deprecatedConfig: (_Deprecated || _load_Deprecated()).default,
      exampleConfig: (_ValidConfig || _load_ValidConfig()).default,
      recursiveBlacklist: [
        'collectCoverageOnlyFrom',
        // 'coverageThreshold' allows to use 'global' and glob strings on the same
        // level, there's currently no way we can deal with such config
        'coverageThreshold',
        'globals',
        'moduleNameMapper',
        'testEnvironmentOptions',
        'transform'
      ]
    }
  );

  const hasDeprecationWarnings = _validate.hasDeprecationWarnings;

  options = normalizePreprocessor(
    normalizeReporters(
      normalizeMissingOptions(
        normalizeRootDir(
          (0, (_setFromArgv || _load_setFromArgv()).default)(options, argv)
        )
      )
    )
  );

  if (options.preset) {
    options = setupPreset(options, options.preset);
  }

  if (options.testEnvironment) {
    options.testEnvironment = (0, (_utils || _load_utils()).getTestEnvironment)(
      options
    );
  }

  if (!options.roots && options.testPathDirs) {
    options.roots = options.testPathDirs;
    delete options.testPathDirs;
  }
  if (!options.roots) {
    options.roots = [options.rootDir];
  }

  if (!options.testRunner || options.testRunner === 'jasmine2') {
    options.testRunner = require.resolve('jest-jasmine2');
  }

  if (!options.coverageDirectory) {
    options.coverageDirectory = (_path || _load_path()).default.resolve(
      options.rootDir,
      'coverage'
    );
  }

  const babelJest = setupBabelJest(options);
  const newOptions = Object.assign({}, (_Defaults || _load_Defaults()).default);
  // Cast back to exact type
  options = options;

  if (options.resolver) {
    newOptions.resolver = (0, (_utils || _load_utils()).resolve)(null, {
      filePath: options.resolver,
      key: 'resolver',
      rootDir: options.rootDir
    });
  }

  Object.keys(options).reduce((newOptions, key) => {
    // The resolver has been resolved separately; skip it
    if (key === 'resolver') {
      return newOptions;
    }
    let value;
    switch (key) {
      case 'collectCoverageOnlyFrom':
        value = normalizeCollectCoverageOnlyFrom(options, key);
        break;
      case 'setupFiles':
      case 'snapshotSerializers':
        value =
          options[key] &&
          options[key].map(filePath =>
            (0, (_utils || _load_utils()).resolve)(newOptions.resolver, {
              filePath: filePath,
              key: key,
              rootDir: options.rootDir
            })
          );
        break;
      case 'modulePaths':
      case 'roots':
        value =
          options[key] &&
          options[key].map(filePath =>
            (_path || _load_path()).default.resolve(
              options.rootDir,
              (0, (_utils || _load_utils()).replaceRootDirInPath)(
                options.rootDir,
                filePath
              )
            )
          );
        break;
      case 'collectCoverageFrom':
        value = normalizeCollectCoverageFrom(options, key);
        break;
      case 'cacheDirectory':
      case 'coverageDirectory':
        value =
          options[key] &&
          (_path || _load_path()).default.resolve(
            options.rootDir,
            (0, (_utils || _load_utils()).replaceRootDirInPath)(
              options.rootDir,
              options[key]
            )
          );
        break;
      case 'globalSetup':
      case 'globalTeardown':
      case 'moduleLoader':
      case 'runner':
      case 'setupTestFrameworkScriptFile':
      case 'testResultsProcessor':
      case 'testRunner':
      case 'filter':
        value =
          options[key] &&
          (0, (_utils || _load_utils()).resolve)(newOptions.resolver, {
            filePath: options[key],
            key: key,
            rootDir: options.rootDir
          });
        break;
      case 'prettierPath':
        // We only want this to throw if "prettierPath" is explicitly passed
        // from config or CLI, and the requested path isn't found. Otherwise we
        // set it to null and throw an error lazily when it is used.
        value =
          options[key] &&
          (0, (_utils || _load_utils()).resolve)(newOptions.resolver, {
            filePath: options[key],
            key: key,
            optional:
              options[key] === (_Defaults || _load_Defaults()).default[key],
            rootDir: options.rootDir
          });
        break;
      case 'moduleNameMapper':
        const moduleNameMapper = options[key];
        value =
          moduleNameMapper &&
          Object.keys(moduleNameMapper).map(regex => {
            const item = moduleNameMapper && moduleNameMapper[regex];
            return (
              item && [
                regex,
                (0, (_utils || _load_utils())._replaceRootDirTags)(
                  options.rootDir,
                  item
                )
              ]
            );
          });
        break;
      case 'transform':
        const transform = options[key];
        value =
          transform &&
          Object.keys(transform).map(regex => [
            regex,
            (0, (_utils || _load_utils()).resolve)(newOptions.resolver, {
              filePath: transform[regex],
              key: key,
              rootDir: options.rootDir
            })
          ]);
        break;
      case 'coveragePathIgnorePatterns':
      case 'modulePathIgnorePatterns':
      case 'testPathIgnorePatterns':
      case 'transformIgnorePatterns':
      case 'watchPathIgnorePatterns':
      case 'unmockedModulePathPatterns':
        value = normalizeUnmockedModulePathPatterns(options, key);
        break;
      case 'haste':
        value = Object.assign({}, options[key]);
        if (value.hasteImplModulePath != null) {
          value.hasteImplModulePath = (0, (_utils || _load_utils()).resolve)(
            newOptions.resolver,
            {
              filePath: (0, (_utils || _load_utils()).replaceRootDirInPath)(
                options.rootDir,
                value.hasteImplModulePath
              ),
              key: 'haste.hasteImplModulePath',
              rootDir: options.rootDir
            }
          );
        }
        break;
      case 'projects':
        value = (options[key] || [])
          .map(
            project =>
              typeof project === 'string'
                ? (0, (_utils || _load_utils())._replaceRootDirTags)(
                    options.rootDir,
                    project
                  )
                : project
          )
          .reduce((projects, project) => {
            // Project can be specified as globs. If a glob matches any files,
            // We expand it to these paths. If not, we keep the original path
            // for the future resolution.
            const globMatches =
              typeof project === 'string'
                ? (_glob || _load_glob()).default.sync(project)
                : [];
            return projects.concat(globMatches.length ? globMatches : project);
          }, []);
        break;
      case 'moduleDirectories':
      case 'testMatch':
        value = (0, (_utils || _load_utils())._replaceRootDirTags)(
          (0, (_utils || _load_utils()).escapeGlobCharacters)(options.rootDir),
          options[key]
        );
        break;
      case 'testRegex':
        value =
          options[key] &&
          (0, (_jestRegexUtil || _load_jestRegexUtil()).replacePathSepForRegex)(
            options[key]
          );
        break;
      case 'automock':
      case 'bail':
      case 'browser':
      case 'cache':
      case 'changedSince':
      case 'changedFilesWithAncestor':
      case 'clearMocks':
      case 'collectCoverage':
      case 'coverageReporters':
      case 'coverageThreshold':
      case 'detectLeaks':
      case 'detectOpenHandles':
      case 'displayName':
      case 'errorOnDeprecated':
      case 'expand':
      case 'globals':
      case 'findRelatedTests':
      case 'forceCoverageMatch':
      case 'forceExit':
      case 'lastCommit':
      case 'listTests':
      case 'logHeapUsage':
      case 'mapCoverage':
      case 'moduleFileExtensions':
      case 'name':
      case 'noStackTrace':
      case 'notify':
      case 'notifyMode':
      case 'onlyChanged':
      case 'outputFile':
      case 'passWithNoTests':
      case 'replname':
      case 'reporters':
      case 'resetMocks':
      case 'resetModules':
      case 'restoreMocks':
      case 'rootDir':
      case 'runTestsByPath':
      case 'silent':
      case 'skipFilter':
      case 'skipNodeResolution':
      case 'testEnvironment':
      case 'testEnvironmentOptions':
      case 'testFailureExitCode':
      case 'testLocationInResults':
      case 'testNamePattern':
      case 'testURL':
      case 'timers':
      case 'useStderr':
      case 'verbose':
      case 'watch':
      case 'watchAll':
      case 'watchman':
        value = options[key];
        break;
      case 'watchPlugins':
        value = (options[key] || []).map(watchPlugin => {
          if (typeof watchPlugin === 'string') {
            return {
              config: {},
              path: (0, (_utils || _load_utils()).resolve)(
                newOptions.resolver,
                {
                  filePath: watchPlugin,
                  key: key,
                  rootDir: options.rootDir
                }
              )
            };
          } else {
            return {
              config: watchPlugin[1] || {},
              path: (0, (_utils || _load_utils()).resolve)(
                newOptions.resolver,
                {
                  filePath: watchPlugin[0],
                  key: key,
                  rootDir: options.rootDir
                }
              )
            };
          }
        });
        break;
    }
    newOptions[key] = value;
    return newOptions;
  }, newOptions);

  newOptions.nonFlagArgs = argv._;
  newOptions.testPathPattern = buildTestPathPattern(argv);
  newOptions.json = argv.json;

  newOptions.testFailureExitCode = parseInt(newOptions.testFailureExitCode, 10);

  for (const key of [
    'lastCommit',
    'changedFilesWithAncestor',
    'changedSince'
  ]) {
    if (newOptions[key]) {
      newOptions.onlyChanged = true;
    }
  }

  if (argv.all) {
    newOptions.onlyChanged = false;
  } else if (newOptions.testPathPattern) {
    // When passing a test path pattern we don't want to only monitor changed
    // files unless `--watch` is also passed.
    newOptions.onlyChanged = newOptions.watch;
  }

  newOptions.updateSnapshot =
    argv.ci && !argv.updateSnapshot
      ? 'none'
      : argv.updateSnapshot
        ? 'all'
        : 'new';

  newOptions.maxWorkers = (0,
  (_getMaxWorkers || _load_getMaxWorkers()).default)(argv);

  if (babelJest) {
    const regeneratorRuntimePath = (
      _jestResolve || _load_jestResolve()
    ).default.findNodeModule('regenerator-runtime/runtime', {
      basedir: options.rootDir,
      resolver: newOptions.resolver
    });

    if (regeneratorRuntimePath) {
      newOptions.setupFiles.unshift(regeneratorRuntimePath);
    }
  }

  if (options.testRegex && options.testMatch) {
    throw createConfigError(
      `  Configuration options ${(_chalk || _load_chalk()).default.bold(
        'testMatch'
      )} and` +
        ` ${(_chalk || _load_chalk()).default.bold(
          'testRegex'
        )} cannot be used together.`
    );
  }

  if (options.testRegex && !options.testMatch) {
    // Prevent the default testMatch conflicting with any explicitly
    // configured `testRegex` value
    newOptions.testMatch = [];
  }

  // If argv.json is set, coverageReporters shouldn't print a text report.
  if (argv.json) {
    newOptions.coverageReporters = (newOptions.coverageReporters || []).filter(
      reporter => reporter !== 'text'
    );
  }

  // If collectCoverage is enabled while using --findRelatedTests we need to
  // avoid having false negatives in the generated coverage report.
  // The following: `--findRelatedTests '/rootDir/file1.js' --coverage`
  // Is transformed to: `--findRelatedTests '/rootDir/file1.js' --coverage --collectCoverageFrom 'file1.js'`
  // where arguments to `--collectCoverageFrom` should be globs (or relative
  // paths to the rootDir)
  if (newOptions.collectCoverage && argv.findRelatedTests) {
    let collectCoverageFrom = argv._.map(filename => {
      filename = (0, (_utils || _load_utils()).replaceRootDirInPath)(
        options.rootDir,
        filename
      );
      return (_path || _load_path()).default.isAbsolute(filename)
        ? (_path || _load_path()).default.relative(options.rootDir, filename)
        : filename;
    });

    // Don't override existing collectCoverageFrom options
    if (newOptions.collectCoverageFrom) {
      collectCoverageFrom = collectCoverageFrom.reduce((patterns, filename) => {
        if (
          !(0, (_micromatch || _load_micromatch()).default)(
            [
              (_path || _load_path()).default.relative(
                options.rootDir,
                filename
              )
            ],
            newOptions.collectCoverageFrom
          ).length
        ) {
          return patterns;
        }
        return [].concat(_toConsumableArray(patterns), [filename]);
      }, newOptions.collectCoverageFrom);
    }

    newOptions.collectCoverageFrom = collectCoverageFrom;
  }

  return {
    hasDeprecationWarnings: hasDeprecationWarnings,
    options: newOptions
  };
}