@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.topairs');

var _lodash2 = _interopRequireDefault(_lodash);

var _lodash3 = require('lodash.merge');

var _lodash4 = _interopRequireDefault(_lodash3);

var _lodash5 = require('lodash.mergewith');

var _lodash6 = _interopRequireDefault(_lodash5);

var _lodash7 = require('lodash.pick');

var _lodash8 = _interopRequireDefault(_lodash7);

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

var _resolveFrom2 = _interopRequireDefault(_resolveFrom);

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

const w = (a, b) => Array.isArray(b) ? b : undefined;
const valid = input => (0, _lodash8.default)(input, 'extends', 'rules', 'parserPreset');

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_3) {
		try {
			loaded = $await_3;
			base = loaded.filepath ? _path2.default.dirname(loaded.filepath) : options.cwd;
			config = valid((0, _lodash4.default)(loaded.config, seed));
			opts = (0, _lodash4.default)({ extends: [], rules: {} }, (0, _lodash8.default)(config, 'extends'));


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

						config.parserPreset = {
							name: config.parserPreset,
							path: resolvedParserPreset,
							parserOpts: $await_4.parserOpts
						};
						return $If_1.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, _lodash6.default)(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_5) {
						try {
							preset.parserPreset.parserOpts = $await_5.parserOpts;
							return $If_2.call(this);
						} catch ($boundEx) {
							return $error($boundEx);
						}
					}.bind(this), $error);
				}

				// Execute rule config functions if needed

				function $If_2() {
					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, _lodash2.default)(value || {}).map(entry => (0, _executeRule2.default)(entry)))).then(function ($await_6) {
							try {
								executedValue = $await_6;

								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_7) {
						try {
							executed = $await_7;


							// 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, local;
		explorer = (0, _cosmiconfig2.default)('commitlint', {
			rcExtensions: true,
			configPath: configPath ? _path2.default.resolve(cwd, configPath) : null
		});
		return Promise.resolve(explorer.load(cwd)).then(function ($await_8) {
			try {
				local = $await_8;


				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