Create utility helper that inverts a JavaScript object

`invertObject` is a functional helper that swaps the key with the
value for a JavaScript object.

This utility helper will be used to invert the objects in React's
HTMLDOMPropertyConfig in order to create a map for my parser.

HTMLDOMPropertyConfig:
https://github.com/facebook/react/blob/master/src/renderers/dom/shared/HTMLDOMPropertyConfig.js

Tests added to ensure the helper works as expected.

Author: remarkablemark

lib/utilities.js

@@ -26,9 +26,36 @@ function camelCase(string) {
     return string;
 }
 
+/**
+ * Swap key with value in an object.
+ *
+ * @param  {Object} obj - The object.
+ * @return {Object}     - The inverted object.
+ */
+function invertObject(obj) {
+    if (typeof obj !== 'object' || !obj) { // null is an object
+        throw new Error('`invert`: First argument must be an object.');
+    }
+
+    var result = {};
+    var key;
+    var value;
+
+    for (key in obj) {
+        value = obj[key];
+        if (typeof value === 'object') {
+            throw new Error('`invert`: Object must be flat.');
+        }
+        result[value] = key;
+    }
+
+    return result;
+}
+
 /**
  * Export utilties.
  */
 module.exports = {
-    camelCase: camelCase
+    camelCase: camelCase,
+    invertObject: invertObject
 };

test/utilities.js

@@ -33,4 +33,49 @@ describe('utilties', function() {
         })
     });
 
+    describe('`invertObject` helper', function() {
+        var invertObject = utilities.invertObject;
+
+        it('swaps key with value for object', function() {
+            assert.deepEqual(
+                invertObject({ foo: 'bar', baz: 'qux' }),
+                { bar: 'foo', qux: 'baz' }
+            );
+
+            // check for unusual cases
+            assert.deepEqual(
+                invertObject({
+                    $: 'dollar',
+                    _: 'underscore',
+                    num: 1,
+                    u: undefined
+                }),
+                {
+                    dollar: '$',
+                    underscore: '_',
+                    '1': 'num',
+                    'undefined': 'u'
+                }
+            );
+        });
+
+        it('swaps key with value for array', function() {
+            assert.deepEqual(
+                invertObject(['zero', 'one']),
+                { 'zero': '0', 'one': '1' }
+            );
+        });
+
+        it('throws an error if the first argument is invalid', function() {
+            [undefined, null, 'foo', 1337].forEach(function(parameter) {
+                assert.throws(function() { invertObject(parameter); });
+            });
+        })
+
+        it('throws an error if object is not flat', function() {
+            assert.throws(function() { invertObject({ nested: {} }); });
+            assert.throws(function() { invertObject({ obj: null }); });
+        })
+    });
+
 });