object-merge - npm Package Compare versions

Comparing version 2.3.0 to 2.4.0

browser/object-merge_web.js

@@ -63,9 +63,37 @@ (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);throw new Error("Cannot find module '"+o+"'")}var f=n[o]={exports:{}};t[o][0].call(f.exports,function(e){var n=t[o][1][e];return s(n?n:e)},f,f.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
 */
+function ObjectMergeOptions(opts) {
+    'use strict';
+    opts = opts || {};
+    this.depth = opts.depth || false;
+    // circular ref check is true unless explicitly set to false
+    // ignore the jslint warning here, it's pointless.
+    this.throwOnCircularRef = 'throwOnCircularRef' in opts && opts.throwOnCircularRef === false ? false : true;
+}
+/*jslint unparam:true*/
 /**
+ * Creates a new options object suitable for use with objectMerge.
+ * @param {Object} [opts] An object specifying the options.
+ * @returns {ObjectMergeOptions} Returns an instance of ObjectMergeOptions
+ *  to be used with objectMerge.
+ */
+function createOptions(opts) {
+    'use strict';
+    var argz = Array.prototype.slice.call(arguments, 0);
+    argz.unshift(null);
+    var F = ObjectMergeOptions.bind.apply(ObjectMergeOptions, argz);
+    return new F();
+}
+/*jslint unparam:false*/
+/**
  * Merges JavaScript objects recursively without altering the objects merged.
  * @author <a href="mailto:[e-mail]">Matthew Kastor</a>
+ * @param {ObjectMergeOptions} [opts] An options object created by 
+ *  objectMerge.createOptions. Options must be specified as the first argument
+ *  and must be an object created with createOptions or else the object will
+ *  not be recognized as an options object and will be merged instead.
  * @param {Object} shadows [[shadows]...] One or more objects to merge. Each
- *  argument given will be treated as an object to merge. Each object overwrites
- *  the previous objects descendant properties if the property name matches. If
- *  objects properties are objects they will be merged recursively as well.
+ *  argument given will be treated as an object to merge. Each object
+ *  overwrites the previous objects descendant properties if the property name
+ *  matches. If objects properties are objects they will be merged recursively
+ *  as well.
  * @returns {Object} Returns a single merged object composed from clones of the
@@ -121,3 +149,6 @@ *  input objects.
     var cloneFunction = require('clone-function');
-    shadows = Array.prototype.slice.call(arguments, 0);
+    // this is the queue of visited objects / properties.
+    var visited = [];
+    // various merge options
+    var options = {};
     // gets the sequential trailing objects from array.
@@ -155,5 +186,4 @@ function getShadowObjects(shadows) {
     }
-    // this is the queue of visited objects / properties.
-    var visited = [];
-    function objectMergeRecursor(shadows) {
+    // checks for circular references
+    function circularReferenceCheck(shadows) {
         // if any of the current objects to process exist in the queue
@@ -166,40 +196,60 @@ // then throw an error.
         });
-        // if none of the current objects were in the queue then add references
-        // to the queue.
+        // if none of the current objects were in the queue
+        // then add references to the queue.
         visited = visited.concat(shadows);
-        function main(shadows) {
-            var out = getOutputObject(shadows);
-            /*jslint unparam:true */
-            function shadowHandler(val, prop, shadow) {
-                if (out[prop]) {
-                    out[prop] = objectMergeRecursor([
-                        out[prop],
-                        shadow[prop]
-                    ]);
-                } else {
-                    out[prop] = objectMergeRecursor([shadow[prop]]);
-                }
+    }
+    function main(shadows) {
+        var out = getOutputObject(shadows);
+        /*jslint unparam: true */
+        // recursor defined below. Dougie removed the intelligent suppression of
+        // this warning, probably because of functions that reference each other.
+        // So, you're stuck with making sure this isn't a mistake every time you
+        // use his linter.
+        function shadowHandler(val, prop, shadow) {
+            if (out[prop]) {
+                out[prop] = objectMergeRecursor([
+                    out[prop],
+                    shadow[prop]
+                ]);
+            } else {
+                out[prop] = objectMergeRecursor([shadow[prop]]);
             }
-            /*jslint unparam:false */
-            function shadowMerger(shadow) {
-                objectForeach(shadow, shadowHandler);
-            }
-            // short circuits case where output would be a primitive value
-            // anyway.
-            if (out instanceof Object) {
-                // only merges trailing objects since primitives would wipe out
-                // previous objects, as in merging {a:'a'}, 'a', and {b:'b'}
-                // would result in {b:'b'} so the first two arguments
-                // can be ignored completely.
-                var relevantShadows = getShadowObjects(shadows);
-                relevantShadows.forEach(shadowMerger);
-            }
-            return out;
         }
+        /*jslint unparam:false */
+        function shadowMerger(shadow) {
+            objectForeach(shadow, shadowHandler);
+        }
+        // short circuits case where output would be a primitive value
+        // anyway.
+        if (out instanceof Object) {
+            // only merges trailing objects since primitives would wipe out
+            // previous objects, as in merging {a:'a'}, 'a', and {b:'b'}
+            // would result in {b:'b'} so the first two arguments
+            // can be ignored completely.
+            var relevantShadows = getShadowObjects(shadows);
+            relevantShadows.forEach(shadowMerger);
+        }
+        return out;
+    }
+    function objectMergeRecursor(shadows) {
+        if (options.throwOnCircularRef === true) {
+            circularReferenceCheck(shadows);
+        }
         return main(shadows);
     }
+    // determines whether an options object was passed in and
+    // uses it if present
+    // ignore the jslint warning here too.
+    if (arguments[0] instanceof ObjectMergeOptions) {
+        options = arguments[0];
+        shadows = Array.prototype.slice.call(arguments, 1);
+    } else {
+        options = createOptions();
+        shadows = Array.prototype.slice.call(arguments, 0);
+    }
     return objectMergeRecursor(shadows);
 }
