standardize on invariant for runtime checks

Author: globalchubby

src/__tests__/combineActions-test.js

@@ -4,10 +4,10 @@ import { expect } from 'chai';
 describe('combineActions', () => {
   it('should throw an error if any action is not a function or string', () => {
     expect(() => combineActions(1, 'ACTION_2'))
-      .to.throw(TypeError, 'Expected action types to be strings, symbols, or action creators');
+      .to.throw(Error, 'Expected action types to be strings, symbols, or action creators');
 
     expect(() => combineActions('ACTION_1', () => {}, null))
-      .to.throw(TypeError, 'Expected action types to be strings, symbols, or action creators');
+      .to.throw(Error, 'Expected action types to be strings, symbols, or action creators');
   });
 
   it('should accept action creators and action type strings', () => {

src/__tests__/createActions-test.js

@@ -5,16 +5,16 @@ describe('createActions', () => {
   it('should throw an error when given arguments that contain a non-string', () => {
     const expectedError = 'Expected optional object followed by string action types';
 
-    expect(() => createActions(1)).to.throw(TypeError, expectedError);
-    expect(() => createActions({ ACTION_1: undefined }, [])).to.throw(TypeError, expectedError);
-    expect(() => createActions('ACTION_1', true)).to.throw(TypeError, expectedError);
+    expect(() => createActions(1)).to.throw(Error, expectedError);
+    expect(() => createActions({ ACTION_1: undefined }, [])).to.throw(Error, expectedError);
+    expect(() => createActions('ACTION_1', true)).to.throw(Error, expectedError);
   });
 
   it('should throw an error when given bad payload creators', () => {
     expect(
       () => createActions({ ACTION_1: {} })
     ).to.throw(
-      TypeError,
+      Error,
       'Expected function, undefined, or array with payload and meta functions for ACTION_1'
     );
 
@@ -24,7 +24,7 @@ describe('createActions', () => {
         ACTION_2: 'string'
       })
     ).to.throw(
-      TypeError,
+      Error,
       'Expected function, undefined, or array with payload and meta functions for ACTION_2'
     );
   });
@@ -38,7 +38,7 @@ describe('createActions', () => {
         ]
       })
     ).to.throw(
-      TypeError,
+      Error,
       'Expected function, undefined, or array with payload and meta functions for ACTION_1'
     );
 
@@ -54,7 +54,7 @@ describe('createActions', () => {
         ]
       })
     ).to.throw(
-      TypeError,
+      Error,
       'Expected function, undefined, or array with payload and meta functions for ACTION_2'
     );
   });
@@ -63,7 +63,7 @@ describe('createActions', () => {
     expect(
       () => createActions({ ACTION_1: undefined }, 'ACTION_2')
     ).to.throw(
-      TypeError,
+      Error,
       'Expected function, undefined, or array with payload and meta functions for ACTION_1'
     );
 
@@ -73,7 +73,7 @@ describe('createActions', () => {
         ACTION_2: undefined
       })
     ).to.throw(
-      TypeError,
+      Error,
       'Expected function, undefined, or array with payload and meta functions for ACTION_2'
     );
   });
@@ -84,7 +84,7 @@ describe('createActions', () => {
         ACTION_1: [() => {}]
       })
     ).to.throw(
-      TypeError,
+      Error,
       'Expected function, undefined, or array with payload and meta functions for ACTION_1'
     );
   });

src/combineActions.js

@@ -3,6 +3,7 @@ import isFunction from 'lodash/isFunction';
 import isEmpty from 'lodash/isEmpty';
 import toString from 'lodash/toString';
 import isSymbol from 'lodash/isSymbol';
+import invariant from 'invariant';
 
 export const ACTION_TYPE_DELIMITER = '||';
 
@@ -18,11 +19,10 @@ function isValidActionTypes(actionTypes) {
 }
 
 export default function combineActions(...actionsTypes) {
-  if (!isValidActionTypes(actionsTypes)) {
-    throw new TypeError('Expected action types to be strings, symbols, or action creators');
-  }
-
+  invariant(
+    isValidActionTypes(actionsTypes),
+    'Expected action types to be strings, symbols, or action creators'
+  );
   const combinedActionType = actionsTypes.map(toString).join(ACTION_TYPE_DELIMITER);
-
   return { toString: () => combinedActionType };
 }

src/createActions.js

@@ -6,17 +6,18 @@ import reduce from 'lodash/reduce';
 import isString from 'lodash/isString';
 import isFunction from 'lodash/isFunction';
 import createAction from './createAction';
+import invariant from 'invariant';
 
 export default function createActions(actionsMap, ...identityActions) {
-  if (identityActions.every(isString)) {
-    if (isString(actionsMap)) {
-      return fromIdentityActions([actionsMap, ...identityActions]);
-    } else if (isPlainObject(actionsMap)) {
-      return { ...fromActionsMap(actionsMap), ...fromIdentityActions(identityActions) };
-    }
+  invariant(
+    identityActions.every(isString) &&
+    (isString(actionsMap) || isPlainObject(actionsMap)),
+    'Expected optional object followed by string action types'
+  );
+  if (isString(actionsMap)) {
+    return fromIdentityActions([actionsMap, ...identityActions]);
   }
-
-  throw new TypeError('Expected optional object followed by string action types');
+  return { ...fromActionsMap(actionsMap), ...fromIdentityActions(identityActions) };
 }
 
 function isValidActionsMapValue(actionsMapValue) {
@@ -32,12 +33,11 @@ function isValidActionsMapValue(actionsMapValue) {
 
 function fromActionsMap(actionsMap) {
   return reduce(actionsMap, (actionCreatorsMap, actionsMapValue, type) => {
-    if (!isValidActionsMapValue(actionsMapValue)) {
-      throw new TypeError(
-        'Expected function, undefined, or array with payload and meta ' +
-        `functions for ${type}`);
-    }
-
+    invariant(
+      isValidActionsMapValue(actionsMapValue),
+      'Expected function, undefined, or array with payload and meta ' +
+      `functions for ${type}`
+    );
     const actionCreator = isArray(actionsMapValue)
       ? createAction(type, ...actionsMapValue)
       : createAction(type, actionsMapValue);
@@ -47,9 +47,7 @@ function fromActionsMap(actionsMap) {
 }
 
 function fromIdentityActions(identityActions) {
-  return fromActionsMap(
-    identityActions.reduce(
-      (actionsMap, actionType) => ({ ...actionsMap, [actionType]: identity })
-    , {})
-  );
+  return fromActionsMap(identityActions.reduce(
+    (actionsMap, actionType) => ({ ...actionsMap, [actionType]: identity })
+  , {}));
 }