Variant of merge that's useful for webpack configuration. 

Variant of merge that's useful for webpack configuration

bebraw

webpack-merge

- Fix - Don't merge strings with objects in `mergeWithRules`. #172

- Fix - If there's no match when using `merge` operation with `mergeWithRules`, use default merge behavior as a fallback. #167

- Fix - Fix a merge failure for `mergeWithRules` when non-array matches are merged. #166

- Feat - Throw a `TypeError` if trying to use `mergeWithRules` with invalid configuration types for `append`/`prepend`/`merge` operations.

- Feat - Support `merge` (`CustomizeRule.Merge`) for objects at `mergeWithRules`. This is useful for merging loader options for example. #163

- Feat - Allow `mergeWithRules` to merge based on rules without a match. #151 #159

- Fix - Allow `mergeUnique` to work with arbitrary order. #161

- Fix - Fall back correctly in `mergeWithRules` for cases that aren't matched. #157 #158

- Fix - Don't throw if using `mergeWithRules` without a rule #151

- Feat - Throw if `undefined` is passed to `merge` as a structure to merge

- Fix - Expose `Configuration` type through a generic to TypeScript to support both webpack 4 and 5 #141 #154

In case you use webpack 4, please change your typing as instructed in the readme as the default type is loose but non-breaking.

- Feature - Support advanced merging cases through `mergeWithRules` #146 #149

- Fix - Expose `CustomizeRule` for TypeScript users #147

- Fix - Allow merging a `RegExp` to itself #145

- Fix - Allow overriding an object field with `null` #144

- Fix - Drop `<reference types="webpack-dev-server" />` from **index.d.ts** #143

- Feature - Expose `merge` as `default` for backwards-compatibility with TypeScript. Now `import merge from "webpack-merge";` works there. In CommonJS, the default alias is exposed through `default` property due to technical constraints.

- Fix - Don't crash on `merge()` and `merge([])`. Now `{}` is returned in these corner cases.

- Fix - Drop tslib dependency by setting `"importHelpers": false,`