+objectMerge.createOptions = createOptions;
 module.exports = objectMerge;
 },{"clone-function":2,"object-foreach":3}]},{},[1])
-//@ sourceMappingURL=data:application/json;base64,{"version":3,"file":"generated.js","sources":["C:/Users/kastor/Documents/GitHub/object-merge/dev/browserMain.js","C:/Users/kastor/Documents/GitHub/object-merge/node_modules/clone-function/src/clone-function.js","C:/Users/kastor/Documents/GitHub/object-merge/node_modules/object-foreach/src/object-foreach.js","C:/Users/kastor/Documents/GitHub/object-merge/src/object-merge.js"],"names":[],"mappings":";AAAA;AACA;;ACDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","sourcesContent":["objectMerge = require('../src/object-merge.js');\r\n","/*\r\nLicense gpl-3.0 http://www.gnu.org/licenses/gpl-3.0-standalone.html\r\n*/\r\n/*jslint\r\n    evil: true,\r\n    node: true\r\n*/\r\n'use strict';\r\n/**\r\n * Clones non native JavaScript functions, or references native functions.\r\n * @author <a href=\"mailto:matthewkastor@gmail.com\">Matthew Kastor</a>\r\n * @param {Function} func The function to clone.\r\n * @returns {Function} Returns a clone of the non native function, or a\r\n *  reference to the native function.\r\n */\r\nfunction cloneFunction(func) {\r\n    var out, str;\r\n    try {\r\n        str = func.toString();\r\n        if (/\\[native code\\]/.test(str)) {\r\n            out = func;\r\n        } else {\r\n            out = eval('(function(){return ' + str + '}());');\r\n        }\r\n    } catch (e) {\r\n        throw new Error(e.message + '\\r\\n\\r\\n' + str);\r\n    }\r\n    return out;\r\n}\r\nmodule.exports = cloneFunction;","/**\r\n * Executes a function on each of an objects own enumerable properties. The\r\n *  callback function will receive three arguments: the value of the current\r\n *  property, the name of the property, and the object being processed. This is\r\n *  roughly equivalent to the signature for callbacks to\r\n *  Array.prototype.forEach.\r\n * @param {Object} obj The object to act on.\r\n * @param {Function} callback The function to execute.\r\n * @returns {Object} Returns the given object.\r\n */\r\nfunction objectForeach(obj, callback) {\r\n    \"use strict\";\r\n    Object.keys(obj).forEach(function (prop) {\r\n        callback(obj[prop], prop, obj);\r\n    });\r\n    return obj;\r\n};\r\nmodule.exports = objectForeach;","/*\r\nLicense gpl-3.0 http://www.gnu.org/licenses/gpl-3.0-standalone.html\r\n*/\r\n/*jslint\r\n    white: true,\r\n    vars: true,\r\n    node: true\r\n*/\r\n/**\r\n * Merges JavaScript objects recursively without altering the objects merged.\r\n * @author <a href=\"mailto:matthewkastor@gmail.com\">Matthew Kastor</a>\r\n * @param {Object} shadows [[shadows]...] One or more objects to merge. Each\r\n *  argument given will be treated as an object to merge. Each object overwrites\r\n *  the previous objects descendant properties if the property name matches. If\r\n *  objects properties are objects they will be merged recursively as well.\r\n * @returns {Object} Returns a single merged object composed from clones of the\r\n *  input objects.\r\n * @example\r\n *  var objectMerge = require('object-merge');\r\n *  var x = {\r\n *      a : 'a',\r\n *      b : 'b',\r\n *      c : {\r\n *          d : 'd',\r\n *          e : 'e',\r\n *          f : {\r\n *              g : 'g'\r\n *          }\r\n *      }\r\n *  };\r\n *  var y = {\r\n *      a : '`a',\r\n *      b : '`b',\r\n *      c : {\r\n *          d : '`d'\r\n *      }\r\n *  };\r\n *  var z = {\r\n *      a : {\r\n *          b : '``b'\r\n *      },\r\n *      fun : function foo () {\r\n *          return 'foo';\r\n *      },\r\n *      aps : Array.prototype.slice\r\n *  };\r\n *  var out = objectMerge(x, y, z);\r\n *  // out.a will be {\r\n *  //         b : '``b'\r\n *  //     }\r\n *  // out.b will be '`b'\r\n *  // out.c will be {\r\n *  //         d : '`d',\r\n *  //         e : 'e',\r\n *  //         f : {\r\n *  //             g : 'g'\r\n *  //         }\r\n *  //     }\r\n *  // out.fun will be a clone of z.fun\r\n *  // out.aps will be equal to z.aps\r\n */\r\nfunction objectMerge(shadows) {\r\n    'use strict';\r\n    var objectForeach = require('object-foreach');\r\n    var cloneFunction = require('clone-function');\r\n    shadows = Array.prototype.slice.call(arguments, 0);\r\n    // gets the sequential trailing objects from array.\r\n    function getShadowObjects(shadows) {\r\n        var out = shadows.reduce(function (collector, shadow) {\r\n                if (shadow instanceof Object) {\r\n                    collector.push(shadow);\r\n                } else {\r\n                    collector = [];\r\n                }\r\n                return collector;\r\n            }, []);\r\n        return out;\r\n    }\r\n    // gets either a new object of the proper type or the last primitive value\r\n    function getOutputObject(shadows) {\r\n        var out;\r\n        var lastShadow = shadows[shadows.length - 1];\r\n        if (lastShadow instanceof Array) {\r\n            out = [];\r\n        } else if (lastShadow instanceof Function) {\r\n            try {\r\n                out = cloneFunction(lastShadow);\r\n            } catch (e) {\r\n                throw new Error(e.message);\r\n            }\r\n        } else if (lastShadow instanceof Object) {\r\n            out = {};\r\n        } else {\r\n            // lastShadow is a primitive value;\r\n            out = lastShadow;\r\n        }\r\n        return out;\r\n    }\r\n    // this is the queue of visited objects / properties.\r\n    var visited = [];\r\n    function objectMergeRecursor(shadows) {\r\n        // if any of the current objects to process exist in the queue\r\n        // then throw an error.\r\n        shadows.forEach(function (item) {\r\n            if (item instanceof Object && visited.indexOf(item) > -1) {\r\n                throw new Error('Circular reference error');\r\n            }\r\n        });\r\n        // if none of the current objects were in the queue then add references\r\n        // to the queue.\r\n        visited = visited.concat(shadows);\r\n        function main(shadows) {\r\n            var out = getOutputObject(shadows);\r\n            /*jslint unparam:true */\r\n            function shadowHandler(val, prop, shadow) {\r\n                if (out[prop]) {\r\n                    out[prop] = objectMergeRecursor([\r\n                        out[prop],\r\n                        shadow[prop]\r\n                    ]);\r\n                } else {\r\n                    out[prop] = objectMergeRecursor([shadow[prop]]);\r\n                }\r\n            }\r\n            /*jslint unparam:false */\r\n            function shadowMerger(shadow) {\r\n                objectForeach(shadow, shadowHandler);\r\n            }\r\n            // short circuits case where output would be a primitive value\r\n            // anyway.\r\n            if (out instanceof Object) {\r\n                // only merges trailing objects since primitives would wipe out\r\n                // previous objects, as in merging {a:'a'}, 'a', and {b:'b'}\r\n                // would result in {b:'b'} so the first two arguments\r\n                // can be ignored completely.\r\n                var relevantShadows = getShadowObjects(shadows);\r\n                relevantShadows.forEach(shadowMerger);\r\n            }\r\n            return out;\r\n        }\r\n        return main(shadows);\r\n    }\r\n    return objectMergeRecursor(shadows);\r\n}\r\nmodule.exports = objectMerge;"]}
+//@ sourceMappingURL=data:application/json;base64,{"version":3,"file":"generated.js","sources":["C:/Users/kastor/Documents/GitHub/object-merge/dev/browserMain.js","C:/Users/kastor/Documents/GitHub/object-merge/node_modules/clone-function/src/clone-function.js","C:/Users/kastor/Documents/GitHub/object-merge/node_modules/object-foreach/src/object-foreach.js","C:/Users/kastor/Documents/GitHub/object-merge/src/object-merge.js"],"names":[],"mappings":";AAAA;AACA;;ACDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","sourcesContent":["objectMerge = require('../src/object-merge.js');\r\n","/*\r\nLicense gpl-3.0 http://www.gnu.org/licenses/gpl-3.0-standalone.html\r\n*/\r\n/*jslint\r\n    evil: true,\r\n    node: true\r\n*/\r\n'use strict';\r\n/**\r\n * Clones non native JavaScript functions, or references native functions.\r\n * @author <a href=\"mailto:matthewkastor@gmail.com\">Matthew Kastor</a>\r\n * @param {Function} func The function to clone.\r\n * @returns {Function} Returns a clone of the non native function, or a\r\n *  reference to the native function.\r\n */\r\nfunction cloneFunction(func) {\r\n    var out, str;\r\n    try {\r\n        str = func.toString();\r\n        if (/\\[native code\\]/.test(str)) {\r\n            out = func;\r\n        } else {\r\n            out = eval('(function(){return ' + str + '}());');\r\n        }\r\n    } catch (e) {\r\n        throw new Error(e.message + '\\r\\n\\r\\n' + str);\r\n    }\r\n    return out;\r\n}\r\nmodule.exports = cloneFunction;","/**\r\n * Executes a function on each of an objects own enumerable properties. The\r\n *  callback function will receive three arguments: the value of the current\r\n *  property, the name of the property, and the object being processed. This is\r\n *  roughly equivalent to the signature for callbacks to\r\n *  Array.prototype.forEach.\r\n * @param {Object} obj The object to act on.\r\n * @param {Function} callback The function to execute.\r\n * @returns {Object} Returns the given object.\r\n */\r\nfunction objectForeach(obj, callback) {\r\n    \"use strict\";\r\n    Object.keys(obj).forEach(function (prop) {\r\n        callback(obj[prop], prop, obj);\r\n    });\r\n    return obj;\r\n};\r\nmodule.exports = objectForeach;","/*\r\nLicense gpl-3.0 http://www.gnu.org/licenses/gpl-3.0-standalone.html\r\n*/\r\n/*jslint\r\n    white: true,\r\n    vars: true,\r\n    node: true\r\n*/\r\nfunction ObjectMergeOptions(opts) {\r\n    'use strict';\r\n    opts = opts || {};\r\n    this.depth = opts.depth || false;\r\n    // circular ref check is true unless explicitly set to false\r\n    // ignore the jslint warning here, it's pointless.\r\n    this.throwOnCircularRef = 'throwOnCircularRef' in opts && opts.throwOnCircularRef === false ? false : true;\r\n}\r\n/*jslint unparam:true*/\r\n/**\r\n * Creates a new options object suitable for use with objectMerge.\r\n * @param {Object} [opts] An object specifying the options.\r\n * @returns {ObjectMergeOptions} Returns an instance of ObjectMergeOptions\r\n *  to be used with objectMerge.\r\n */\r\nfunction createOptions(opts) {\r\n    'use strict';\r\n    var argz = Array.prototype.slice.call(arguments, 0);\r\n    argz.unshift(null);\r\n    var F = ObjectMergeOptions.bind.apply(ObjectMergeOptions, argz);\r\n    return new F();\r\n}\r\n/*jslint unparam:false*/\r\n/**\r\n * Merges JavaScript objects recursively without altering the objects merged.\r\n * @author <a href=\"mailto:matthewkastor@gmail.com\">Matthew Kastor</a>\r\n * @param {ObjectMergeOptions} [opts] An options object created by \r\n *  objectMerge.createOptions. Options must be specified as the first argument\r\n *  and must be an object created with createOptions or else the object will\r\n *  not be recognized as an options object and will be merged instead.\r\n * @param {Object} shadows [[shadows]...] One or more objects to merge. Each\r\n *  argument given will be treated as an object to merge. Each object\r\n *  overwrites the previous objects descendant properties if the property name\r\n *  matches. If objects properties are objects they will be merged recursively\r\n *  as well.\r\n * @returns {Object} Returns a single merged object composed from clones of the\r\n *  input objects.\r\n * @example\r\n *  var objectMerge = require('object-merge');\r\n *  var x = {\r\n *      a : 'a',\r\n *      b : 'b',\r\n *      c : {\r\n *          d : 'd',\r\n *          e : 'e',\r\n *          f : {\r\n *              g : 'g'\r\n *          }\r\n *      }\r\n *  };\r\n *  var y = {\r\n *      a : '`a',\r\n *      b : '`b',\r\n *      c : {\r\n *          d : '`d'\r\n *      }\r\n *  };\r\n *  var z = {\r\n *      a : {\r\n *          b : '``b'\r\n *      },\r\n *      fun : function foo () {\r\n *          return 'foo';\r\n *      },\r\n *      aps : Array.prototype.slice\r\n *  };\r\n *  var out = objectMerge(x, y, z);\r\n *  // out.a will be {\r\n *  //         b : '``b'\r\n *  //     }\r\n *  // out.b will be '`b'\r\n *  // out.c will be {\r\n *  //         d : '`d',\r\n *  //         e : 'e',\r\n *  //         f : {\r\n *  //             g : 'g'\r\n *  //         }\r\n *  //     }\r\n *  // out.fun will be a clone of z.fun\r\n *  // out.aps will be equal to z.aps\r\n */\r\nfunction objectMerge(shadows) {\r\n    'use strict';\r\n    var objectForeach = require('object-foreach');\r\n    var cloneFunction = require('clone-function');\r\n    // this is the queue of visited objects / properties.\r\n    var visited = [];\r\n    // various merge options\r\n    var options = {};\r\n    // gets the sequential trailing objects from array.\r\n    function getShadowObjects(shadows) {\r\n        var out = shadows.reduce(function (collector, shadow) {\r\n                if (shadow instanceof Object) {\r\n                    collector.push(shadow);\r\n                } else {\r\n                    collector = [];\r\n                }\r\n                return collector;\r\n            }, []);\r\n        return out;\r\n    }\r\n    // gets either a new object of the proper type or the last primitive value\r\n    function getOutputObject(shadows) {\r\n        var out;\r\n        var lastShadow = shadows[shadows.length - 1];\r\n        if (lastShadow instanceof Array) {\r\n            out = [];\r\n        } else if (lastShadow instanceof Function) {\r\n            try {\r\n                out = cloneFunction(lastShadow);\r\n            } catch (e) {\r\n                throw new Error(e.message);\r\n            }\r\n        } else if (lastShadow instanceof Object) {\r\n            out = {};\r\n        } else {\r\n            // lastShadow is a primitive value;\r\n            out = lastShadow;\r\n        }\r\n        return out;\r\n    }\r\n    // checks for circular references\r\n    function circularReferenceCheck(shadows) {\r\n        // if any of the current objects to process exist in the queue\r\n        // then throw an error.\r\n        shadows.forEach(function (item) {\r\n            if (item instanceof Object && visited.indexOf(item) > -1) {\r\n                throw new Error('Circular reference error');\r\n            }\r\n        });\r\n        // if none of the current objects were in the queue\r\n        // then add references to the queue.\r\n        visited = visited.concat(shadows);\r\n    }\r\n    function main(shadows) {\r\n        var out = getOutputObject(shadows);\r\n        /*jslint unparam: true */\r\n        // recursor defined below. Dougie removed the intelligent suppression of\r\n        // this warning, probably because of functions that reference each other.\r\n        // So, you're stuck with making sure this isn't a mistake every time you\r\n        // use his linter.\r\n        function shadowHandler(val, prop, shadow) {\r\n            if (out[prop]) {\r\n                out[prop] = objectMergeRecursor([\r\n                    out[prop],\r\n                    shadow[prop]\r\n                ]);\r\n            } else {\r\n                out[prop] = objectMergeRecursor([shadow[prop]]);\r\n            }\r\n        }\r\n        /*jslint unparam:false */\r\n        function shadowMerger(shadow) {\r\n            objectForeach(shadow, shadowHandler);\r\n        }\r\n        // short circuits case where output would be a primitive value\r\n        // anyway.\r\n        if (out instanceof Object) {\r\n            // only merges trailing objects since primitives would wipe out\r\n            // previous objects, as in merging {a:'a'}, 'a', and {b:'b'}\r\n            // would result in {b:'b'} so the first two arguments\r\n            // can be ignored completely.\r\n            var relevantShadows = getShadowObjects(shadows);\r\n            relevantShadows.forEach(shadowMerger);\r\n        }\r\n        return out;\r\n    }\r\n    function objectMergeRecursor(shadows) {\r\n        if (options.throwOnCircularRef === true) {\r\n            circularReferenceCheck(shadows);\r\n        }\r\n        return main(shadows);\r\n    }\r\n    // determines whether an options object was passed in and\r\n    // uses it if present\r\n    // ignore the jslint warning here too.\r\n    if (arguments[0] instanceof ObjectMergeOptions) {\r\n        options = arguments[0];\r\n        shadows = Array.prototype.slice.call(arguments, 1);\r\n    } else {\r\n        options = createOptions();\r\n        shadows = Array.prototype.slice.call(arguments, 0);\r\n    }\r\n    return objectMergeRecursor(shadows);\r\n}\r\nobjectMerge.createOptions = createOptions;\r\nmodule.exports = objectMerge;"]}

