diff options
Diffstat (limited to 'node_modules/webpack-merge/lib/join-arrays-smart.js')
| -rw-r--r-- | node_modules/webpack-merge/lib/join-arrays-smart.js | 148 |
1 files changed, 148 insertions, 0 deletions
diff --git a/node_modules/webpack-merge/lib/join-arrays-smart.js b/node_modules/webpack-merge/lib/join-arrays-smart.js new file mode 100644 index 000000000..74dda9047 --- /dev/null +++ b/node_modules/webpack-merge/lib/join-arrays-smart.js @@ -0,0 +1,148 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.uniteEntries = exports.uniteRules = undefined; + +var _differenceWith2 = require('lodash/differenceWith'); + +var _differenceWith3 = _interopRequireDefault(_differenceWith2); + +var _unionWith2 = require('lodash/unionWith'); + +var _unionWith3 = _interopRequireDefault(_unionWith2); + +var _mergeWith2 = require('lodash/mergeWith'); + +var _mergeWith3 = _interopRequireDefault(_mergeWith2); + +var _isEqual2 = require('lodash/isEqual'); + +var _isEqual3 = _interopRequireDefault(_isEqual2); + +var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }(); + +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); } } + +var isArray = Array.isArray; + +function uniteRules(rules, key, newRule, rule) { + if (String(rule.test) !== String(newRule.test) || (newRule.enforce || rule.enforce) && rule.enforce !== newRule.enforce || newRule.include && !isSameValue(rule.include, newRule.include) || newRule.exclude && !isSameValue(rule.exclude, newRule.exclude)) { + return false; + } else if (!rule.test && !rule.include && !rule.exclude && (rule.loader && rule.loader.split('?')[0]) !== (newRule.loader && newRule.loader.split('?')[0])) { + // Don't merge the rule if there isn't any identifying fields and the loaders don't match + return false; + } else if ((rule.include || rule.exclude) && !newRule.include && !newRule.exclude) { + // Don't merge child without include/exclude to parent that has either + return false; + } + + // newRule.loader should always override + if (newRule.loader) { + var optionsKey = newRule.options ? 'options' : newRule.query && 'query'; + + delete rule.use; + delete rule.loaders; + rule.loader = newRule.loader; + + if (optionsKey) { + rule[optionsKey] = newRule[optionsKey]; + } + } else if ((rule.use || rule.loaders || rule.loader) && (newRule.use || newRule.loaders)) { + var expandEntry = function expandEntry(loader) { + return typeof loader === 'string' ? { loader: loader } : loader; + }; + // this is only here to avoid breaking existing tests + var unwrapEntry = function unwrapEntry(entry) { + return !entry.options && !entry.query ? entry.loader : entry; + }; + + var entries = void 0; + if (rule.loader) { + var _optionsKey = rule.options ? 'options' : rule.query && 'query'; + entries = [{ loader: rule.loader }]; + + if (_optionsKey) { + entries[0][_optionsKey] = rule[_optionsKey]; + } + + delete rule.loader; + + if (_optionsKey) { + delete rule[_optionsKey]; + } + } else { + entries = [].concat(rule.use || rule.loaders).map(expandEntry); + } + var newEntries = [].concat(newRule.use || newRule.loaders).map(expandEntry); + + var loadersKey = rule.use || newRule.use ? 'use' : 'loaders'; + var resolvedKey = key + '.' + loadersKey; + + switch (rules[resolvedKey]) { + case 'prepend': + rule[loadersKey] = [].concat(_toConsumableArray((0, _differenceWith3.default)(newEntries, entries, uniteEntries)), _toConsumableArray(entries)).map(unwrapEntry); + break; + case 'replace': + rule[loadersKey] = newRule.use || newRule.loaders; + break; + default: + rule[loadersKey] = (0, _unionWith3.default)( + // Remove existing entries so that we can respect the order of the new + // entries + (0, _differenceWith3.default)(entries, newEntries, _isEqual3.default), newEntries, uniteEntries).map(unwrapEntry); + } + } + + if (newRule.include) { + rule.include = newRule.include; + } + + if (newRule.exclude) { + rule.exclude = newRule.exclude; + } + + return true; +} + +/** + * Check equality of two values using lodash's isEqual + * Arrays need to be sorted for equality checking + * but clone them first so as not to disrupt the sort order in tests + */ +function isSameValue(a, b) { + var _map = [a, b].map(function (value) { + return isArray(value) ? [].concat(_toConsumableArray(value)).sort() : value; + }), + _map2 = _slicedToArray(_map, 2), + propA = _map2[0], + propB = _map2[1]; + + return (0, _isEqual3.default)(propA, propB); +} + +function uniteEntries(newEntry, entry) { + var loaderNameRe = /^([^?]+)/ig; + + var _entry$loader$match = entry.loader.match(loaderNameRe), + _entry$loader$match2 = _slicedToArray(_entry$loader$match, 1), + loaderName = _entry$loader$match2[0]; + + var _newEntry$loader$matc = newEntry.loader.match(loaderNameRe), + _newEntry$loader$matc2 = _slicedToArray(_newEntry$loader$matc, 1), + newLoaderName = _newEntry$loader$matc2[0]; + + if (loaderName !== newLoaderName) { + return false; + } + + // Replace query values with newer ones + (0, _mergeWith3.default)(entry, newEntry); + return true; +} + +exports.uniteRules = uniteRules; +exports.uniteEntries = uniteEntries;
\ No newline at end of file |