webpack-config/dist/ConfigExtendCommand.js

Helps to load, extend and merge webpack configs

'use strict';

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

var _entries = require('babel-runtime/core-js/object/entries');

var _entries2 = _interopRequireDefault(_entries);

var _getIterator2 = require('babel-runtime/core-js/get-iterator');

var _getIterator3 = _interopRequireDefault(_getIterator2);

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

var _slicedToArray3 = _interopRequireDefault(_slicedToArray2);

var _weakMap = require('babel-runtime/core-js/weak-map');

var _weakMap2 = _interopRequireDefault(_weakMap);

var _lodash = require('lodash');

var _Config = require('./Config');

var _Config2 = _interopRequireDefault(_Config);

var _ConfigCommand = require('./ConfigCommand');

var _ConfigCommand2 = _interopRequireDefault(_ConfigCommand);

var _ConfigDefaultTransform = require('./ConfigDefaultTransform');

var _ConfigDefaultTransform2 = _interopRequireDefault(_ConfigDefaultTransform);

var _ConfigCleanupTransform = require('./ConfigCleanupTransform');

var _ConfigCleanupTransform2 = _interopRequireDefault(_ConfigCleanupTransform);

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

/**
 * @typedef {Object<String,ConfigTransform[]>} ConfigExtendOptions
 */

/**
 * @typedef {String|Object<String,ConfigTransform>|ConfigExtendOptions} ConfigExtendPossibleOptions
 */

/**
 * @private
 * @type {WeakMap}
 */
const LOADER = new _weakMap2.default();

/**
 * @private
 * @type {WeakMap}
 */
const FACTORY = new _weakMap2.default();

/**
 * @class
 * @extends {ConfigCommand}
 */
class ConfigExtendCommand extends _ConfigCommand2.default {
    /**
     * @constructor
     * @param {ConfigOptionsResolver} optionsResolver
     * @param {ConfigLoader} loader
     * @param {ConfigFactory} factory
     */
    constructor(optionsResolver, loader, factory) {
        super(optionsResolver);

        LOADER.set(this, loader);
        FACTORY.set(this, factory);
    }

    /**
     * @readonly
     * @type {ConfigLoader}
     */
    get loader() {
        return LOADER.get(this);
    }

    /**
     * @readonly
     * @type {ConfigFactory}
     */
    get factory() {
        return FACTORY.get(this);
    }

    /**
     * @override
     */
    execute(config, options) {
        const normalizedOptions = ConfigExtendCommand.normalizeOptions(options);

        normalizedOptions.forEach(value => {
            var _optionsResolver$reso = this.optionsResolver.resolve(config, value);

            const filename = _optionsResolver$reso.filename,
                  transforms = _optionsResolver$reso.transforms;

            const pendingConfig = this.loader.loadConfig(filename);

            if (pendingConfig instanceof _Config2.default) {
                config.dependencyTree.children.push(pendingConfig.dependencyTree);

                let prevConfig = pendingConfig.clone();

                transforms.forEach(transform => {
                    const currConfig = transform.call(config, prevConfig);

                    if (!(0, _lodash.isObject)(currConfig)) {
                        prevConfig = {};
                    } else {
                        prevConfig = currConfig;
                    }

                    if (!(prevConfig instanceof _Config2.default)) {
                        prevConfig = this.factory.createConfig({}).merge(prevConfig);
                    }
                });

                if (prevConfig instanceof _Config2.default) {
                    config.merge(prevConfig.toObject());
                }
            }
        });
    }

    /**
     * @param {ConfigExtendPossibleOptions} options
     * @returns {ConfigExtendOptions[]}
     */
    static normalizeOptions(options) {
        let normalizedOptions = [];

        if ((0, _lodash.isString)(options)) {
            normalizedOptions = [{
                filename: options,
                transforms: [_ConfigDefaultTransform2.default, _ConfigCleanupTransform2.default]
            }];
        } else if ((0, _lodash.isObject)(options)) {
            var _iteratorNormalCompletion = true;
            var _didIteratorError = false;
            var _iteratorError = undefined;

            try {
                for (var _iterator = (0, _getIterator3.default)((0, _entries2.default)(options)), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
                    const _ref = _step.value;

                    var _ref2 = (0, _slicedToArray3.default)(_ref, 2);

                    const filename = _ref2[0];
                    const transform = _ref2[1];

                    const transforms = Array.isArray(transform) ? transform : [transform];

                    normalizedOptions.push({
                        filename,
                        transforms: [...transforms, _ConfigCleanupTransform2.default]
                    });
                }
            } catch (err) {
                _didIteratorError = true;
                _iteratorError = err;
            } finally {
                try {
                    if (!_iteratorNormalCompletion && _iterator.return) {
                        _iterator.return();
                    }
                } finally {
                    if (_didIteratorError) {
                        throw _iteratorError;
                    }
                }
            }
        }

        return normalizedOptions;
    }
}

exports.default = ConfigExtendCommand;
//# sourceMappingURL=ConfigExtendCommand.js.map