browser/tests/object-merge.test.js

 /*
 License gpl-3.0 http://www.gnu.org/licenses/gpl-3.0-standalone.html
 */
+describe('createOptions', function () {
+    it('creates an options object with defaults for unspecified values',
+        function () {
+            var opts = objectMerge.createOptions();
+            expect(opts).toEqual({
+                depth : false,
+                throwOnCircularRef : true
+            });
+        }
+    );
+    it('creates an options object with user specified values',
+        function () {
+            var opts = objectMerge.createOptions({
+                depth : 9,
+                throwOnCircularRef : false
+            });
+            expect(opts).toEqual({
+                depth : 9,
+                throwOnCircularRef : false
+            });
+        }
+    );
+});
 describe('object-merge', function () {
@@ -234,2 +257,58 @@ var w = {
     );
+    it('allows circular reference check to be disabled', function () {
+        var x = {
+            'a' : {}
+        };
+        x.b = x.a;
+        function thrower () {
+            var opts = objectMerge.createOptions({throwOnCircularRef : false});
+            return objectMerge(opts, x);
+        }
+        expect(thrower).not.toThrow();
+    });
+    it('only considers ObjectMergeOptions obj @ arg[0] to be valid options',
+        function () {
+            var x = {
+                'a' : {}
+            };
+            x.b = x.a;
+            function thrower () {
+                var opts = objectMerge.createOptions({throwOnCircularRef : false});
+                return objectMerge(x, opts);
+            }
+            function thrower2 () {
+                return objectMerge({throwOnCircularRef : false}, x);
+            }
+            expect(thrower).toThrow();
+            expect(thrower2).toThrow();
+        }
+    );
+    it('considers depth of false to mean no limit', function () {
+        var a = {
+            'a1' : {
+                'a2' : {
+                    'a3' : {}
+                }
+            }
+        };
+        var opts = objectMerge.createOptions({depth : false});
+        var res = objectMerge(opts, a);
+        expect(res).toEqual(a);
+    });
+    it('allows specifying depth of traversal', function () {
+        var a = {
+            'a1' : {
+                'a2' : {
+                    'a3' : {}
+                }
+            }
+        };
+        var opts = objectMerge.createOptions({depth : 2});
+        var res = objectMerge(opts, a);
+        expect(res).toEqual({
+            'a1' : {
+                'a2' : {}
+            }
+        });
+    });
 });