- Tech - Optimize build size (UMD isn't needed)

- Documentation - Use CommonJS imports at the examples. #137

- Feature - Support TypeScript out of the box. #84 #86 #95 #110 #112

- Deprecation - `merge.smart` has been dropped as it's tricky to support all the corner cases. Instead, it's better to use the provided utilities to put together a `merge` that fits your case.

- Deprecation - `mergeStrategy` has been dropped in favor of using `mergeWithCustomize` with `customizeArray` and `customizeObject`.

- Deprecation - `merge.multiple` has been dropped as the functionality was too specific and it's better to implement in the user space if needed.

- Breaking - `merge` has been moved as a regular import (i.e. `import { merge } from 'webpack-merge'`).

- Breaking - Merge customization has been moved behind `mergeWithCustomize`.

- Breaking - Bump supported Node version to 12

- Feature - `customizeArray` supports wildcards now. Example: `'entry.*': 'prepend'`. #45 #99

- Feature - Throw an error in case a `Promise` is being merged. It's better to wrap configuration within a `Promise` and merge inside it. #81

- Fix - Drop lodash in favor of simpler dependencies. #134

- Fix - Make `unique` merge from right to left to match behavior elsewhere. #119

var __assign = (this && this.__assign) || function () {

    __assign = Object.assign || function(t) {

        for (var s, i = 1, n = arguments.length; i < n; i++) {

            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))

    return __assign.apply(this, arguments);

var __read = (this && this.__read) || function (o, n) {

    var m = typeof Symbol === "function" && o[Symbol.iterator];

        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);

    catch (error) { e = { error: error }; }

            if (r && !r.done && (m = i["return"])) m.call(i);

        finally { if (e) throw e.error; }

var __spread = (this && this.__spread) || function () {

    for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));

var __importDefault = (this && this.__importDefault) || function (mod) {

    return (mod && mod.__esModule) ? mod : { "default": mod };

exports.unique = exports.mergeWithRules = exports.mergeWithCustomize = exports["default"] = exports.merge = exports.CustomizeRule = exports.customizeObject = exports.customizeArray = void 0;

var wildcard_1 = __importDefault(require("wildcard"));

var merge_with_1 = __importDefault(require("./merge-with"));

var join_arrays_1 = __importDefault(require("./join-arrays"));

var unique_1 = __importDefault(require("./unique"));

exports.CustomizeRule = types_1.CustomizeRule;

    for (var _i = 1; _i < arguments.length; _i++) {

        configurations[_i - 1] = arguments[_i];

    return mergeWithCustomize({}).apply(void 0, __spread([firstConfiguration], configurations));

    return function mergeWithOptions(firstConfiguration) {

        for (var _i = 1; _i < arguments.length; _i++) {

            configurations[_i - 1] = arguments[_i];

        if (utils_1.isUndefined(firstConfiguration) || configurations.some(utils_1.isUndefined)) {

            throw new TypeError("Merging undefined is not supported");

            throw new TypeError("Promises are not supported");

        if (configurations.length === 0) {

            if (Array.isArray(firstConfiguration)) {

                if (firstConfiguration.length === 0) {

                if (firstConfiguration.some(utils_1.isUndefined)) {

                    throw new TypeError("Merging undefined is not supported");

                if (firstConfiguration[0].then) {

                    throw new TypeError("Promises are not supported");

                return merge_with_1["default"](firstConfiguration, join_arrays_1["default"](options));

        return merge_with_1["default"]([firstConfiguration].concat(configurations), join_arrays_1["default"](options));

exports.mergeWithCustomize = mergeWithCustomize;

        var matchedRule = Object.keys(rules).find(function (rule) { return wildcard_1["default"](rule, key); }) || "";

            switch (rules[matchedRule]) {

                case types_1.CustomizeRule.Prepend:

                    return __spread(b, a);

                case types_1.CustomizeRule.Replace:

        if (!utils_1.isPlainObject(ao)) {

        Object.entries(ao).forEach(function (_a) {

            var _b = __read(_a, 2), k = _b[0], v = _b[1];

                case types_1.CustomizeRule.Match:

                    Object.entries(rule).forEach(function (_a) {

                        var _b = __read(_a, 2), k = _b[0], v = _b[1];

                        if (v === types_1.CustomizeRule.Replace && bMatches.length > 0) {

                            var val = last(bMatches)[k];

                            if (typeof val !== "undefined") {

                                ret[k] = val;

                case types_1.CustomizeRule.Append:

                    if (!bMatches.length) {

                    var appendValue = last(bMatches)[k];

                    if (!isArray(v) || !isArray(appendValue)) {

                        throw new TypeError("Trying to append non-arrays");

                    ret[k] = v.concat(appendValue);

                case types_1.CustomizeRule.Merge:

                    var lastValue = last(bMatches)[k];

                    if (!utils_1.isPlainObject(v) || !utils_1.isPlainObject(lastValue)) {

                        throw new TypeError("Trying to merge non-objects");

                    // @ts-ignore: These should be objects now

                    ret[k] = __assign(__assign({}, v), lastValue);

                    var prependValue = last(bMatches)[k];

                    if (!isArray(v) || !isArray(prependValue)) {

                        throw new TypeError("Trying to prepend non-arrays");

                    ret[k] = prependValue.concat(v);

                    ret[k] = bMatches.length > 0 ? last(bMatches)[k] : v;

                    var currentRule_1 = operations[k];

                    // Use .flat(); starting from Node 12

                        .map(function (o) { return o[k]; })

                        .reduce(function (acc, val) {

                        return isArray(acc) && isArray(val) ? __spread(acc, val) : acc;

                    ret[k] = mergeWithRule({ currentRule: currentRule_1, a: v, b: b_1 });

    return ret.concat(b.filter(function (o) { return !bAllMatches.includes(o); }));

    var currentRule = _a.currentRule, a = _a.a, b = _a.b;

        case types_1.CustomizeRule.Append:

        case types_1.CustomizeRule.Prepend:

        case types_1.CustomizeRule.Replace:

            case types_1.CustomizeRule.Prepend:

                return merge_with_1["default"]([b, a], join_arrays_1["default"]());

            case types_1.CustomizeRule.Replace:

            case types_1.CustomizeRule.Append:

                return merge_with_1["default"]([a, b], join_arrays_1["default"]());

exports.customizeObject = customizeObject;

  "description": "Variant of merge that's useful for webpack configuration",

  "author": "Juho Vepsalainen <bebraw@gmail.com>",

    "format": "prettier . --write --ignore-path .gitignore",

    "url": "https://github.com/survivejs/webpack-merge.git"

  "homepage": "https://github.com/survivejs/webpack-merge",

    "url": "https://github.com/survivejs/webpack-merge/issues"

		# Changelog

		## 5.7.3 / 2020-12-22

		- Fix - Don't merge strings with objects in `mergeWithRules`. #172

		## 5.7.2 / 2020-12-16
		@@ -4,0 +8,0 @@

		@@ -5,3 +5,3 @@ {
		"author": "Juho Vepsalainen <bebraw@gmail.com>",
		"version": "5.7.2",
		"version": "5.7.3",
		"scripts": {
		@@ -8,0 +8,0 @@ "build": "tsc",

		@@ -161,2 +161,5 @@ "use strict";
		});
		if (!utils_1.isPlainObject(ao)) {
		return ao;
		}
		Object.entries(ao).forEach(function (_a) {
		@@ -163,0 +166,0 @@ var _b = __read(_a, 2), k = _b[0], v = _b[1];

Improved metrics