@commitlint/load/lib/index.js

'use strict';

Object.defineProperty(exports, "__esModule", {
	value: true
});

var _slicedToArray2 = require('babel-runtime/helpers/slicedToArray');

var _slicedToArray3 = _interopRequireDefault(_slicedToArray2);

var _path = require('path');

var _path2 = _interopRequireDefault(_path);

var _executeRule = require('@commitlint/execute-rule');

var _executeRule2 = _interopRequireDefault(_executeRule);

var _resolveExtends = require('@commitlint/resolve-extends');

var _resolveExtends2 = _interopRequireDefault(_resolveExtends);

var _cosmiconfig = require('cosmiconfig');

var _cosmiconfig2 = _interopRequireDefault(_cosmiconfig);

var _lodash = require('lodash');

var _resolveFrom = require('resolve-from');

var _resolveFrom2 = _interopRequireDefault(_resolveFrom);

var _loadPlugin = require('./utils/loadPlugin');

var _loadPlugin2 = _interopRequireDefault(_loadPlugin);

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

const w = (a, b) => Array.isArray(b) ? b : undefined;
const valid = input => (0, _lodash.pick)(input, 'extends', 'rules', 'plugins', 'parserPreset', 'formatter', 'ignores', 'defaultIgnores');

exports.default = (seed = {}, options = { cwd: process.cwd() }) => new Promise(function ($return, $error) {
	var loaded, base, config, opts, resolvedParserPreset, extended, preset, executed;
	return Promise.resolve(loadConfig(options.cwd, options.file)).then(function ($await_4) {
		try {
			loaded = $await_4;
			base = loaded.filepath ? _path2.default.dirname(loaded.filepath) : options.cwd;
			config = valid((0, _lodash.merge)({}, loaded.config, seed));
			opts = (0, _lodash.merge)({ extends: [], rules: {}, formatter: '@commitlint/format' }, (0, _lodash.pick)(config, 'extends', 'plugins', 'ignores', 'defaultIgnores'));


			// Resolve parserPreset key
			if (typeof config.parserPreset === 'string') {
				let resolvedParserConfig;
				resolvedParserPreset = (0, _resolveFrom2.default)(base, config.parserPreset);
				return Promise.resolve(require(resolvedParserPreset)).then(function ($await_5) {
					try {
						resolvedParserConfig = $await_5;

						// Resolve loaded parser preset if its a factory
						if (typeof resolvedParserConfig === 'function') {
							return Promise.resolve(resolvedParserConfig()).then(function ($await_6) {
								try {
									resolvedParserConfig = $await_6;
									return $If_3.call(this);
								} catch ($boundEx) {
									return $error($boundEx);
								}
							}.bind(this), $error);
						}

						function $If_3() {
							config.parserPreset = {
								name: config.parserPreset,
								path: resolvedParserPreset,
								parserOpts: resolvedParserConfig.parserOpts
							};
							return $If_1.call(this);
						}

						return $If_3.call(this);
					} catch ($boundEx) {
						return $error($boundEx);
					}
				}.bind(this), $error);
			}

			// Resolve extends key

			function $If_1() {
				extended = (0, _resolveExtends2.default)(opts, {
					prefix: 'commitlint-config',
					cwd: base,
					parserPreset: config.parserPreset
				});
				preset = valid((0, _lodash.mergeWith)(extended, config, w));

				// Await parser-preset if applicable
				if (typeof preset.parserPreset === 'object' && typeof preset.parserPreset.parserOpts === 'object' && typeof preset.parserPreset.parserOpts.then === 'function') {
					return Promise.resolve(preset.parserPreset.parserOpts).then(function ($await_7) {
						try {
							preset.parserPreset.parserOpts = $await_7.parserOpts;
							return $If_2.call(this);
						} catch ($boundEx) {
							return $error($boundEx);
						}
					}.bind(this), $error);
				}

				// Resolve config-relative formatter module

				function $If_2() {
					if (typeof config.formatter === 'string') {
						preset.formatter = _resolveFrom2.default.silent(base, config.formatter) || config.formatter;
					}

					// resolve plugins
					preset.plugins = {};
					if (config.plugins && config.plugins.length) {
						config.plugins.forEach(pluginKey => {
							(0, _loadPlugin2.default)(preset.plugins, pluginKey, process.env.DEBUG === 'true');
						});
					}

					// Execute rule config functions if needed
					return Promise.resolve(Promise.all(['rules'].map(key => [key, preset[key]]).map(item => new Promise(function ($return, $error) {
						var _item, key, value, executedValue;

						_item = (0, _slicedToArray3.default)(item, 2);
						key = _item[0], value = _item[1];
						return Promise.resolve(Promise.all((0, _lodash.toPairs)(value || {}).map(entry => (0, _executeRule2.default)(entry)))).then(function ($await_8) {
							try {
								executedValue = $await_8;

								return $return([key, executedValue.reduce((registry, item) => {
									var _item2 = (0, _slicedToArray3.default)(item, 2);

									const key = _item2[0],
									      value = _item2[1];

									registry[key] = value;
									return registry;
								}, {})]);
							} catch ($boundEx) {
								return $error($boundEx);
							}
						}.bind(this), $error);
					}.bind(this))))).then(function ($await_9) {
						try {
							executed = $await_9;


							// Merge executed config keys into preset
							return $return(executed.reduce((registry, item) => {
								var _item3 = (0, _slicedToArray3.default)(item, 2);

								const key = _item3[0],
								      value = _item3[1];

								registry[key] = value;
								return registry;
							}, preset));
						} catch ($boundEx) {
							return $error($boundEx);
						}
					}.bind(this), $error);
				}

				return $If_2.call(this);
			}

			return $If_1.call(this);
		} catch ($boundEx) {
			return $error($boundEx);
		}
	}.bind(this), $error);
}.bind(this));

function loadConfig(cwd, configPath) {
	return new Promise(function ($return, $error) {
		var explorer, explicitPath, explore, searchPath, local;
		explorer = (0, _cosmiconfig2.default)('commitlint');
		explicitPath = configPath ? _path2.default.resolve(cwd, configPath) : undefined;
		explore = explicitPath ? explorer.load : explorer.search;
		searchPath = explicitPath ? explicitPath : cwd;
		return Promise.resolve(explore(searchPath)).then(function ($await_10) {
			try {
				local = $await_10;


				if (local) {
					return $return(local);
				}

				return $return({});
			} catch ($boundEx) {
				return $error($boundEx);
			}
		}.bind(this), $error);
	}.bind(this));
}
module.exports = exports.default;
//# sourceMappingURL=index.js.map