Feature: allow specifying to use before or after other use

README.md

@@ -201,8 +201,11 @@ entries()
 ```js
 // Provide an object which maps its properties and values
 // into the backing Map as keys and values.
+// You can also provide an array to the second argument
+// for property names to omit from being merged.
 // obj: Object
-merge(obj)
+// omit: Optional Array
+merge(obj, omit)
 ```
 
 ```js

src/ChainedMap.js

@@ -1,3 +1,4 @@
+const merge = require('deepmerge');
 const Chainable = require('./Chainable');
 
 module.exports = class extends Chainable {
@@ -53,8 +54,23 @@ module.exports = class extends Chainable {
     return this;
   }
 
-  merge(obj) {
-    Object.keys(obj).forEach(key => this.set(key, obj[key]));
+  merge(obj, omit = []) {
+    Object
+      .keys(obj)
+      .forEach(key => {
+        if (omit.includes(key)) {
+          return;
+        }
+
+        const value = obj[key];
+
+        if ((!Array.isArray(value) && typeof value !== 'object') || value === null || !this.has(key)) {
+          this.set(key, value);
+        } else {
+          this.set(key, merge(this.get(key), value));
+        }
+      });
+
     return this;
   }
 

src/Config.js

@@ -74,41 +74,35 @@ module.exports = class extends ChainedMap {
     }));
   }
 
-  merge(obj = {}) {
-    Object
-      .keys(obj)
-      .forEach(key => {
-        const value = obj[key];
+  merge(obj = {}, omit = []) {
+    const omissions = [
+      'node',
+      'output',
+      'resolve',
+      'resolveLoader',
+      'devServer',
+      'performance',
+      'module'
+    ];
 
-        switch (key) {
-          case 'node':
-          case 'output':
-          case 'resolve':
-          case 'resolveLoader':
-          case 'devServer':
-          case 'performance':
-          case 'module': {
-            return this[key].merge(value);
-          }
-
-          case 'entry': {
-            return Object
-              .keys(value)
-              .forEach(name => this.entry(name).merge(value[name]));
-          }
+    if (!omit.includes('entry') && 'entry' in obj) {
+      Object
+        .keys(obj.entry)
+        .forEach(name => this.entry(name).merge(obj.entry[name]));
+    }
 
-          case 'plugin': {
-            return Object
-              .keys(value)
-              .forEach(name => this.plugin(name).merge(value[name]));
-          }
+    if (!omit.includes('plugin') && 'plugin' in obj) {
+      Object
+        .keys(obj.plugin)
+        .forEach(name => this.plugin(name).merge(obj.plugin[name]));
+    }
 
-          default: {
-            this.set(key, value);
-          }
-        }
-      });
+    omissions.forEach(key => {
+      if (!omit.includes(key) && key in obj) {
+        this[key].merge(obj[key]);
+      }
+    });
 
-    return this;
+    return super.merge(obj, [...omit, ...omissions, 'entry', 'plugin']);
   }
 };

src/DevServer.js

@@ -54,27 +54,11 @@ module.exports = class extends ChainedMap {
     }, this.entries() || {}));
   }
 
-  merge(obj) {
-    Object
-      .keys(obj)
-      .forEach(key => {
-        const value = obj[key];
+  merge(obj, omit = []) {
+    if (!omit.includes('allowedHosts') && 'allowedHosts' in obj) {
+      this.allowedHosts.merge(obj.allowedHosts);
+    }
 
-        switch (key) {
-          case 'allowedHosts': {
-            return this[key].merge(value);
-          }
-
-          default: {
-            if (this.has(key)) {
-              this.set(key, merge(this.get(key), value));
-            } else {
-              this.set(key, value);
-            }
-          }
-        }
-      });
-
-    return this;
+    return super.merge(obj, ['allowedHosts']);
   }
 };

src/Module.js

@@ -22,25 +22,13 @@ module.exports = class extends ChainedMap {
     }));
   }
 
-  merge(obj) {
-    Object
-      .keys(obj)
-      .forEach(key => {
-        const value = obj[key];
-
-        switch (key) {
-          case 'rule': {
-            return Object
-              .keys(value)
-              .forEach(name => this.rule(name).merge(value[name]));
-          }
-
-          default: {
-            this.set(key, value);
-          }
-        }
-      });
+  merge(obj, omit = []) {
+    if (!omit.includes('rule') && 'rule' in obj) {
+      Object
+        .keys(obj.rule)
+        .forEach(name => this.rule(name).merge(obj.rule[name]));
+    }
 
-    return this;
+    return super.merge(obj, ['rule']);
   }
 };

src/Plugin.js

@@ -19,16 +19,16 @@ module.exports = class extends ChainedMap {
     return this;
   }
 
-  merge(obj) {
-    if (obj.plugin) {
+  merge(obj, omit = []) {
+    if ('plugin' in obj) {
       this.set('plugin', obj.plugin);
     }
 
-    if (obj.args) {
+    if ('args' in obj) {
       this.set('args', obj.args);
     }
 
-    return this;
+    return super.merge(obj, [...omit, 'args', 'plugin'])
   }
 
   toConfig() {

src/Resolve.js

@@ -45,34 +45,24 @@ module.exports = class extends ChainedMap {
     }));
   }
 
-  merge(obj) {
-    Object
-      .keys(obj)
-      .forEach(key => {
-        const value = obj[key];
+  merge(obj, omit = []) {
+    const omissions = [
+      'alias',
+      'aliasFields',
+      'descriptionFiles',
+      'extensions',
+      'mainFields',
+      'mainFiles',
+      'modules',
+      'plugins'
+    ];
 
-        switch (key) {
-          case 'alias':
-          case 'aliasFields':
-          case 'descriptionFiles':
-          case 'extensions':
-          case 'mainFields':
-          case 'mainFiles':
-          case 'modules':
-          case 'plugins': {
-            return this[key].merge(value);
-          }
+    omissions.forEach(key => {
+      if (!omit.includes(key) && key in obj) {
+        this[key].merge(obj[key]);
+      }
+    });
 
-          default: {
-            if (this.has(key)) {
-              this.set(key, merge(this.get(key), value));
-            } else {
-              this.set(key, value);
-            }
-          }
-        }
-      });
-
-    return this;
+    return super.merge(obj, [...omit, ...omissions]);
   }
 };

src/ResolveLoader.js

@@ -20,30 +20,20 @@ module.exports = class extends ChainedMap {
     }, this.entries() || {}));
   }
 
-  merge(obj) {
-    Object
-      .keys(obj)
-      .forEach(key => {
-        const value = obj[key];
+  merge(obj, omit = []) {
+    const omissions = [
+      'extensions',
+      'modules',
+      'moduleExtensions',
+      'packageMains'
+    ];
 
-        switch (key) {
-          case 'extensions':
-          case 'modules':
-          case 'moduleExtensions':
-          case 'packageMains': {
-            return this[key].merge(value);
-          }
+    omissions.forEach(key => {
+      if (!omit.includes(key) && key in obj) {
+        this[key].merge(obj[key]);
+      }
+    });
 
-          default: {
-            if (this.has(key)) {
-              this.set(key, merge(this.get(key), value));
-            } else {
-              this.set(key, value);
-            }
-          }
-        }
-      });
-
-    return this;
+    return super.merge(obj, [...omit, ...omissions]);
   }
 };

src/Rule.js

@@ -40,45 +40,36 @@ module.exports = class Rule extends ChainedMap {
     return this.clean(Object.assign(this.entries() || {}, {
       include: this.include.values(),
       exclude: this.exclude.values(),
-      oneOf: this.oneOfs.values().map(r => r.toConfig()),
+      oneOf: this.oneOfs.values().map(oneOf => oneOf.toConfig()),
       use: this.uses.values().map(use => use.toConfig())
     }));
   }
 
-  merge(obj) {
-    Object
-      .keys(obj)
-      .forEach(key => {
-        const value = obj[key];
-
-        switch (key) {
-          case 'include':
-          case 'exclude': {
-            return this[key].merge(value);
-          }
+  merge(obj, omit = []) {
+    if (!omit.includes('include') && 'include' in obj) {
+      this.include.merge(obj.include);
+    }
 
-          case 'use': {
-            return Object
-              .keys(value)
-              .forEach(name => this.use(name).merge(value[name]));
-          }
+    if (!omit.includes('exclude') && 'exclude' in obj) {
+      this.exclude.merge(obj.exclude);
+    }
 
-          case 'oneOf': {
-            return Object
-              .keys(value)
-              .forEach(name => this.oneOf(name).merge(value[name]))
-          }
+    if (!omit.includes('use') && 'use' in obj) {
+      Object
+        .keys(obj.use)
+        .forEach(name => this.use(name).merge(obj.use[name]));
+    }
 
-          case 'test': {
-            return this.test(value instanceof RegExp ? value : new RegExp(value));
-          }
+    if (!omit.includes('oneOf') && 'oneOf' in obj) {
+      Object
+        .keys(obj.oneOf)
+        .forEach(name => this.oneOf(name).merge(obj.oneOf[name]))
+    }
 
-          default: {
-            this.set(key, value);
-          }
-        }
-      });
+    if (!omit.includes('test') && 'test' in obj) {
+      this.test(obj.test instanceof RegExp ? obj.test : new RegExp(obj.test));
+    }
 
-    return this;
+    return super.merge(obj, [...omit, 'include', 'exclude', 'use', 'oneOf', 'test']);
   }
 };

src/Use.js

@@ -12,16 +12,16 @@ module.exports = class extends ChainedMap {
     return this;
   }
 
-  merge(obj) {
-    if (obj.loader) {
+  merge(obj, omit = []) {
+    if (!omit.includes('loader') && 'loader' in obj) {
       this.loader(obj.loader);
     }
 
-    if (obj.options) {
+    if (!omit.includes('options') && 'options' in obj) {
       this.options(merge(this.store.get('options') || {}, obj.options));
     }
 
-    return this;
+    return super.merge(obj, [...omit, 'loader', 'options']);
   }
 
   toConfig() {

test/ChainedMap.js

@@ -118,6 +118,15 @@ test('merge with overriding values', t => {
   t.deepEqual(map.entries(), { a: 'alpha', b: 'beta', c: 'gamma' });
 });
 
+test('merge with omitting keys', t => {
+  const map = new ChainedMap();
+  const obj = { a: 'alpha', b: 'beta', c: 'gamma'};
+
+  map.merge(obj, ['b']);
+
+  t.deepEqual(map.entries(), { a: 'alpha', c: 'gamma' });
+});
+
 test('when true', t => {
   const map = new ChainedMap();
   const right = instance => {