package.json

 {
   "name": "object-merge",
-  "version": "2.3.0",
+  "version": "2.4.0",
   "description": "Merges JavaScript objects recursively without altering the objects merged.",
@@ -5,0 +5,0 @@ "main": "./src/object-merge.js",

src/object-merge.js

@@ -9,9 +9,37 @@ /*
 */
+function ObjectMergeOptions(opts) {
+    'use strict';
+    opts = opts || {};
+    this.depth = opts.depth || false;
+    // circular ref check is true unless explicitly set to false
+    // ignore the jslint warning here, it's pointless.
+    this.throwOnCircularRef = 'throwOnCircularRef' in opts && opts.throwOnCircularRef === false ? false : true;
+}
+/*jslint unparam:true*/
 /**
+ * Creates a new options object suitable for use with objectMerge.
+ * @param {Object} [opts] An object specifying the options.
+ * @returns {ObjectMergeOptions} Returns an instance of ObjectMergeOptions
+ *  to be used with objectMerge.
+ */
+function createOptions(opts) {
+    'use strict';
+    var argz = Array.prototype.slice.call(arguments, 0);
+    argz.unshift(null);
+    var F = ObjectMergeOptions.bind.apply(ObjectMergeOptions, argz);
+    return new F();
+}
+/*jslint unparam:false*/
+/**
  * Merges JavaScript objects recursively without altering the objects merged.
  * @author <a href="mailto:[e-mail]">Matthew Kastor</a>
+ * @param {ObjectMergeOptions} [opts] An options object created by 
+ *  objectMerge.createOptions. Options must be specified as the first argument
+ *  and must be an object created with createOptions or else the object will
+ *  not be recognized as an options object and will be merged instead.
  * @param {Object} shadows [[shadows]...] One or more objects to merge. Each
- *  argument given will be treated as an object to merge. Each object overwrites
- *  the previous objects descendant properties if the property name matches. If
- *  objects properties are objects they will be merged recursively as well.
+ *  argument given will be treated as an object to merge. Each object
+ *  overwrites the previous objects descendant properties if the property name
+ *  matches. If objects properties are objects they will be merged recursively
+ *  as well.
  * @returns {Object} Returns a single merged object composed from clones of the
@@ -67,3 +95,6 @@ *  input objects.
     var cloneFunction = require('clone-function');
-    shadows = Array.prototype.slice.call(arguments, 0);
+    // this is the queue of visited objects / properties.
+    var visited = [];
+    // various merge options
+    var options = {};
     // gets the sequential trailing objects from array.
@@ -101,5 +132,4 @@ function getShadowObjects(shadows) {
     }
-    // this is the queue of visited objects / properties.
-    var visited = [];
-    function objectMergeRecursor(shadows) {
+    // checks for circular references
+    function circularReferenceCheck(shadows) {
         // if any of the current objects to process exist in the queue
@@ -112,38 +142,58 @@ // then throw an error.
         });
-        // if none of the current objects were in the queue then add references
-        // to the queue.
+        // if none of the current objects were in the queue
+        // then add references to the queue.
         visited = visited.concat(shadows);
-        function main(shadows) {
-            var out = getOutputObject(shadows);
-            /*jslint unparam:true */
-            function shadowHandler(val, prop, shadow) {
-                if (out[prop]) {
-                    out[prop] = objectMergeRecursor([
-                        out[prop],
-                        shadow[prop]
-                    ]);
-                } else {
-                    out[prop] = objectMergeRecursor([shadow[prop]]);
-                }
+    }
+    function main(shadows) {
+        var out = getOutputObject(shadows);
+        /*jslint unparam: true */
+        // recursor defined below. Dougie removed the intelligent suppression of
+        // this warning, probably because of functions that reference each other.
+        // So, you're stuck with making sure this isn't a mistake every time you
+        // use his linter.
+        function shadowHandler(val, prop, shadow) {
+            if (out[prop]) {
+                out[prop] = objectMergeRecursor([
+                    out[prop],
+                    shadow[prop]
+                ]);
+            } else {
+                out[prop] = objectMergeRecursor([shadow[prop]]);
             }
-            /*jslint unparam:false */
-            function shadowMerger(shadow) {
-                objectForeach(shadow, shadowHandler);
-            }
-            // short circuits case where output would be a primitive value
-            // anyway.
-            if (out instanceof Object) {
-                // only merges trailing objects since primitives would wipe out
-                // previous objects, as in merging {a:'a'}, 'a', and {b:'b'}
-                // would result in {b:'b'} so the first two arguments
-                // can be ignored completely.
-                var relevantShadows = getShadowObjects(shadows);
-                relevantShadows.forEach(shadowMerger);
-            }
-            return out;
         }
+        /*jslint unparam:false */
+        function shadowMerger(shadow) {
+            objectForeach(shadow, shadowHandler);
+        }
+        // short circuits case where output would be a primitive value
+        // anyway.
+        if (out instanceof Object) {
+            // only merges trailing objects since primitives would wipe out
+            // previous objects, as in merging {a:'a'}, 'a', and {b:'b'}
+            // would result in {b:'b'} so the first two arguments
+            // can be ignored completely.
+            var relevantShadows = getShadowObjects(shadows);
+            relevantShadows.forEach(shadowMerger);
+        }
+        return out;
+    }
+    function objectMergeRecursor(shadows) {
+        if (options.throwOnCircularRef === true) {
+            circularReferenceCheck(shadows);
+        }
         return main(shadows);
     }
+    // determines whether an options object was passed in and
+    // uses it if present
+    // ignore the jslint warning here too.
+    if (arguments[0] instanceof ObjectMergeOptions) {
+        options = arguments[0];
+        shadows = Array.prototype.slice.call(arguments, 1);
+    } else {
+        options = createOptions();
+        shadows = Array.prototype.slice.call(arguments, 0);
+    }
     return objectMergeRecursor(shadows);
 }
+objectMerge.createOptions = createOptions;
 module.exports = objectMerge;

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

237042

increased by5.02%

Lines of code

3749

increased by5.37%

No dependency changes